Changeset c65afce4 in rtems


Ignore:
Timestamp:
Jul 7, 2012, 1:46:33 PM (7 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, master
Children:
545c71a, ad6c1f1
Parents:
c5ba8ba
git-author:
Sebastian Huber <sebastian.huber@…> (07/07/12 13:46:33)
git-committer:
Sebastian Huber <sebastian.huber@…> (07/11/12 15:14:51)
Message:

dosfs: Use fs_info instead of mt_entry

Location:
cpukit/libfs/src/dosfs
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libfs/src/dosfs/fat.c

    rc5ba8ba rc65afce4  
    162162 *
    163163 * PARAMETERS:
    164  *     mt_entry - mount table entry
     164 *     fs_info  - FS info
    165165 *     start    - sector num to start read from
    166166 *     offset   - offset inside sector 'start'
     
    174174ssize_t
    175175_fat_block_read(
    176     rtems_filesystem_mount_table_entry_t *mt_entry,
     176    fat_fs_info_t                        *fs_info,
    177177    uint32_t                              start,
    178178    uint32_t                              offset,
     
    182182{
    183183    int                     rc = RC_OK;
    184     register fat_fs_info_t *fs_info = mt_entry->fs_info;
    185184    ssize_t                 cmpltd = 0;
    186185    uint32_t                blk = start;
     
    213212 *
    214213 * PARAMETERS:
    215  *     mt_entry - mount table entry
     214 *     fs_info  - FS info
    216215 *     start    - sector num to start read from
    217216 *     offset   - offset inside sector 'start'
     
    225224ssize_t
    226225_fat_block_write(
    227     rtems_filesystem_mount_table_entry_t *mt_entry,
     226    fat_fs_info_t                        *fs_info,
    228227    uint32_t                              start,
    229228    uint32_t                              offset,
     
    232231{
    233232    int                 rc = RC_OK;
    234     fat_fs_info_t      *fs_info = mt_entry->fs_info;
    235233    ssize_t             cmpltd = 0;
    236234    uint32_t            blk  = start;
     
    264262int
    265263_fat_block_zero(
    266     rtems_filesystem_mount_table_entry_t *mt_entry,
     264    fat_fs_info_t                        *fs_info,
    267265    uint32_t                              start,
    268266    uint32_t                              offset,
     
    270268{
    271269    int                 rc = RC_OK;
    272     fat_fs_info_t      *fs_info = mt_entry->fs_info;
    273270    uint32_t            blk  = start;
    274271    uint32_t            ofs = offset;
     
    303300 *
    304301 * PARAMETERS:
    305  *     mt_entry - mount table entry
     302 *     fs_info  - FS info
    306303 *
    307304 * RETURNS:
     
    309306 */
    310307int
    311 _fat_block_release(
    312     rtems_filesystem_mount_table_entry_t *mt_entry)
    313 {
    314     fat_fs_info_t *fs_info = mt_entry->fs_info;
     308_fat_block_release(fat_fs_info_t *fs_info)
     309{
    315310    return fat_buf_release(fs_info);
    316311}
     
    320315 *
    321316 * PARAMETERS:
    322  *     mt_entry - mount table entry
     317 *     fs_info  - FS info
    323318 *     cln      - number of cluster to read
    324319 *     buff     - buffer provided by user
     
    330325ssize_t
    331326fat_cluster_read(
    332     rtems_filesystem_mount_table_entry_t *mt_entry,
     327    fat_fs_info_t                        *fs_info,
    333328    uint32_t                              cln,
    334329    void                                 *buff
    335330    )
    336331{
    337     fat_fs_info_t *fs_info = mt_entry->fs_info;
    338332    uint32_t       fsec = 0;
    339333
    340     fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
    341 
    342     return _fat_block_read(mt_entry, fsec, 0,
     334    fsec = fat_cluster_num_to_sector_num(fs_info, cln);
     335
     336    return _fat_block_read(fs_info, fsec, 0,
    343337                           fs_info->vol.spc << fs_info->vol.sec_log2, buff);
    344338}
     
    348342 *
    349343 * PARAMETERS:
    350  *     mt_entry - mount table entry
     344 *     fs_info  - FS info
    351345 *     cln      - number of cluster to write
    352346 *     buff     - buffer provided by user
     
    358352ssize_t
    359353fat_cluster_write(
    360     rtems_filesystem_mount_table_entry_t *mt_entry,
     354    fat_fs_info_t                        *fs_info,
    361355    uint32_t                              cln,
    362356    const void                           *buff
    363357    )
    364358{
    365     fat_fs_info_t *fs_info = mt_entry->fs_info;
    366359    uint32_t       fsec = 0;
    367360
    368     fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
    369 
    370     return _fat_block_write(mt_entry, fsec, 0,
     361    fsec = fat_cluster_num_to_sector_num(fs_info, cln);
     362
     363    return _fat_block_write(fs_info, fsec, 0,
    371364                          fs_info->vol.spc << fs_info->vol.sec_log2, buff);
    372365}
     
    376369 *
    377370 * PARAMETERS:
    378  *     mt_entry - mount table entry
     371 *     fs_info  - FS info
    379372 *
    380373 * RETURNS:
     
    383376 */
    384377int
    385 fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     378fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
    386379{
    387380    rtems_status_code   sc = RTEMS_SUCCESSFUL;
    388381    int                 rc = RC_OK;
    389     fat_fs_info_t      *fs_info = mt_entry->fs_info;
    390382    register fat_vol_t *vol = &fs_info->vol;
    391383    uint32_t            data_secs = 0;
     
    397389    rtems_bdbuf_buffer *block = NULL;
    398390
    399     vol->fd = open(mt_entry->dev, O_RDWR);
     391    vol->fd = open(device, O_RDWR);
    400392    if (vol->fd < 0)
    401393    {
     
    557549        else
    558550        {
    559             ret = _fat_block_read(mt_entry, vol->info_sec , 0,
     551            ret = _fat_block_read(fs_info, vol->info_sec , 0,
    560552                                  FAT_FSI_LEADSIG_SIZE, fs_info_sector);
    561553            if ( ret < 0 )
     
    568560                FAT_FSINFO_LEAD_SIGNATURE_VALUE)
    569561            {
    570                 _fat_block_release(mt_entry);
     562                _fat_block_release(fs_info);
    571563                close(vol->fd);
    572564                rtems_set_errno_and_return_minus_one( EINVAL );
     
    574566            else
    575567            {
    576                 ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
     568                ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
    577569                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
    578570                if ( ret < 0 )
    579571                {
    580                     _fat_block_release(mt_entry);
     572                    _fat_block_release(fs_info);
    581573                    close(vol->fd);
    582574                    return -1;
     
    585577                vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
    586578                vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
    587                 rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
     579                rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
    588580                                                    0xFFFFFFFF);
    589581                if ( rc != RC_OK )
    590582                {
    591                     _fat_block_release(mt_entry);
     583                    _fat_block_release(fs_info);
    592584                    close(vol->fd);
    593585                    return rc;
     
    605597    }
    606598
    607     _fat_block_release(mt_entry);
     599    _fat_block_release(fs_info);
    608600
    609601    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
     
    658650 *
    659651 * PARAMETERS:
    660  *     mt_entry - mount table entry
     652 *     fs_info  - FS info
    661653 *
    662654 * RETURNS:
     
    665657 */
    666658int
    667 fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
     659fat_shutdown_drive(fat_fs_info_t *fs_info)
    668660{
    669661    int            rc = RC_OK;
    670     fat_fs_info_t *fs_info = mt_entry->fs_info;
    671662    int            i = 0;
    672663
    673664    if (fs_info->vol.type & FAT_FAT32)
    674665    {
    675         rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
     666        rc = fat_fat32_update_fsinfo_sector(fs_info, fs_info->vol.free_cls,
    676667                                            fs_info->vol.next_cl);
    677668        if ( rc != RC_OK )
     
    718709 *
    719710 * PARAMETERS:
    720  *     mt_entry          - mount table entry
     711 *     fs_info           - FS info
    721712 *     start_cluster_num - num of first cluster in the chain
    722713 *
     
    727718int
    728719fat_init_clusters_chain(
    729     rtems_filesystem_mount_table_entry_t *mt_entry,
     720    fat_fs_info_t                        *fs_info,
    730721    uint32_t                              start_cln
    731722    )
     
    733724    int                     rc = RC_OK;
    734725    ssize_t                 ret = 0;
    735     register fat_fs_info_t *fs_info = mt_entry->fs_info;
    736726    uint32_t                cur_cln = start_cln;
    737727    char                   *buf;
     
    743733    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
    744734    {
    745         ret = fat_cluster_write(mt_entry, cur_cln, buf);
     735        ret = fat_cluster_write(fs_info, cur_cln, buf);
    746736        if ( ret == -1 )
    747737        {
     
    750740        }
    751741
    752         rc  = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
     742        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
    753743        if ( rc != RC_OK )
    754744        {
     
    777767 *
    778768 * PARAMETERS:
    779  *     mt_entry - mount table entry
     769 *     fs_info  - FS info
    780770 *
    781771 * RETURNS:
     
    788778 */
    789779uint32_t
    790 fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
    791 {
    792     register fat_fs_info_t *fs_info = mt_entry->fs_info;
     780fat_get_unique_ino(fat_fs_info_t *fs_info)
     781{
    793782    uint32_t                j = 0;
    794783    bool                    resrc_unsuff = false;
     
    827816 *
    828817 * PARAMETERS:
    829  *     mt_entry - mount table entry
     818 *     fs_info  - FS info
    830819 *     ino      - inode number to free
    831820 *
     
    835824void
    836825fat_free_unique_ino(
    837     rtems_filesystem_mount_table_entry_t *mt_entry,
     826    fat_fs_info_t                        *fs_info,
    838827    uint32_t                              ino
    839828    )
    840829{
    841     fat_fs_info_t *fs_info = mt_entry->fs_info;
    842 
    843830    FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
    844831}
     
    848835 *
    849836 * PARAMETERS:
    850  *     mt_entry - mount table entry
     837 *     fs_info  - FS info
    851838 *     ino   - ino to be tested
    852839 *
     
    856843inline bool
    857844fat_ino_is_unique(
    858     rtems_filesystem_mount_table_entry_t *mt_entry,
     845    fat_fs_info_t                        *fs_info,
    859846    uint32_t                              ino
    860847    )
    861848{
    862     fat_fs_info_t *fs_info = mt_entry->fs_info;
    863849
    864850    return (ino >= fs_info->uino_base);
     
    869855 *
    870856 * PARAMETERS:
    871  *     mt_entry   - mount table entry
     857 *     fs_info    - FS info
    872858 *     free_count - count of free clusters
    873859 *     next_free  - the next free cluster num
     
    878864int
    879865fat_fat32_update_fsinfo_sector(
    880     rtems_filesystem_mount_table_entry_t *mt_entry,
     866    fat_fs_info_t                        *fs_info,
    881867    uint32_t                              free_count,
    882868    uint32_t                              next_free
     
    884870{
    885871    ssize_t                 ret1 = 0, ret2 = 0;
    886     register fat_fs_info_t *fs_info = mt_entry->fs_info;
    887872    uint32_t                le_free_count = 0;
    888873    uint32_t                le_next_free = 0;
     
    891876    le_next_free = CT_LE_L(next_free);
    892877
    893     ret1 = _fat_block_write(mt_entry,
     878    ret1 = _fat_block_write(fs_info,
    894879                            fs_info->vol.info_sec,
    895880                            FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
     
    897882                            (char *)(&le_free_count));
    898883
    899     ret2 = _fat_block_write(mt_entry,
     884    ret2 = _fat_block_write(fs_info,
    900885                            fs_info->vol.info_sec,
    901886                            FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
  • cpukit/libfs/src/dosfs/fat.h

    rc5ba8ba rc65afce4  
    408408static inline uint32_t
    409409fat_cluster_num_to_sector_num(
    410     rtems_filesystem_mount_table_entry_t *mt_entry,
    411     uint32_t                              cln
     410    const fat_fs_info_t *fs_info,
     411    uint32_t             cln
    412412    )
    413413{
    414     register fat_fs_info_t *fs_info = mt_entry->fs_info;
    415 
    416414    if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
    417415        return fs_info->vol.rdir_loc;
     
    423421static inline uint32_t
    424422fat_cluster_num_to_sector512_num(
    425     rtems_filesystem_mount_table_entry_t *mt_entry,
    426     uint32_t                              cln
     423    const fat_fs_info_t *fs_info,
     424    uint32_t             cln
    427425    )
    428426{
    429     fat_fs_info_t *fs_info = mt_entry->fs_info;
    430 
    431427    if (cln == 1)
    432428        return 1;
    433429
    434     return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
     430    return (fat_cluster_num_to_sector_num(fs_info, cln) <<
    435431            fs_info->vol.sec_mul);
    436432}
     
    450446
    451447ssize_t
    452 _fat_block_read(rtems_filesystem_mount_table_entry_t *mt_entry,
     448_fat_block_read(fat_fs_info_t                        *fs_info,
    453449                uint32_t                              start,
    454450                uint32_t                              offset,
     
    457453
    458454ssize_t
    459 _fat_block_write(rtems_filesystem_mount_table_entry_t *mt_entry,
     455_fat_block_write(fat_fs_info_t                        *fs_info,
    460456                 uint32_t                              start,
    461457                 uint32_t                              offset,
     
    464460
    465461int
    466 _fat_block_zero(rtems_filesystem_mount_table_entry_t *mt_entry,
     462_fat_block_zero(fat_fs_info_t                         *fs_info,
    467463                 uint32_t                              start,
    468464                 uint32_t                              offset,
     
    470466
    471467int
    472 _fat_block_release(rtems_filesystem_mount_table_entry_t *mt_entry);
     468_fat_block_release(fat_fs_info_t *fs_info);
    473469
    474470ssize_t
    475 fat_cluster_read(rtems_filesystem_mount_table_entry_t *mt_entry,
     471fat_cluster_read(fat_fs_info_t                        *fs_info,
    476472                  uint32_t                             cln,
    477473                  void                                *buff);
    478474
    479475ssize_t
    480 fat_cluster_write(rtems_filesystem_mount_table_entry_t *mt_entry,
     476fat_cluster_write(fat_fs_info_t                        *fs_info,
    481477                   uint32_t                             cln,
    482478                   const void                          *buff);
    483479
    484480int
    485 fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry);
    486 
    487 int
    488 fat_init_clusters_chain(rtems_filesystem_mount_table_entry_t *mt_entry,
     481fat_init_volume_info(fat_fs_info_t *fs_info, const char *device);
     482
     483int
     484fat_init_clusters_chain(fat_fs_info_t                        *fs_info,
    489485                        uint32_t                              start_cln);
    490486
     487int
     488fat_shutdown_drive(fat_fs_info_t *fs_info);
     489
     490
    491491uint32_t
    492 fat_cluster_num_to_sector_num(rtems_filesystem_mount_table_entry_t *mt_entry,
    493                               uint32_t                              cln);
    494 
    495 int
    496 fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry);
    497 
    498 
    499 uint32_t
    500 fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry);
     492fat_get_unique_ino(fat_fs_info_t *fs_info);
    501493
    502494bool
    503 fat_ino_is_unique(rtems_filesystem_mount_table_entry_t *mt_entry,
     495fat_ino_is_unique(fat_fs_info_t                        *fs_info,
    504496                  uint32_t                              ino);
    505497
    506498void
    507 fat_free_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry,
     499fat_free_unique_ino(fat_fs_info_t                        *fs_info,
    508500                    uint32_t                              ino);
    509501
    510502int
    511503fat_fat32_update_fsinfo_sector(
    512   rtems_filesystem_mount_table_entry_t *mt_entry,
     504  fat_fs_info_t                        *fs_info,
    513505  uint32_t                              free_count,
    514506  uint32_t                              next_free
  • cpukit/libfs/src/dosfs/fat_fat_operations.c

    rc5ba8ba rc65afce4  
    2828 *
    2929 * PARAMETERS:
    30  *     mt_entry - mount table entry
     30 *     fs_info  - FS info
    3131 *     chain    - the number of the first allocated cluster (first cluster
    3232 *                in  the chain)
     
    4141int
    4242fat_scan_fat_for_free_clusters(
    43     rtems_filesystem_mount_table_entry_t *mt_entry,
     43    fat_fs_info_t                        *fs_info,
    4444    uint32_t                             *chain,
    4545    uint32_t                              count,
     
    5050{
    5151    int            rc = RC_OK;
    52     fat_fs_info_t *fs_info = mt_entry->fs_info;
    5352    uint32_t       cl4find = 2;
    5453    uint32_t       next_cln = 0;
     
    7271    while (i < data_cls_val)
    7372    {
    74         rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
     73        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
    7574        if ( rc != RC_OK )
    7675        {
    7776            if (*cls_added != 0)
    78                 fat_free_fat_clusters_chain(mt_entry, (*chain));
     77                fat_free_fat_clusters_chain(fs_info, (*chain));
    7978            return rc;
    8079        }
     
    9089            {
    9190                *chain = cl4find;
    92                 rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
     91                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
    9392                if ( rc != RC_OK )
    9493                {
     
    103102            {
    104103                /* set EOC value to new allocated cluster */
    105                 rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
     104                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
    106105                if ( rc != RC_OK )
    107106                {
    108107                    /* cleanup activity */
    109                     fat_free_fat_clusters_chain(mt_entry, (*chain));
     108                    fat_free_fat_clusters_chain(fs_info, (*chain));
    110109                    return rc;
    111110                }
    112111
    113                 rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
     112                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
    114113                if ( rc != RC_OK )
    115114                    goto cleanup;
     
    117116
    118117            if (zero_fill) {
    119                 uint32_t sec = fat_cluster_num_to_sector_num(mt_entry,
     118                uint32_t sec = fat_cluster_num_to_sector_num(fs_info,
    120119                                                             cl4find);
    121120
    122                 rc = _fat_block_zero(mt_entry, sec, 0, fs_info->vol.bpc);
     121                rc = _fat_block_zero(fs_info, sec, 0, fs_info->vol.bpc);
    123122                if ( rc != RC_OK )
    124123                    goto cleanup;
     
    156155
    157156    /* cleanup activity */
    158     fat_free_fat_clusters_chain(mt_entry, (*chain));
     157    fat_free_fat_clusters_chain(fs_info, (*chain));
    159158    /* trying to save last allocated cluster for future use */
    160     fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
     159    fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
    161160    fat_buf_release(fs_info);
    162161    return rc;
     
    167166 *
    168167 * PARAMETERS:
    169  *     mt_entry - mount table entry
     168 *     fs_info  - FS info
    170169 *     chain    - number of the first cluster in  the chain
    171170 *
     
    175174int
    176175fat_free_fat_clusters_chain(
    177     rtems_filesystem_mount_table_entry_t *mt_entry,
     176    fat_fs_info_t                        *fs_info,
    178177    uint32_t                              chain
    179178    )
    180179{
    181180    int            rc = RC_OK, rc1 = RC_OK;
    182     fat_fs_info_t *fs_info = mt_entry->fs_info;
    183181    uint32_t       cur_cln = chain;
    184182    uint32_t       next_cln = 0;
     
    187185    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
    188186    {
    189         rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
     187        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
    190188        if ( rc != RC_OK )
    191189        {
     
    197195        }
    198196
    199         rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
     197        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
    200198        if ( rc != RC_OK )
    201199            rc1 = rc;
     
    221219 *
    222220 * PARAMETERS:
    223  *     mt_entry - mount table entry
     221 *     fs_info  - FS info
    224222 *     cln      - number of cluster to fetch the contents from
    225223 *     ret_val  - contents of the cluster 'cln' (link to next cluster in
     
    232230int
    233231fat_get_fat_cluster(
    234     rtems_filesystem_mount_table_entry_t *mt_entry,
     232    fat_fs_info_t                        *fs_info,
    235233    uint32_t                              cln,
    236234    uint32_t                             *ret_val
     
    238236{
    239237    int                     rc = RC_OK;
    240     register fat_fs_info_t *fs_info = mt_entry->fs_info;
    241238    rtems_bdbuf_buffer     *block0 = NULL;
    242239    uint32_t                sec = 0;
     
    306303 *
    307304 * PARAMETERS:
    308  *     mt_entry - mount table entry
     305 *     fs_info  - FS info
    309306 *     cln      - number of cluster to set contents to
    310307 *     in_val   - value to set
     
    316313int
    317314fat_set_fat_cluster(
    318     rtems_filesystem_mount_table_entry_t *mt_entry,
     315    fat_fs_info_t                        *fs_info,
    319316    uint32_t                              cln,
    320317    uint32_t                              in_val
     
    322319{
    323320    int                 rc = RC_OK;
    324     fat_fs_info_t      *fs_info = mt_entry->fs_info;
    325321    uint32_t            sec = 0;
    326322    uint32_t            ofs = 0;
  • cpukit/libfs/src/dosfs/fat_fat_operations.h

    rc5ba8ba rc65afce4  
    2727
    2828int
    29 fat_get_fat_cluster(rtems_filesystem_mount_table_entry_t *mt_entry,
     29fat_get_fat_cluster(fat_fs_info_t                        *fs_info,
    3030                    uint32_t                              cln,
    3131                    uint32_t                             *ret_val);
    3232
    3333int
    34 fat_set_fat_cluster(rtems_filesystem_mount_table_entry_t *mt_entry,
     34fat_set_fat_cluster(fat_fs_info_t                        *fs_info,
    3535                    uint32_t                              cln,
    3636                    uint32_t                              in_val);
     
    3838int
    3939fat_scan_fat_for_free_clusters(
    40     rtems_filesystem_mount_table_entry_t *mt_entry,
     40    fat_fs_info_t                        *fs_info,
    4141    uint32_t                             *chain,
    4242    uint32_t                              count,
     
    4848int
    4949fat_free_fat_clusters_chain(
    50     rtems_filesystem_mount_table_entry_t *mt_entry,
     50    fat_fs_info_t                        *fs_info,
    5151    uint32_t                              chain
    5252);
  • cpukit/libfs/src/dosfs/fat_file.c

    rc5ba8ba rc65afce4  
    4141static inline int
    4242_hash_search(
    43     rtems_filesystem_mount_table_entry_t  *mt_entry,
     43    const fat_fs_info_t                   *fs_info,
    4444    rtems_chain_control                   *hash,
    4545    uint32_t                               key1,
     
    5050static off_t
    5151fat_file_lseek(
    52     rtems_filesystem_mount_table_entry_t  *mt_entry,
     52    fat_fs_info_t                         *fs_info,
    5353    fat_file_fd_t                         *fat_fd,
    5454    uint32_t                               file_cln,
     
    7373 *
    7474 * PARAMETERS:
    75  *     mt_entry - mount table entry
     75 *     fs_info  - FS info
    7676 *     pos      - cluster and offset of the node
    7777 *     fat_fd   - placeholder for returned fat-file descriptor
     
    8383int
    8484fat_file_open(
    85     rtems_filesystem_mount_table_entry_t  *mt_entry,
     85    fat_fs_info_t                         *fs_info,
    8686    fat_dir_pos_t                         *dir_pos,
    8787    fat_file_fd_t                        **fat_fd
     
    8989{
    9090    int            rc = RC_OK;
    91     fat_fs_info_t *fs_info = mt_entry->fs_info;
    9291    fat_file_fd_t *lfat_fd = NULL;
    9392    uint32_t       key = 0;
    9493
    9594    /* construct key */
    96     key = fat_construct_key(mt_entry, &dir_pos->sname);
     95    key = fat_construct_key(fs_info, &dir_pos->sname);
    9796
    9897    /* access "valid" hash table */
    99     rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
     98    rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
    10099    if ( rc == RC_OK )
    101100    {
     
    107106
    108107    /* access "removed-but-still-open" hash table */
    109     rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
     108    rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
    110109
    111110    lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
     
    125124    else
    126125    {
    127         lfat_fd->ino = fat_get_unique_ino(mt_entry);
     126        lfat_fd->ino = fat_get_unique_ino(fs_info);
    128127
    129128        if ( lfat_fd->ino == 0 )
     
    177176 *
    178177 * PARAMETERS:
    179  *     mt_entry - mount table entry
     178 *     fs_info  - FS info
    180179 *     fat_fd   - fat-file descriptor
    181180 *
     
    185184int
    186185fat_file_close(
    187     rtems_filesystem_mount_table_entry_t *mt_entry,
     186    fat_fs_info_t                        *fs_info,
    188187    fat_file_fd_t                        *fat_fd
    189188    )
    190189{
    191190    int            rc = RC_OK;
    192     fat_fs_info_t *fs_info = mt_entry->fs_info;
    193191    uint32_t       key = 0;
    194192
     
    203201    }
    204202
    205     key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
     203    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
    206204
    207205    if (fat_fd->flags & FAT_FILE_REMOVED)
    208206    {
    209         rc = fat_file_truncate(mt_entry, fat_fd, 0);
     207        rc = fat_file_truncate(fs_info, fat_fd, 0);
    210208        if ( rc != RC_OK )
    211209            return rc;
     
    213211        _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
    214212
    215         if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
    216             fat_free_unique_ino(mt_entry, fat_fd->ino);
     213        if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
     214            fat_free_unique_ino(fs_info, fat_fd->ino);
    217215
    218216        free(fat_fd);
     
    220218    else
    221219    {
    222         if (fat_ino_is_unique(mt_entry, fat_fd->ino))
     220        if (fat_ino_is_unique(fs_info, fat_fd->ino))
    223221        {
    224222            fat_fd->links_num = 0;
     
    244242 *
    245243 * PARAMETERS:
    246  *     mt_entry - mount table entry
     244 *     fs_info  - FS info
    247245 *     fat_fd   - fat-file descriptor
    248246 *     start    - offset in fat-file (in bytes) to read from
     
    256254ssize_t
    257255fat_file_read(
    258     rtems_filesystem_mount_table_entry_t *mt_entry,
     256    fat_fs_info_t                        *fs_info,
    259257    fat_file_fd_t                        *fat_fd,
    260258    uint32_t                              start,
     
    265263    int            rc = RC_OK;
    266264    ssize_t        ret = 0;
    267     fat_fs_info_t *fs_info = mt_entry->fs_info;
    268265    uint32_t       cmpltd = 0;
    269266    uint32_t       cur_cln = 0;
     
    294291        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
    295292    {
    296         sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
     293        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
    297294        sec += (start >> fs_info->vol.sec_log2);
    298295        byte = start & (fs_info->vol.bps - 1);
    299296
    300         ret = _fat_block_read(mt_entry, sec, byte, count, buf);
     297        ret = _fat_block_read(fs_info, sec, byte, count, buf);
    301298        if ( ret < 0 )
    302299            return -1;
     
    308305    save_ofs = ofs = start & (fs_info->vol.bpc - 1);
    309306
    310     rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
     307    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
    311308    if (rc != RC_OK)
    312309        return rc;
     
    316313        c = MIN(count, (fs_info->vol.bpc - ofs));
    317314
    318         sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
     315        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
    319316        sec += (ofs >> fs_info->vol.sec_log2);
    320317        byte = ofs & (fs_info->vol.bps - 1);
    321318
    322         ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
     319        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
    323320        if ( ret < 0 )
    324321            return -1;
     
    327324        cmpltd += c;
    328325        save_cln = cur_cln;
    329         rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
     326        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
    330327        if ( rc != RC_OK )
    331328            return rc;
     
    349346 *
    350347 * PARAMETERS:
    351  *     mt_entry - mount table entry
     348 *     fs_info  - FS info
    352349 *     fat_fd   - fat-file descriptor
    353350 *     start    - offset(in bytes) to write from
     
    361358ssize_t
    362359fat_file_write(
    363     rtems_filesystem_mount_table_entry_t *mt_entry,
     360    fat_fs_info_t                        *fs_info,
    364361    fat_file_fd_t                        *fat_fd,
    365362    uint32_t                              start,
     
    370367    int            rc = 0;
    371368    ssize_t        ret = 0;
    372     fat_fs_info_t *fs_info = mt_entry->fs_info;
    373369    uint32_t       cmpltd = 0;
    374370    uint32_t       cur_cln = 0;
     
    391387        count = fat_fd->size_limit - start;
    392388
    393     rc = fat_file_extend(mt_entry, fat_fd, zero_fill, start + count, &c);
     389    rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
    394390    if (rc != RC_OK)
    395391        return rc;
     
    405401        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
    406402    {
    407         sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
     403        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
    408404        sec += (start >> fs_info->vol.sec_log2);
    409405        byte = start & (fs_info->vol.bps - 1);
    410406
    411         ret = _fat_block_write(mt_entry, sec, byte, count, buf);
     407        ret = _fat_block_write(fs_info, sec, byte, count, buf);
    412408        if ( ret < 0 )
    413409            return -1;
     
    419415    save_ofs = ofs = start & (fs_info->vol.bpc - 1);
    420416
    421     rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
     417    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
    422418    if (rc != RC_OK)
    423419        return rc;
     
    427423        c = MIN(count, (fs_info->vol.bpc - ofs));
    428424
    429         sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
     425        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
    430426        sec += (ofs >> fs_info->vol.sec_log2);
    431427        byte = ofs & (fs_info->vol.bps - 1);
    432428
    433         ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
     429        ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
    434430        if ( ret < 0 )
    435431            return -1;
     
    438434        cmpltd += c;
    439435        save_cln = cur_cln;
    440         rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
     436        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
    441437        if ( rc != RC_OK )
    442438            return rc;
     
    461457 *
    462458 * PARAMETERS:
    463  *     mt_entry   - mount table entry
     459 *     fs_info    - FS info
    464460 *     fat_fd     - fat-file descriptor
    465461 *     new_length - new length
     
    472468int
    473469fat_file_extend(
    474     rtems_filesystem_mount_table_entry_t *mt_entry,
     470    fat_fs_info_t                        *fs_info,
    475471    fat_file_fd_t                        *fat_fd,
    476472    bool                                  zero_fill,
     
    480476{
    481477    int            rc = RC_OK;
    482     fat_fs_info_t *fs_info = mt_entry->fs_info;
    483478    uint32_t       chain = 0;
    484479    uint32_t       bytes2add = 0;
     
    517512        uint32_t byte;
    518513
    519         rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
     514        rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
    520515        if (rc != RC_OK)
    521516            return rc;
    522517
    523         sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
     518        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
    524519        sec += ofs >> fs_info->vol.sec_log2;
    525520        byte = ofs & (fs_info->vol.bps - 1);
    526521
    527         rc = _fat_block_zero(mt_entry, sec, byte, bytes_remain);
     522        rc = _fat_block_zero(fs_info, sec, byte, bytes_remain);
    528523        if (rc != RC_OK)
    529524            return rc;
     
    540535    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
    541536
    542     rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
     537    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
    543538                                        &cls_added, &last_cl, zero_fill);
    544539
     
    572567        else
    573568        {
    574             rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
     569            rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
    575570                                (fat_fd->fat_file_size - 1), &old_last_cl);
    576571            if ( rc != RC_OK )
    577572            {
    578                 fat_free_fat_clusters_chain(mt_entry, chain);
     573                fat_free_fat_clusters_chain(fs_info, chain);
    579574                return rc;
    580575            }
    581576        }
    582577
    583         rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
     578        rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
    584579        if ( rc != RC_OK )
    585580        {
    586             fat_free_fat_clusters_chain(mt_entry, chain);
     581            fat_free_fat_clusters_chain(fs_info, chain);
    587582            return rc;
    588583        }
     
    596591        if (fat_fd->fat_file_type == FAT_DIRECTORY)
    597592        {
    598             rc = fat_init_clusters_chain(mt_entry, chain);
     593            rc = fat_init_clusters_chain(fs_info, chain);
    599594            if ( rc != RC_OK )
    600595            {
    601                 fat_free_fat_clusters_chain(mt_entry, chain);
     596                fat_free_fat_clusters_chain(fs_info, chain);
    602597                return rc;
    603598            }
     
    617612 *
    618613 * PARAMETERS:
    619  *     mt_entry   - mount table entry
     614 *     fs_info    - FS info
    620615 *     fat_fd     - fat-file descriptor
    621616 *     new_length - new length
     
    626621int
    627622fat_file_truncate(
    628     rtems_filesystem_mount_table_entry_t *mt_entry,
     623    fat_fs_info_t                        *fs_info,
    629624    fat_file_fd_t                        *fat_fd,
    630625    uint32_t                              new_length
     
    632627{
    633628    int            rc = RC_OK;
    634     fat_fs_info_t *fs_info = mt_entry->fs_info;
    635629    uint32_t       cur_cln = 0;
    636630    uint32_t       cl_start = 0;
     
    650644    if (cl_start != 0)
    651645    {
    652         rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
     646        rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
    653647        if (rc != RC_OK)
    654648            return rc;
     
    656650    }
    657651
    658     rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
     652    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
    659653    if (rc != RC_OK)
    660654        return rc;
    661655
    662     rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
     656    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
    663657    if (rc != RC_OK)
    664658        return rc;
     
    666660    if (cl_start != 0)
    667661    {
    668         rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
     662        rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
    669663        if ( rc != RC_OK )
    670664            return rc;
     
    683677 * PARAMETERS:
    684678 *     fat_fd     - fat-file descriptor
    685  *     mt_entry   - mount table entry
     679 *     fs_info    - FS info
    686680 *     cmd        - command
    687681 *     ...
     
    692686int
    693687fat_file_ioctl(
    694     rtems_filesystem_mount_table_entry_t *mt_entry,
     688    fat_fs_info_t                        *fs_info,
    695689    fat_file_fd_t                        *fat_fd,
    696690    int                                   cmd,
     
    698692{
    699693    int            rc = RC_OK;
    700     fat_fs_info_t *fs_info = mt_entry->fs_info;
    701694    uint32_t       cur_cln = 0;
    702695    uint32_t       cl_start = 0;
     
    730723            cl_start = pos >> fs_info->vol.bpc_log2;
    731724
    732             rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
     725            rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
    733726            if ( rc != RC_OK )
    734727                break;
     
    752745 * PARAMETERS:
    753746 *     fat_fd     - fat-file descriptor
    754  *     mt_entry   - mount table entry
     747 *     fs_info    - FS info
    755748 *
    756749 * RETURNS:
     
    759752void
    760753fat_file_mark_removed(
    761     rtems_filesystem_mount_table_entry_t *mt_entry,
     754    fat_fs_info_t                        *fs_info,
    762755    fat_file_fd_t                        *fat_fd
    763756    )
    764757{
    765     fat_fs_info_t *fs_info = mt_entry->fs_info;
    766758    uint32_t       key = 0;
    767759
    768     key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
     760    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
    769761
    770762    _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
     
    785777 *
    786778 * PARAMETERS:
    787  *     mt_entry - mount table entry
     779 *     fs_info  - FS info
    788780 *     fat_fd   - fat-file descriptor
    789781 *
     
    793785int
    794786fat_file_size(
    795     rtems_filesystem_mount_table_entry_t *mt_entry,
     787    fat_fs_info_t                        *fs_info,
    796788    fat_file_fd_t                        *fat_fd
    797789    )
    798790{
    799791    int            rc = RC_OK;
    800     fat_fs_info_t *fs_info = mt_entry->fs_info;
    801792    uint32_t       cur_cln = fat_fd->cln;
    802793    uint32_t       save_cln = 0;
     
    815806    {
    816807        save_cln = cur_cln;
    817         rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
     808        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
    818809        if ( rc != RC_OK )
    819810            return rc;
     
    871862 *
    872863 * PARAMETERS:
    873  *     mt_entry - mount table entry
     864 *     fs_info  - FS info
    874865 *     hash     - hash element will be removed from
    875866 *     key1     - search key
     
    882873static inline int
    883874_hash_search(
    884     rtems_filesystem_mount_table_entry_t  *mt_entry,
     875    const fat_fs_info_t                   *fs_info,
    885876    rtems_chain_control                   *hash,
    886877    uint32_t                               key1,
     
    895886    {
    896887        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
    897         uint32_t       ck =  fat_construct_key(mt_entry, &ffd->dir_pos.sname);
     888        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
    898889
    899890        if ( (key1) == ck)
     
    912903static off_t
    913904fat_file_lseek(
    914     rtems_filesystem_mount_table_entry_t  *mt_entry,
     905    fat_fs_info_t                         *fs_info,
    915906    fat_file_fd_t                         *fat_fd,
    916907    uint32_t                               file_cln,
     
    942933        for (i = 0; i < count; i++)
    943934        {
    944             rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
     935            rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
    945936            if ( rc != RC_OK )
    946937                return rc;
  • cpukit/libfs/src/dosfs/fat_file.h

    rc5ba8ba rc65afce4  
    112112 *     cl       - cluster number
    113113 *     ofs      - offset inside cluster 'cl'
    114  *     mt_entry - mount table entry
     114 *     fs_info  - FS info
    115115 *
    116116 * RETURNS:
     
    119119static inline uint32_t
    120120fat_construct_key(
    121     rtems_filesystem_mount_table_entry_t *mt_entry,
     121    const fat_fs_info_t                  *fs_info,
    122122    fat_pos_t                            *pos)
    123123{
    124     return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
     124    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
    125125              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +
    126126              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
     
    129129/* Prototypes for "fat-file" operations */
    130130int
    131 fat_file_open(rtems_filesystem_mount_table_entry_t  *mt_entry,
     131fat_file_open(fat_fs_info_t                         *fs_info,
    132132              fat_dir_pos_t                         *dir_pos,
    133133              fat_file_fd_t                        **fat_fd);
     
    137137
    138138int
    139 fat_file_close(rtems_filesystem_mount_table_entry_t *mt_entry,
     139fat_file_close(fat_fs_info_t                        *fs_info,
    140140               fat_file_fd_t                        *fat_fd);
    141141
    142142ssize_t
    143 fat_file_read(rtems_filesystem_mount_table_entry_t *mt_entry,
     143fat_file_read(fat_fs_info_t                        *fs_info,
    144144              fat_file_fd_t                        *fat_fd,
    145145              uint32_t                              start,
     
    148148
    149149ssize_t
    150 fat_file_write(rtems_filesystem_mount_table_entry_t *mt_entry,
     150fat_file_write(fat_fs_info_t                        *fs_info,
    151151               fat_file_fd_t                        *fat_fd,
    152152               uint32_t                              start,
     
    155155
    156156int
    157 fat_file_extend(rtems_filesystem_mount_table_entry_t *mt_entry,
     157fat_file_extend(fat_fs_info_t                        *fs_info,
    158158                fat_file_fd_t                        *fat_fd,
    159159                bool                                  zero_fill,
     
    162162
    163163int
    164 fat_file_truncate(rtems_filesystem_mount_table_entry_t *mt_entry,
     164fat_file_truncate(fat_fs_info_t                        *fs_info,
    165165                  fat_file_fd_t                        *fat_fd,
    166166                  uint32_t                              new_length);
    167167
    168168int
    169 fat_file_ioctl(rtems_filesystem_mount_table_entry_t *mt_entry,
     169fat_file_ioctl(fat_fs_info_t                        *fs_info,
    170170               fat_file_fd_t                        *fat_fd,
    171171               int                                   cmd,
     
    173173
    174174int
    175 fat_file_size(rtems_filesystem_mount_table_entry_t *mt_entry,
     175fat_file_size(fat_fs_info_t                        *fs_info,
    176176              fat_file_fd_t                        *fat_fd);
    177177
    178178void
    179 fat_file_mark_removed(rtems_filesystem_mount_table_entry_t *mt_entry,
     179fat_file_mark_removed(fat_fs_info_t                        *fs_info,
    180180                      fat_file_fd_t                        *fat_fd);
    181181
  • cpukit/libfs/src/dosfs/msdos_create.c

    rc5ba8ba rc65afce4  
    123123       * read the original directory entry
    124124       */
    125       sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
     125      sec = fat_cluster_num_to_sector_num(&fs_info->fat,
    126126                                          link_fd->dir_pos.sname.cln);
    127127      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
    128128      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
    129129
    130       ret = _fat_block_read(parent_loc->mt_entry,
     130      ret = _fat_block_read(&fs_info->fat,
    131131                            sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
    132132                            link_node);
     
    176176    {
    177177        /* open new directory as fat-file */
    178         rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
     178        rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
    179179        if (rc != RC_OK)
    180180            goto err;
     
    226226         * by one cluster and entries will be written
    227227         */
    228         ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
     228        ret = fat_file_write(&fs_info->fat, fat_fd, 0,
    229229                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
    230230                             (uint8_t *)dot_dotdot);
     
    245245
    246246        /* rewrite dot entry */
    247         ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
     247        ret = fat_file_write(&fs_info->fat, fat_fd, 0,
    248248                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
    249249                             (uint8_t *)DOT_NODE_P(dot_dotdot));
     
    259259            goto error;
    260260
    261         fat_file_close(parent_loc->mt_entry, fat_fd);
     261        fat_file_close(&fs_info->fat, fat_fd);
    262262    }
    263263    return RC_OK;
    264264
    265265error:
    266     fat_file_close(parent_loc->mt_entry, fat_fd);
     266    fat_file_close(&fs_info->fat, fat_fd);
    267267
    268268err:
  • cpukit/libfs/src/dosfs/msdos_dir.c

    rc5ba8ba rc65afce4  
    171171         * present in the directory because there may be holes :)
    172172         */
    173         ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
     173        ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
    174174                            bts2rd, fs_info->cl_buf);
    175175        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
     
    315315
    316316                /* get number of cluster we are working with */
    317                 rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
     317                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
    318318                                    j * bts2rd, &cur_cln);
    319319                if (rc != RC_OK)
     
    326326                dir_pos.sname.cln = cur_cln;
    327327                dir_pos.sname.ofs = i;
    328                 rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
     328                rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
    329329                if (rc != RC_OK)
    330330                {
     
    378378
    379379                /* inode number extracted, close fat-file */
    380                 rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
     380                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
    381381                if (rc != RC_OK)
    382382                {
  • cpukit/libfs/src/dosfs/msdos_file.c

    rc5ba8ba rc65afce4  
    116116        rtems_set_errno_and_return_minus_one(EIO);
    117117
    118     ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
     118    ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
    119119                        buffer);
    120120    if (ret > 0)
     
    154154        iop->offset = fat_fd->fat_file_size;
    155155
    156     ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
     156    ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
    157157                         buffer);
    158158    if (ret < 0)
     
    237237    old_length = fat_fd->fat_file_size;
    238238    if (length < old_length) {
    239         rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
     239        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
    240240    } else {
    241241        uint32_t new_length;
    242242
    243         rc = fat_file_extend(iop->pathinfo.mt_entry,
     243        rc = fat_file_extend(&fs_info->fat,
    244244                             fat_fd,
    245245                             true,
     
    247247                             &new_length);
    248248        if (rc == RC_OK && length != new_length) {
    249             fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, old_length);
     249            fat_file_truncate(&fs_info->fat, fat_fd, old_length);
    250250            errno = ENOSPC;
    251251            rc = -1;
  • cpukit/libfs/src/dosfs/msdos_free.c

    rc5ba8ba rc65afce4  
    3232msdos_free_node_info(const rtems_filesystem_location_info_t *pathloc)
    3333{
    34     fat_file_close(pathloc->mt_entry, pathloc->node_access);
     34    msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
     35
     36    fat_file_close(&fs_info->fat, pathloc->node_access);
    3537}
  • cpukit/libfs/src/dosfs/msdos_fsunmount.c

    rc5ba8ba rc65afce4  
    4545
    4646    /* close fat-file which correspondes to root directory */
    47     fat_file_close(temp_mt_entry, fat_fd);
     47    fat_file_close(&fs_info->fat, fat_fd);
    4848
    49     fat_shutdown_drive(temp_mt_entry);
     49    fat_shutdown_drive(&fs_info->fat);
    5050
    5151    rtems_semaphore_delete(fs_info->vol_sema);
  • cpukit/libfs/src/dosfs/msdos_initsupp.c

    rc5ba8ba rc65afce4  
    6464    temp_mt_entry->fs_info = fs_info;
    6565
    66     rc = fat_init_volume_info(temp_mt_entry);
     66    rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
    6767    if (rc != RC_OK)
    6868    {
     
    8080    fat_dir_pos_init(&root_pos);
    8181    root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
    82     rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
     82    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
    8383    if (rc != RC_OK)
    8484    {
    85         fat_shutdown_drive(temp_mt_entry);
     85        fat_shutdown_drive(&fs_info->fat);
    8686        free(fs_info);
    8787        return rc;
     
    106106    else
    107107    {
    108         rc = fat_file_size(temp_mt_entry, fat_fd);
     108        rc = fat_file_size(&fs_info->fat, fat_fd);
    109109        if ( rc != RC_OK )
    110110        {
    111             fat_file_close(temp_mt_entry, fat_fd);
    112             fat_shutdown_drive(temp_mt_entry);
     111            fat_file_close(&fs_info->fat, fat_fd);
     112            fat_shutdown_drive(&fs_info->fat);
    113113            free(fs_info);
    114114            return rc;
     
    120120    if (fs_info->cl_buf == NULL)
    121121    {
    122         fat_file_close(temp_mt_entry, fat_fd);
    123         fat_shutdown_drive(temp_mt_entry);
     122        fat_file_close(&fs_info->fat, fat_fd);
     123        fat_shutdown_drive(&fs_info->fat);
    124124        free(fs_info);
    125125        rtems_set_errno_and_return_minus_one(ENOMEM);
     
    133133    if (sc != RTEMS_SUCCESSFUL)
    134134    {
    135         fat_file_close(temp_mt_entry, fat_fd);
    136         fat_shutdown_drive(temp_mt_entry);
     135        fat_file_close(&fs_info->fat, fat_fd);
     136        fat_shutdown_drive(&fs_info->fat);
    137137        free(fs_info->cl_buf);
    138138        free(fs_info);
  • cpukit/libfs/src/dosfs/msdos_misc.c

    rc5ba8ba rc65afce4  
    307307
    308308    /* open fat-file corresponded to the found node */
    309     rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
     309    rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
    310310    if (rc != RC_OK)
    311311        return rc;
     
    334334            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
    335335
    336             rc = fat_file_size(parent_loc->mt_entry, fat_fd);
     336            rc = fat_file_size(&fs_info->fat, fat_fd);
    337337            if (rc != RC_OK)
    338338            {
    339                 fat_file_close(parent_loc->mt_entry, fat_fd);
     339                fat_file_close(&fs_info->fat, fat_fd);
    340340                return rc;
    341341            }
     
    364364
    365365    /* close fat-file corresponded to the node we searched in */
    366     rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
     366    rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
    367367    if (rc != RC_OK)
    368368    {
    369         fat_file_close(parent_loc->mt_entry, fat_fd);
     369        fat_file_close(&fs_info->fat, fat_fd);
    370370        return rc;
    371371    }
     
    518518     * open fat-file corresponded to ".."
    519519     */
    520     rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
     520    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
    521521    if (rc != RC_OK)
    522522        return rc;
     
    529529    fat_fd->map.disk_cln = fat_fd->cln;
    530530
    531     rc = fat_file_size(mt_entry, fat_fd);
     531    rc = fat_file_size(&fs_info->fat, fat_fd);
    532532    if (rc != RC_OK)
    533533    {
    534         fat_file_close(mt_entry, fat_fd);
     534        fat_file_close(&fs_info->fat, fat_fd);
    535535        return rc;
    536536    }
     
    544544    if (rc != RC_OK)
    545545    {
    546         fat_file_close(mt_entry, fat_fd);
     546        fat_file_close(&fs_info->fat, fat_fd);
    547547        return rc;
    548548    }
     
    557557    if (rc != RC_OK)
    558558    {
    559         fat_file_close(mt_entry, fat_fd);
     559        fat_file_close(&fs_info->fat, fat_fd);
    560560        return rc;
    561561    }
     
    564564
    565565    /* close fat-file corresponded to ".." directory */
    566     rc = fat_file_close(mt_entry, fat_fd);
     566    rc = fat_file_close(&fs_info->fat, fat_fd);
    567567    if ( rc != RC_OK )
    568568        return rc;
     
    579579
    580580    /* open fat-file corresponded to second ".." */
    581     rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
     581    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
    582582    if (rc != RC_OK)
    583583        return rc;
     
    594594    fat_fd->map.disk_cln = fat_fd->cln;
    595595
    596     rc = fat_file_size(mt_entry, fat_fd);
     596    rc = fat_file_size(&fs_info->fat, fat_fd);
    597597    if (rc != RC_OK)
    598598    {
    599         fat_file_close(mt_entry, fat_fd);
     599        fat_file_close(&fs_info->fat, fat_fd);
    600600        return rc;
    601601    }
     
    606606    if (rc != RC_OK)
    607607    {
    608         fat_file_close(mt_entry, fat_fd);
     608        fat_file_close(&fs_info->fat, fat_fd);
    609609        return rc;
    610610    }
    611     rc = fat_file_close(mt_entry, fat_fd);
     611    rc = fat_file_close(&fs_info->fat, fat_fd);
    612612    return rc;
    613613}
     
    645645     * (sector num, new offset)
    646646     */
    647     sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
     647    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    648648    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
    649649    /* byte points to start of 32bytes structure */
     
    651651
    652652    time_val = CT_LE_W(time_val);
    653     ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
     653    ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
    654654                            2, (char *)(&time_val));
    655655    date = CT_LE_W(date);
    656     ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
     656    ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
    657657                            2, (char *)(&date));
    658     ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
     658    ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
    659659                            2, (char *)(&date));
    660660
     
    695695     * (sector num, new offset)
    696696     */
    697     sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
     697    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    698698    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
    699699    /* byte from points to start of 32bytes structure */
     
    701701
    702702    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));
    703     ret1 = _fat_block_write(mt_entry, sec,
     703    ret1 = _fat_block_write(&fs_info->fat, sec,
    704704                            byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
    705705                            (char *)(&le_cl_low));
    706706    le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));
    707     ret2 = _fat_block_write(mt_entry, sec,
     707    ret2 = _fat_block_write(&fs_info->fat, sec,
    708708                            byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
    709709                            (char *)(&le_cl_hi));
     
    738738    uint32_t         byte = 0;
    739739
    740     sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
     740    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
    741741    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
    742742    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
    743743
    744744    le_new_length = CT_LE_L((fat_fd->fat_file_size));
    745     ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
     745    ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
    746746                           (char *)(&le_new_length));
    747747    if ( ret < 0 )
     
    799799    while (true)
    800800    {
    801       uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
     801      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
    802802                      (start.ofs >> fs_info->fat.vol.sec_log2));
    803803      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
    804804
    805       ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
    806                              &fchar);
     805      ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
     806                             1, &fchar);
    807807      if (ret < 0)
    808808        return -1;
     
    818818            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
    819819          break;
    820         rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
     820        rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
    821821        if ( rc != RC_OK )
    822822          return rc;
     
    855855    *ret_val = false;
    856856
    857     while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
     857    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
    858858                                  fs_info->fat.vol.bps,
    859859                                  fs_info->cl_buf)) != FAT_EOF)
     
    999999     * create the entry if the name is not found.
    10001000     */
    1001     while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
     1001    while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
    10021002                                bts2rd, fs_info->cl_buf)) != FAT_EOF)
    10031003    {
     
    12831283                         * structure and the 32 bytes of the short entry
    12841284                         */
    1285                         int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
     1285                        int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
    12861286                                                dir_offset * bts2rd,
    12871287                                                &dir_pos->sname.cln);
     
    12931293                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)
    12941294                        {
    1295                           rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
     1295                          rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
    12961296                                              lfn_start.cln * bts2rd,
    12971297                                              &lfn_start.cln);
     
    13981398          printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
    13991399#endif
    1400           ret = fat_file_read(mt_entry, fat_fd,
     1400          ret = fat_file_read(&fs_info->fat, fat_fd,
    14011401                              (empty_space_offset * bts2rd), bts2rd,
    14021402                              fs_info->cl_buf);
     
    14101410            printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
    14111411#endif
    1412             ret = fat_file_extend (mt_entry, fat_fd, false,
     1412            ret = fat_file_extend (&fs_info->fat, fat_fd, false,
    14131413                                   empty_space_offset * bts2rd, &new_length);
    14141414
     
    14241424            memset(fs_info->cl_buf, 0, bts2rd);
    14251425
    1426             ret = fat_file_write(mt_entry, fat_fd,
     1426            ret = fat_file_write(&fs_info->fat, fat_fd,
    14271427                                 empty_space_offset * bts2rd,
    14281428                                 bts2rd, fs_info->cl_buf);
     
    14651465            {
    14661466                /* get current cluster number */
    1467                 int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
     1467                int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
    14681468                                        empty_space_offset * bts2rd,
    14691469                                        &dir_pos->sname.cln);
     
    14751475                if (lfn_start.cln != FAT_FILE_SHORT_NAME)
    14761476                {
    1477                   rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
     1477                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
    14781478                                      lfn_start.cln * bts2rd,
    14791479                                      &lfn_start.cln);
     
    15471547        }
    15481548
    1549         ret = fat_file_write(mt_entry, fat_fd,
     1549        ret = fat_file_write(&fs_info->fat, fat_fd,
    15501550                             (empty_space_offset * bts2rd) + empty_space_entry,
    15511551                             length, fs_info->cl_buf + empty_space_entry);
     
    16011601        bts2rd = fs_info->fat.vol.bpc;
    16021602
    1603     while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
     1603    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
    16041604                                  fs_info->cl_buf)) != FAT_EOF)
    16051605    {
     
    16271627            {
    16281628                /* on success fill aux structure and copy all 32 bytes */
    1629                 rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
     1629                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
    16301630                                    &dir_pos->sname.cln);
    16311631                if (rc != RC_OK)
  • cpukit/libfs/src/dosfs/msdos_rmnod.c

    rc5ba8ba rc65afce4  
    2121{
    2222    int                rc = RC_OK;
     23    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;
    2324    fat_file_fd_t     *fat_fd = pathloc->node_access;
    2425
     
    7273    }
    7374
    74     fat_file_mark_removed(pathloc->mt_entry, fat_fd);
     75    fat_file_mark_removed(&fs_info->fat, fat_fd);
    7576
    7677    return rc;
Note: See TracChangeset for help on using the changeset viewer.