Index: cpukit/libfs/src/dosfs/fat.c
===================================================================
--- cpukit/libfs/src/dosfs/fat.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -162,5 +162,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     start    - sector num to start read from
  *     offset   - offset inside sector 'start'
@@ -174,5 +174,5 @@
 ssize_t
 _fat_block_read(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              start,
     uint32_t                              offset,
@@ -182,5 +182,4 @@
 {
     int                     rc = RC_OK;
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
     ssize_t                 cmpltd = 0;
     uint32_t                blk = start;
@@ -213,5 +212,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     start    - sector num to start read from
  *     offset   - offset inside sector 'start'
@@ -225,5 +224,5 @@
 ssize_t
 _fat_block_write(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              start,
     uint32_t                              offset,
@@ -232,5 +231,4 @@
 {
     int                 rc = RC_OK;
-    fat_fs_info_t      *fs_info = mt_entry->fs_info;
     ssize_t             cmpltd = 0;
     uint32_t            blk  = start;
@@ -264,5 +262,5 @@
 int
 _fat_block_zero(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              start,
     uint32_t                              offset,
@@ -270,5 +268,4 @@
 {
     int                 rc = RC_OK;
-    fat_fs_info_t      *fs_info = mt_entry->fs_info;
     uint32_t            blk  = start;
     uint32_t            ofs = offset;
@@ -303,5 +300,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *
  * RETURNS:
@@ -309,8 +306,6 @@
  */
 int
-_fat_block_release(
-    rtems_filesystem_mount_table_entry_t *mt_entry)
-{
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
+_fat_block_release(fat_fs_info_t *fs_info)
+{
     return fat_buf_release(fs_info);
 }
@@ -320,5 +315,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     cln      - number of cluster to read
  *     buff     - buffer provided by user
@@ -330,15 +325,14 @@
 ssize_t
 fat_cluster_read(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              cln,
     void                                 *buff
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       fsec = 0;
 
-    fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
-
-    return _fat_block_read(mt_entry, fsec, 0,
+    fsec = fat_cluster_num_to_sector_num(fs_info, cln);
+
+    return _fat_block_read(fs_info, fsec, 0,
                            fs_info->vol.spc << fs_info->vol.sec_log2, buff);
 }
@@ -348,5 +342,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     cln      - number of cluster to write
  *     buff     - buffer provided by user
@@ -358,15 +352,14 @@
 ssize_t
 fat_cluster_write(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              cln,
     const void                           *buff
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       fsec = 0;
 
-    fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
-
-    return _fat_block_write(mt_entry, fsec, 0,
+    fsec = fat_cluster_num_to_sector_num(fs_info, cln);
+
+    return _fat_block_write(fs_info, fsec, 0,
                           fs_info->vol.spc << fs_info->vol.sec_log2, buff);
 }
@@ -376,5 +369,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *
  * RETURNS:
@@ -383,9 +376,8 @@
  */
 int
-fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
+fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
 {
     rtems_status_code   sc = RTEMS_SUCCESSFUL;
     int                 rc = RC_OK;
-    fat_fs_info_t      *fs_info = mt_entry->fs_info;
     register fat_vol_t *vol = &fs_info->vol;
     uint32_t            data_secs = 0;
@@ -397,5 +389,5 @@
     rtems_bdbuf_buffer *block = NULL;
 
-    vol->fd = open(mt_entry->dev, O_RDWR);
+    vol->fd = open(device, O_RDWR);
     if (vol->fd < 0)
     {
@@ -557,5 +549,5 @@
         else
         {
-            ret = _fat_block_read(mt_entry, vol->info_sec , 0,
+            ret = _fat_block_read(fs_info, vol->info_sec , 0,
                                   FAT_FSI_LEADSIG_SIZE, fs_info_sector);
             if ( ret < 0 )
@@ -568,5 +560,5 @@
                 FAT_FSINFO_LEAD_SIGNATURE_VALUE)
             {
-                _fat_block_release(mt_entry);
+                _fat_block_release(fs_info);
                 close(vol->fd);
                 rtems_set_errno_and_return_minus_one( EINVAL );
@@ -574,9 +566,9 @@
             else
             {
-                ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
+                ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
                                       FAT_USEFUL_INFO_SIZE, fs_info_sector);
                 if ( ret < 0 )
                 {
-                    _fat_block_release(mt_entry);
+                    _fat_block_release(fs_info);
                     close(vol->fd);
                     return -1;
@@ -585,9 +577,9 @@
                 vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
                 vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
-                rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
+                rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
                                                     0xFFFFFFFF);
                 if ( rc != RC_OK )
                 {
-                    _fat_block_release(mt_entry);
+                    _fat_block_release(fs_info);
                     close(vol->fd);
                     return rc;
@@ -605,5 +597,5 @@
     }
 
-    _fat_block_release(mt_entry);
+    _fat_block_release(fs_info);
 
     vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
@@ -658,5 +650,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *
  * RETURNS:
@@ -665,13 +657,12 @@
  */
 int
-fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
+fat_shutdown_drive(fat_fs_info_t *fs_info)
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     int            i = 0;
 
     if (fs_info->vol.type & FAT_FAT32)
     {
-        rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
+        rc = fat_fat32_update_fsinfo_sector(fs_info, fs_info->vol.free_cls,
                                             fs_info->vol.next_cl);
         if ( rc != RC_OK )
@@ -718,5 +709,5 @@
  *
  * PARAMETERS:
- *     mt_entry          - mount table entry
+ *     fs_info           - FS info
  *     start_cluster_num - num of first cluster in the chain
  *
@@ -727,5 +718,5 @@
 int
 fat_init_clusters_chain(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              start_cln
     )
@@ -733,5 +724,4 @@
     int                     rc = RC_OK;
     ssize_t                 ret = 0;
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t                cur_cln = start_cln;
     char                   *buf;
@@ -743,5 +733,5 @@
     while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
     {
-        ret = fat_cluster_write(mt_entry, cur_cln, buf);
+        ret = fat_cluster_write(fs_info, cur_cln, buf);
         if ( ret == -1 )
         {
@@ -750,5 +740,5 @@
         }
 
-        rc  = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
+        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
         if ( rc != RC_OK )
         {
@@ -777,5 +767,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *
  * RETURNS:
@@ -788,7 +778,6 @@
  */
 uint32_t
-fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
-{
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
+fat_get_unique_ino(fat_fs_info_t *fs_info)
+{
     uint32_t                j = 0;
     bool                    resrc_unsuff = false;
@@ -827,5 +816,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     ino      - inode number to free
  *
@@ -835,10 +824,8 @@
 void
 fat_free_unique_ino(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              ino
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
-
     FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
 }
@@ -848,5 +835,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     ino   - ino to be tested
  *
@@ -856,9 +843,8 @@
 inline bool
 fat_ino_is_unique(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              ino
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
 
     return (ino >= fs_info->uino_base);
@@ -869,5 +855,5 @@
  *
  * PARAMETERS:
- *     mt_entry   - mount table entry
+ *     fs_info    - FS info
  *     free_count - count of free clusters
  *     next_free  - the next free cluster num
@@ -878,5 +864,5 @@
 int
 fat_fat32_update_fsinfo_sector(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              free_count,
     uint32_t                              next_free
@@ -884,5 +870,4 @@
 {
     ssize_t                 ret1 = 0, ret2 = 0;
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t                le_free_count = 0;
     uint32_t                le_next_free = 0;
@@ -891,5 +876,5 @@
     le_next_free = CT_LE_L(next_free);
 
-    ret1 = _fat_block_write(mt_entry,
+    ret1 = _fat_block_write(fs_info,
                             fs_info->vol.info_sec,
                             FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
@@ -897,5 +882,5 @@
                             (char *)(&le_free_count));
 
-    ret2 = _fat_block_write(mt_entry,
+    ret2 = _fat_block_write(fs_info,
                             fs_info->vol.info_sec,
                             FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
Index: cpukit/libfs/src/dosfs/fat.h
===================================================================
--- cpukit/libfs/src/dosfs/fat.h	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat.h	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -408,10 +408,8 @@
 static inline uint32_t
 fat_cluster_num_to_sector_num(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
-    uint32_t                              cln
+    const fat_fs_info_t *fs_info,
+    uint32_t             cln
     )
 {
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
-
     if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
         return fs_info->vol.rdir_loc;
@@ -423,14 +421,12 @@
 static inline uint32_t
 fat_cluster_num_to_sector512_num(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
-    uint32_t                              cln
+    const fat_fs_info_t *fs_info,
+    uint32_t             cln
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
-
     if (cln == 1)
         return 1;
 
-    return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
+    return (fat_cluster_num_to_sector_num(fs_info, cln) <<
             fs_info->vol.sec_mul);
 }
@@ -450,5 +446,5 @@
 
 ssize_t
-_fat_block_read(rtems_filesystem_mount_table_entry_t *mt_entry,
+_fat_block_read(fat_fs_info_t                        *fs_info,
                 uint32_t                              start,
                 uint32_t                              offset,
@@ -457,5 +453,5 @@
 
 ssize_t
-_fat_block_write(rtems_filesystem_mount_table_entry_t *mt_entry,
+_fat_block_write(fat_fs_info_t                        *fs_info,
                  uint32_t                              start,
                  uint32_t                              offset,
@@ -464,5 +460,5 @@
 
 int
-_fat_block_zero(rtems_filesystem_mount_table_entry_t *mt_entry,
+_fat_block_zero(fat_fs_info_t                         *fs_info,
                  uint32_t                              start,
                  uint32_t                              offset,
@@ -470,45 +466,41 @@
 
 int
-_fat_block_release(rtems_filesystem_mount_table_entry_t *mt_entry);
+_fat_block_release(fat_fs_info_t *fs_info);
 
 ssize_t
-fat_cluster_read(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_cluster_read(fat_fs_info_t                        *fs_info,
                   uint32_t                             cln,
                   void                                *buff);
 
 ssize_t
-fat_cluster_write(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_cluster_write(fat_fs_info_t                        *fs_info,
                    uint32_t                             cln,
                    const void                          *buff);
 
 int
-fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry);
-
-int
-fat_init_clusters_chain(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_init_volume_info(fat_fs_info_t *fs_info, const char *device);
+
+int
+fat_init_clusters_chain(fat_fs_info_t                        *fs_info,
                         uint32_t                              start_cln);
 
+int
+fat_shutdown_drive(fat_fs_info_t *fs_info);
+
+
 uint32_t
-fat_cluster_num_to_sector_num(rtems_filesystem_mount_table_entry_t *mt_entry,
-                              uint32_t                              cln);
-
-int
-fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry);
-
-
-uint32_t
-fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry);
+fat_get_unique_ino(fat_fs_info_t *fs_info);
 
 bool
-fat_ino_is_unique(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_ino_is_unique(fat_fs_info_t                        *fs_info,
                   uint32_t                              ino);
 
 void
-fat_free_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_free_unique_ino(fat_fs_info_t                        *fs_info,
                     uint32_t                              ino);
 
 int
 fat_fat32_update_fsinfo_sector(
-  rtems_filesystem_mount_table_entry_t *mt_entry,
+  fat_fs_info_t                        *fs_info,
   uint32_t                              free_count,
   uint32_t                              next_free
Index: cpukit/libfs/src/dosfs/fat_fat_operations.c
===================================================================
--- cpukit/libfs/src/dosfs/fat_fat_operations.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat_fat_operations.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -28,5 +28,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     chain    - the number of the first allocated cluster (first cluster
  *                in  the chain)
@@ -41,5 +41,5 @@
 int
 fat_scan_fat_for_free_clusters(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                             *chain,
     uint32_t                              count,
@@ -50,5 +50,4 @@
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cl4find = 2;
     uint32_t       next_cln = 0;
@@ -72,9 +71,9 @@
     while (i < data_cls_val)
     {
-        rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
+        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
         if ( rc != RC_OK )
         {
             if (*cls_added != 0)
-                fat_free_fat_clusters_chain(mt_entry, (*chain));
+                fat_free_fat_clusters_chain(fs_info, (*chain));
             return rc;
         }
@@ -90,5 +89,5 @@
             {
                 *chain = cl4find;
-                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
+                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
                 if ( rc != RC_OK )
                 {
@@ -103,13 +102,13 @@
             {
                 /* set EOC value to new allocated cluster */
-                rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
+                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
                 if ( rc != RC_OK )
                 {
                     /* cleanup activity */
-                    fat_free_fat_clusters_chain(mt_entry, (*chain));
+                    fat_free_fat_clusters_chain(fs_info, (*chain));
                     return rc;
                 }
 
-                rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
+                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
                 if ( rc != RC_OK )
                     goto cleanup;
@@ -117,8 +116,8 @@
 
             if (zero_fill) {
-                uint32_t sec = fat_cluster_num_to_sector_num(mt_entry,
+                uint32_t sec = fat_cluster_num_to_sector_num(fs_info,
                                                              cl4find);
 
-                rc = _fat_block_zero(mt_entry, sec, 0, fs_info->vol.bpc);
+                rc = _fat_block_zero(fs_info, sec, 0, fs_info->vol.bpc);
                 if ( rc != RC_OK )
                     goto cleanup;
@@ -156,7 +155,7 @@
 
     /* cleanup activity */
-    fat_free_fat_clusters_chain(mt_entry, (*chain));
+    fat_free_fat_clusters_chain(fs_info, (*chain));
     /* trying to save last allocated cluster for future use */
-    fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
+    fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
     fat_buf_release(fs_info);
     return rc;
@@ -167,5 +166,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     chain    - number of the first cluster in  the chain
  *
@@ -175,10 +174,9 @@
 int
 fat_free_fat_clusters_chain(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              chain
     )
 {
     int            rc = RC_OK, rc1 = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cur_cln = chain;
     uint32_t       next_cln = 0;
@@ -187,5 +185,5 @@
     while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
     {
-        rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
+        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
         if ( rc != RC_OK )
         {
@@ -197,5 +195,5 @@
         }
 
-        rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
+        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
         if ( rc != RC_OK )
             rc1 = rc;
@@ -221,5 +219,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     cln      - number of cluster to fetch the contents from
  *     ret_val  - contents of the cluster 'cln' (link to next cluster in
@@ -232,5 +230,5 @@
 int
 fat_get_fat_cluster(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              cln,
     uint32_t                             *ret_val
@@ -238,5 +236,4 @@
 {
     int                     rc = RC_OK;
-    register fat_fs_info_t *fs_info = mt_entry->fs_info;
     rtems_bdbuf_buffer     *block0 = NULL;
     uint32_t                sec = 0;
@@ -306,5 +303,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     cln      - number of cluster to set contents to
  *     in_val   - value to set
@@ -316,5 +313,5 @@
 int
 fat_set_fat_cluster(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              cln,
     uint32_t                              in_val
@@ -322,5 +319,4 @@
 {
     int                 rc = RC_OK;
-    fat_fs_info_t      *fs_info = mt_entry->fs_info;
     uint32_t            sec = 0;
     uint32_t            ofs = 0;
Index: cpukit/libfs/src/dosfs/fat_fat_operations.h
===================================================================
--- cpukit/libfs/src/dosfs/fat_fat_operations.h	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat_fat_operations.h	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -27,10 +27,10 @@
 
 int
-fat_get_fat_cluster(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_get_fat_cluster(fat_fs_info_t                        *fs_info,
                     uint32_t                              cln,
                     uint32_t                             *ret_val);
 
 int
-fat_set_fat_cluster(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_set_fat_cluster(fat_fs_info_t                        *fs_info,
                     uint32_t                              cln,
                     uint32_t                              in_val);
@@ -38,5 +38,5 @@
 int
 fat_scan_fat_for_free_clusters(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                             *chain,
     uint32_t                              count,
@@ -48,5 +48,5 @@
 int
 fat_free_fat_clusters_chain(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     uint32_t                              chain
 );
Index: cpukit/libfs/src/dosfs/fat_file.c
===================================================================
--- cpukit/libfs/src/dosfs/fat_file.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat_file.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -41,5 +41,5 @@
 static inline int
 _hash_search(
-    rtems_filesystem_mount_table_entry_t  *mt_entry,
+    const fat_fs_info_t                   *fs_info,
     rtems_chain_control                   *hash,
     uint32_t                               key1,
@@ -50,5 +50,5 @@
 static off_t
 fat_file_lseek(
-    rtems_filesystem_mount_table_entry_t  *mt_entry,
+    fat_fs_info_t                         *fs_info,
     fat_file_fd_t                         *fat_fd,
     uint32_t                               file_cln,
@@ -73,5 +73,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     pos      - cluster and offset of the node
  *     fat_fd   - placeholder for returned fat-file descriptor
@@ -83,5 +83,5 @@
 int
 fat_file_open(
-    rtems_filesystem_mount_table_entry_t  *mt_entry,
+    fat_fs_info_t                         *fs_info,
     fat_dir_pos_t                         *dir_pos,
     fat_file_fd_t                        **fat_fd
@@ -89,13 +89,12 @@
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     fat_file_fd_t *lfat_fd = NULL;
     uint32_t       key = 0;
 
     /* construct key */
-    key = fat_construct_key(mt_entry, &dir_pos->sname);
+    key = fat_construct_key(fs_info, &dir_pos->sname);
 
     /* access "valid" hash table */
-    rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
+    rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
     if ( rc == RC_OK )
     {
@@ -107,5 +106,5 @@
 
     /* access "removed-but-still-open" hash table */
-    rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
+    rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
 
     lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
@@ -125,5 +124,5 @@
     else
     {
-        lfat_fd->ino = fat_get_unique_ino(mt_entry);
+        lfat_fd->ino = fat_get_unique_ino(fs_info);
 
         if ( lfat_fd->ino == 0 )
@@ -177,5 +176,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     fat_fd   - fat-file descriptor
  *
@@ -185,10 +184,9 @@
 int
 fat_file_close(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd
     )
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       key = 0;
 
@@ -203,9 +201,9 @@
     }
 
-    key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
+    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
 
     if (fat_fd->flags & FAT_FILE_REMOVED)
     {
-        rc = fat_file_truncate(mt_entry, fat_fd, 0);
+        rc = fat_file_truncate(fs_info, fat_fd, 0);
         if ( rc != RC_OK )
             return rc;
@@ -213,6 +211,6 @@
         _hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
 
-        if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
-            fat_free_unique_ino(mt_entry, fat_fd->ino);
+        if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
+            fat_free_unique_ino(fs_info, fat_fd->ino);
 
         free(fat_fd);
@@ -220,5 +218,5 @@
     else
     {
-        if (fat_ino_is_unique(mt_entry, fat_fd->ino))
+        if (fat_ino_is_unique(fs_info, fat_fd->ino))
         {
             fat_fd->links_num = 0;
@@ -244,5 +242,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     fat_fd   - fat-file descriptor
  *     start    - offset in fat-file (in bytes) to read from
@@ -256,5 +254,5 @@
 ssize_t
 fat_file_read(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd,
     uint32_t                              start,
@@ -265,5 +263,4 @@
     int            rc = RC_OK;
     ssize_t        ret = 0;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cmpltd = 0;
     uint32_t       cur_cln = 0;
@@ -294,9 +291,9 @@
         (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
     {
-        sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
+        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
         sec += (start >> fs_info->vol.sec_log2);
         byte = start & (fs_info->vol.bps - 1);
 
-        ret = _fat_block_read(mt_entry, sec, byte, count, buf);
+        ret = _fat_block_read(fs_info, sec, byte, count, buf);
         if ( ret < 0 )
             return -1;
@@ -308,5 +305,5 @@
     save_ofs = ofs = start & (fs_info->vol.bpc - 1);
 
-    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
+    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
     if (rc != RC_OK)
         return rc;
@@ -316,9 +313,9 @@
         c = MIN(count, (fs_info->vol.bpc - ofs));
 
-        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
+        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
         sec += (ofs >> fs_info->vol.sec_log2);
         byte = ofs & (fs_info->vol.bps - 1);
 
-        ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
+        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
         if ( ret < 0 )
             return -1;
@@ -327,5 +324,5 @@
         cmpltd += c;
         save_cln = cur_cln;
-        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
+        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
         if ( rc != RC_OK )
             return rc;
@@ -349,5 +346,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     fat_fd   - fat-file descriptor
  *     start    - offset(in bytes) to write from
@@ -361,5 +358,5 @@
 ssize_t
 fat_file_write(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd,
     uint32_t                              start,
@@ -370,5 +367,4 @@
     int            rc = 0;
     ssize_t        ret = 0;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cmpltd = 0;
     uint32_t       cur_cln = 0;
@@ -391,5 +387,5 @@
         count = fat_fd->size_limit - start;
 
-    rc = fat_file_extend(mt_entry, fat_fd, zero_fill, start + count, &c);
+    rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
     if (rc != RC_OK)
         return rc;
@@ -405,9 +401,9 @@
         (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
     {
-        sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
+        sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
         sec += (start >> fs_info->vol.sec_log2);
         byte = start & (fs_info->vol.bps - 1);
 
-        ret = _fat_block_write(mt_entry, sec, byte, count, buf);
+        ret = _fat_block_write(fs_info, sec, byte, count, buf);
         if ( ret < 0 )
             return -1;
@@ -419,5 +415,5 @@
     save_ofs = ofs = start & (fs_info->vol.bpc - 1);
 
-    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
+    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
     if (rc != RC_OK)
         return rc;
@@ -427,9 +423,9 @@
         c = MIN(count, (fs_info->vol.bpc - ofs));
 
-        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
+        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
         sec += (ofs >> fs_info->vol.sec_log2);
         byte = ofs & (fs_info->vol.bps - 1);
 
-        ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
+        ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
         if ( ret < 0 )
             return -1;
@@ -438,5 +434,5 @@
         cmpltd += c;
         save_cln = cur_cln;
-        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
+        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
         if ( rc != RC_OK )
             return rc;
@@ -461,5 +457,5 @@
  *
  * PARAMETERS:
- *     mt_entry   - mount table entry
+ *     fs_info    - FS info
  *     fat_fd     - fat-file descriptor
  *     new_length - new length
@@ -472,5 +468,5 @@
 int
 fat_file_extend(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd,
     bool                                  zero_fill,
@@ -480,5 +476,4 @@
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       chain = 0;
     uint32_t       bytes2add = 0;
@@ -517,13 +512,13 @@
         uint32_t byte;
 
-        rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
+        rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
         if (rc != RC_OK)
             return rc;
 
-        sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
+        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
         sec += ofs >> fs_info->vol.sec_log2;
         byte = ofs & (fs_info->vol.bps - 1);
 
-        rc = _fat_block_zero(mt_entry, sec, byte, bytes_remain);
+        rc = _fat_block_zero(fs_info, sec, byte, bytes_remain);
         if (rc != RC_OK)
             return rc;
@@ -540,5 +535,5 @@
     cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
 
-    rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
+    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
                                         &cls_added, &last_cl, zero_fill);
 
@@ -572,17 +567,17 @@
         else
         {
-            rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
+            rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
                                 (fat_fd->fat_file_size - 1), &old_last_cl);
             if ( rc != RC_OK )
             {
-                fat_free_fat_clusters_chain(mt_entry, chain);
+                fat_free_fat_clusters_chain(fs_info, chain);
                 return rc;
             }
         }
 
-        rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
+        rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
         if ( rc != RC_OK )
         {
-            fat_free_fat_clusters_chain(mt_entry, chain);
+            fat_free_fat_clusters_chain(fs_info, chain);
             return rc;
         }
@@ -596,8 +591,8 @@
         if (fat_fd->fat_file_type == FAT_DIRECTORY)
         {
-            rc = fat_init_clusters_chain(mt_entry, chain);
+            rc = fat_init_clusters_chain(fs_info, chain);
             if ( rc != RC_OK )
             {
-                fat_free_fat_clusters_chain(mt_entry, chain);
+                fat_free_fat_clusters_chain(fs_info, chain);
                 return rc;
             }
@@ -617,5 +612,5 @@
  *
  * PARAMETERS:
- *     mt_entry   - mount table entry
+ *     fs_info    - FS info
  *     fat_fd     - fat-file descriptor
  *     new_length - new length
@@ -626,5 +621,5 @@
 int
 fat_file_truncate(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd,
     uint32_t                              new_length
@@ -632,5 +627,4 @@
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cur_cln = 0;
     uint32_t       cl_start = 0;
@@ -650,5 +644,5 @@
     if (cl_start != 0)
     {
-        rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
+        rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
         if (rc != RC_OK)
             return rc;
@@ -656,9 +650,9 @@
     }
 
-    rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
+    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
     if (rc != RC_OK)
         return rc;
 
-    rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
+    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
     if (rc != RC_OK)
         return rc;
@@ -666,5 +660,5 @@
     if (cl_start != 0)
     {
-        rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
+        rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
         if ( rc != RC_OK )
             return rc;
@@ -683,5 +677,5 @@
  * PARAMETERS:
  *     fat_fd     - fat-file descriptor
- *     mt_entry   - mount table entry
+ *     fs_info    - FS info
  *     cmd        - command
  *     ...
@@ -692,5 +686,5 @@
 int
 fat_file_ioctl(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd,
     int                                   cmd,
@@ -698,5 +692,4 @@
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cur_cln = 0;
     uint32_t       cl_start = 0;
@@ -730,5 +723,5 @@
             cl_start = pos >> fs_info->vol.bpc_log2;
 
-            rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
+            rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
             if ( rc != RC_OK )
                 break;
@@ -752,5 +745,5 @@
  * PARAMETERS:
  *     fat_fd     - fat-file descriptor
- *     mt_entry   - mount table entry
+ *     fs_info    - FS info
  *
  * RETURNS:
@@ -759,12 +752,11 @@
 void
 fat_file_mark_removed(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd
     )
 {
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       key = 0;
 
-    key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
+    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
 
     _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
@@ -785,5 +777,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     fat_fd   - fat-file descriptor
  *
@@ -793,10 +785,9 @@
 int
 fat_file_size(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    fat_fs_info_t                        *fs_info,
     fat_file_fd_t                        *fat_fd
     )
 {
     int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
     uint32_t       cur_cln = fat_fd->cln;
     uint32_t       save_cln = 0;
@@ -815,5 +806,5 @@
     {
         save_cln = cur_cln;
-        rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
+        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
         if ( rc != RC_OK )
             return rc;
@@ -871,5 +862,5 @@
  *
  * PARAMETERS:
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *     hash     - hash element will be removed from
  *     key1     - search key
@@ -882,5 +873,5 @@
 static inline int
 _hash_search(
-    rtems_filesystem_mount_table_entry_t  *mt_entry,
+    const fat_fs_info_t                   *fs_info,
     rtems_chain_control                   *hash,
     uint32_t                               key1,
@@ -895,5 +886,5 @@
     {
         fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
-        uint32_t       ck =  fat_construct_key(mt_entry, &ffd->dir_pos.sname);
+        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
 
         if ( (key1) == ck)
@@ -912,5 +903,5 @@
 static off_t
 fat_file_lseek(
-    rtems_filesystem_mount_table_entry_t  *mt_entry,
+    fat_fs_info_t                         *fs_info,
     fat_file_fd_t                         *fat_fd,
     uint32_t                               file_cln,
@@ -942,5 +933,5 @@
         for (i = 0; i < count; i++)
         {
-            rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
+            rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
             if ( rc != RC_OK )
                 return rc;
Index: cpukit/libfs/src/dosfs/fat_file.h
===================================================================
--- cpukit/libfs/src/dosfs/fat_file.h	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/fat_file.h	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -112,5 +112,5 @@
  *     cl       - cluster number
  *     ofs      - offset inside cluster 'cl'
- *     mt_entry - mount table entry
+ *     fs_info  - FS info
  *
  * RETURNS:
@@ -119,8 +119,8 @@
 static inline uint32_t
 fat_construct_key(
-    rtems_filesystem_mount_table_entry_t *mt_entry,
+    const fat_fs_info_t                  *fs_info,
     fat_pos_t                            *pos)
 {
-    return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
+    return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
               (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +
               ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
@@ -129,5 +129,5 @@
 /* Prototypes for "fat-file" operations */
 int
-fat_file_open(rtems_filesystem_mount_table_entry_t  *mt_entry,
+fat_file_open(fat_fs_info_t                         *fs_info,
               fat_dir_pos_t                         *dir_pos,
               fat_file_fd_t                        **fat_fd);
@@ -137,9 +137,9 @@
 
 int
-fat_file_close(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_close(fat_fs_info_t                        *fs_info,
                fat_file_fd_t                        *fat_fd);
 
 ssize_t
-fat_file_read(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_read(fat_fs_info_t                        *fs_info,
               fat_file_fd_t                        *fat_fd,
               uint32_t                              start,
@@ -148,5 +148,5 @@
 
 ssize_t
-fat_file_write(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_write(fat_fs_info_t                        *fs_info,
                fat_file_fd_t                        *fat_fd,
                uint32_t                              start,
@@ -155,5 +155,5 @@
 
 int
-fat_file_extend(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_extend(fat_fs_info_t                        *fs_info,
                 fat_file_fd_t                        *fat_fd,
                 bool                                  zero_fill,
@@ -162,10 +162,10 @@
 
 int
-fat_file_truncate(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_truncate(fat_fs_info_t                        *fs_info,
                   fat_file_fd_t                        *fat_fd,
                   uint32_t                              new_length);
 
 int
-fat_file_ioctl(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_ioctl(fat_fs_info_t                        *fs_info,
                fat_file_fd_t                        *fat_fd,
                int                                   cmd,
@@ -173,9 +173,9 @@
 
 int
-fat_file_size(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_size(fat_fs_info_t                        *fs_info,
               fat_file_fd_t                        *fat_fd);
 
 void
-fat_file_mark_removed(rtems_filesystem_mount_table_entry_t *mt_entry,
+fat_file_mark_removed(fat_fs_info_t                        *fs_info,
                       fat_file_fd_t                        *fat_fd);
 
Index: cpukit/libfs/src/dosfs/msdos_create.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_create.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_create.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -123,10 +123,10 @@
        * read the original directory entry
        */
-      sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
+      sec = fat_cluster_num_to_sector_num(&fs_info->fat,
                                           link_fd->dir_pos.sname.cln);
       sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
       byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
 
-      ret = _fat_block_read(parent_loc->mt_entry,
+      ret = _fat_block_read(&fs_info->fat,
                             sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                             link_node);
@@ -176,5 +176,5 @@
     {
         /* open new directory as fat-file */
-        rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
+        rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
         if (rc != RC_OK)
             goto err;
@@ -226,5 +226,5 @@
          * by one cluster and entries will be written
          */
-        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
+        ret = fat_file_write(&fs_info->fat, fat_fd, 0,
                              MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
                              (uint8_t *)dot_dotdot);
@@ -245,5 +245,5 @@
 
         /* rewrite dot entry */
-        ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
+        ret = fat_file_write(&fs_info->fat, fat_fd, 0,
                              MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                              (uint8_t *)DOT_NODE_P(dot_dotdot));
@@ -259,10 +259,10 @@
             goto error;
 
-        fat_file_close(parent_loc->mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
     }
     return RC_OK;
 
 error:
-    fat_file_close(parent_loc->mt_entry, fat_fd);
+    fat_file_close(&fs_info->fat, fat_fd);
 
 err:
Index: cpukit/libfs/src/dosfs/msdos_dir.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_dir.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_dir.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -171,5 +171,5 @@
          * present in the directory because there may be holes :)
          */
-        ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
+        ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
                             bts2rd, fs_info->cl_buf);
         if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
@@ -315,5 +315,5 @@
 
                 /* get number of cluster we are working with */
-                rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
+                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                     j * bts2rd, &cur_cln);
                 if (rc != RC_OK)
@@ -326,5 +326,5 @@
                 dir_pos.sname.cln = cur_cln;
                 dir_pos.sname.ofs = i;
-                rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
+                rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
                 if (rc != RC_OK)
                 {
@@ -378,5 +378,5 @@
 
                 /* inode number extracted, close fat-file */
-                rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
+                rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
                 if (rc != RC_OK)
                 {
Index: cpukit/libfs/src/dosfs/msdos_file.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_file.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_file.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -116,5 +116,5 @@
         rtems_set_errno_and_return_minus_one(EIO);
 
-    ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
+    ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
                         buffer);
     if (ret > 0)
@@ -154,5 +154,5 @@
         iop->offset = fat_fd->fat_file_size;
 
-    ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
+    ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
                          buffer);
     if (ret < 0)
@@ -237,9 +237,9 @@
     old_length = fat_fd->fat_file_size;
     if (length < old_length) {
-        rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
+        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
     } else {
         uint32_t new_length;
 
-        rc = fat_file_extend(iop->pathinfo.mt_entry,
+        rc = fat_file_extend(&fs_info->fat,
                              fat_fd,
                              true,
@@ -247,5 +247,5 @@
                              &new_length);
         if (rc == RC_OK && length != new_length) {
-            fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, old_length);
+            fat_file_truncate(&fs_info->fat, fat_fd, old_length);
             errno = ENOSPC;
             rc = -1;
Index: cpukit/libfs/src/dosfs/msdos_free.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_free.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_free.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -32,4 +32,6 @@
 msdos_free_node_info(const rtems_filesystem_location_info_t *pathloc)
 {
-    fat_file_close(pathloc->mt_entry, pathloc->node_access);
+    msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
+
+    fat_file_close(&fs_info->fat, pathloc->node_access);
 }
Index: cpukit/libfs/src/dosfs/msdos_fsunmount.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_fsunmount.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_fsunmount.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -45,7 +45,7 @@
 
     /* close fat-file which correspondes to root directory */
-    fat_file_close(temp_mt_entry, fat_fd);
+    fat_file_close(&fs_info->fat, fat_fd);
 
-    fat_shutdown_drive(temp_mt_entry);
+    fat_shutdown_drive(&fs_info->fat);
 
     rtems_semaphore_delete(fs_info->vol_sema);
Index: cpukit/libfs/src/dosfs/msdos_initsupp.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_initsupp.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_initsupp.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -64,5 +64,5 @@
     temp_mt_entry->fs_info = fs_info;
 
-    rc = fat_init_volume_info(temp_mt_entry);
+    rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
     if (rc != RC_OK)
     {
@@ -80,8 +80,8 @@
     fat_dir_pos_init(&root_pos);
     root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
-    rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
+    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
     if (rc != RC_OK)
     {
-        fat_shutdown_drive(temp_mt_entry);
+        fat_shutdown_drive(&fs_info->fat);
         free(fs_info);
         return rc;
@@ -106,9 +106,9 @@
     else
     {
-        rc = fat_file_size(temp_mt_entry, fat_fd);
+        rc = fat_file_size(&fs_info->fat, fat_fd);
         if ( rc != RC_OK )
         {
-            fat_file_close(temp_mt_entry, fat_fd);
-            fat_shutdown_drive(temp_mt_entry);
+            fat_file_close(&fs_info->fat, fat_fd);
+            fat_shutdown_drive(&fs_info->fat);
             free(fs_info);
             return rc;
@@ -120,6 +120,6 @@
     if (fs_info->cl_buf == NULL)
     {
-        fat_file_close(temp_mt_entry, fat_fd);
-        fat_shutdown_drive(temp_mt_entry);
+        fat_file_close(&fs_info->fat, fat_fd);
+        fat_shutdown_drive(&fs_info->fat);
         free(fs_info);
         rtems_set_errno_and_return_minus_one(ENOMEM);
@@ -133,6 +133,6 @@
     if (sc != RTEMS_SUCCESSFUL)
     {
-        fat_file_close(temp_mt_entry, fat_fd);
-        fat_shutdown_drive(temp_mt_entry);
+        fat_file_close(&fs_info->fat, fat_fd);
+        fat_shutdown_drive(&fs_info->fat);
         free(fs_info->cl_buf);
         free(fs_info);
Index: cpukit/libfs/src/dosfs/msdos_misc.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_misc.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_misc.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -307,5 +307,5 @@
 
     /* open fat-file corresponded to the found node */
-    rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
+    rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
     if (rc != RC_OK)
         return rc;
@@ -334,8 +334,8 @@
             fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
 
-            rc = fat_file_size(parent_loc->mt_entry, fat_fd);
+            rc = fat_file_size(&fs_info->fat, fat_fd);
             if (rc != RC_OK)
             {
-                fat_file_close(parent_loc->mt_entry, fat_fd);
+                fat_file_close(&fs_info->fat, fat_fd);
                 return rc;
             }
@@ -364,8 +364,8 @@
 
     /* close fat-file corresponded to the node we searched in */
-    rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
+    rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
     if (rc != RC_OK)
     {
-        fat_file_close(parent_loc->mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
@@ -518,5 +518,5 @@
      * open fat-file corresponded to ".."
      */
-    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
+    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
     if (rc != RC_OK)
         return rc;
@@ -529,8 +529,8 @@
     fat_fd->map.disk_cln = fat_fd->cln;
 
-    rc = fat_file_size(mt_entry, fat_fd);
+    rc = fat_file_size(&fs_info->fat, fat_fd);
     if (rc != RC_OK)
     {
-        fat_file_close(mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
@@ -544,5 +544,5 @@
     if (rc != RC_OK)
     {
-        fat_file_close(mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
@@ -557,5 +557,5 @@
     if (rc != RC_OK)
     {
-        fat_file_close(mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
@@ -564,5 +564,5 @@
 
     /* close fat-file corresponded to ".." directory */
-    rc = fat_file_close(mt_entry, fat_fd);
+    rc = fat_file_close(&fs_info->fat, fat_fd);
     if ( rc != RC_OK )
         return rc;
@@ -579,5 +579,5 @@
 
     /* open fat-file corresponded to second ".." */
-    rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
+    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
     if (rc != RC_OK)
         return rc;
@@ -594,8 +594,8 @@
     fat_fd->map.disk_cln = fat_fd->cln;
 
-    rc = fat_file_size(mt_entry, fat_fd);
+    rc = fat_file_size(&fs_info->fat, fat_fd);
     if (rc != RC_OK)
     {
-        fat_file_close(mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
@@ -606,8 +606,8 @@
     if (rc != RC_OK)
     {
-        fat_file_close(mt_entry, fat_fd);
+        fat_file_close(&fs_info->fat, fat_fd);
         return rc;
     }
-    rc = fat_file_close(mt_entry, fat_fd);
+    rc = fat_file_close(&fs_info->fat, fat_fd);
     return rc;
 }
@@ -645,5 +645,5 @@
      * (sector num, new offset)
      */
-    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
+    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
     sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
     /* byte points to start of 32bytes structure */
@@ -651,10 +651,10 @@
 
     time_val = CT_LE_W(time_val);
-    ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
+    ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
                             2, (char *)(&time_val));
     date = CT_LE_W(date);
-    ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
+    ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
                             2, (char *)(&date));
-    ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
+    ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
                             2, (char *)(&date));
 
@@ -695,5 +695,5 @@
      * (sector num, new offset)
      */
-    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
+    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
     sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
     /* byte from points to start of 32bytes structure */
@@ -701,9 +701,9 @@
 
     le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));
-    ret1 = _fat_block_write(mt_entry, sec,
+    ret1 = _fat_block_write(&fs_info->fat, sec,
                             byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
                             (char *)(&le_cl_low));
     le_cl_hi = CT_LE_W((uint16_t  )((new_cln & 0xFFFF0000) >> 16));
-    ret2 = _fat_block_write(mt_entry, sec,
+    ret2 = _fat_block_write(&fs_info->fat, sec,
                             byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
                             (char *)(&le_cl_hi));
@@ -738,10 +738,10 @@
     uint32_t         byte = 0;
 
-    sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
+    sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
     sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
     byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
 
     le_new_length = CT_LE_L((fat_fd->fat_file_size));
-    ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
+    ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
                            (char *)(&le_new_length));
     if ( ret < 0 )
@@ -799,10 +799,10 @@
     while (true)
     {
-      uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
+      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
                       (start.ofs >> fs_info->fat.vol.sec_log2));
       uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
 
-      ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
-                             &fchar);
+      ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
+                             1, &fchar);
       if (ret < 0)
         return -1;
@@ -818,5 +818,5 @@
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
           break;
-        rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
+        rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
         if ( rc != RC_OK )
           return rc;
@@ -855,5 +855,5 @@
     *ret_val = false;
 
-    while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
+    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
                                   fs_info->fat.vol.bps,
                                   fs_info->cl_buf)) != FAT_EOF)
@@ -999,5 +999,5 @@
      * create the entry if the name is not found.
      */
-    while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
+    while ((ret = fat_file_read(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
                                 bts2rd, fs_info->cl_buf)) != FAT_EOF)
     {
@@ -1283,5 +1283,5 @@
                          * structure and the 32 bytes of the short entry
                          */
-                        int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
+                        int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                                 dir_offset * bts2rd,
                                                 &dir_pos->sname.cln);
@@ -1293,5 +1293,5 @@
                         if (lfn_start.cln != FAT_FILE_SHORT_NAME)
                         {
-                          rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
+                          rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                               lfn_start.cln * bts2rd,
                                               &lfn_start.cln);
@@ -1398,5 +1398,5 @@
           printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
 #endif
-          ret = fat_file_read(mt_entry, fat_fd,
+          ret = fat_file_read(&fs_info->fat, fat_fd,
                               (empty_space_offset * bts2rd), bts2rd,
                               fs_info->cl_buf);
@@ -1410,5 +1410,5 @@
             printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
 #endif
-            ret = fat_file_extend (mt_entry, fat_fd, false,
+            ret = fat_file_extend (&fs_info->fat, fat_fd, false,
                                    empty_space_offset * bts2rd, &new_length);
 
@@ -1424,5 +1424,5 @@
             memset(fs_info->cl_buf, 0, bts2rd);
 
-            ret = fat_file_write(mt_entry, fat_fd,
+            ret = fat_file_write(&fs_info->fat, fat_fd,
                                  empty_space_offset * bts2rd,
                                  bts2rd, fs_info->cl_buf);
@@ -1465,5 +1465,5 @@
             {
                 /* get current cluster number */
-                int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
+                int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                         empty_space_offset * bts2rd,
                                         &dir_pos->sname.cln);
@@ -1475,5 +1475,5 @@
                 if (lfn_start.cln != FAT_FILE_SHORT_NAME)
                 {
-                  rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
+                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
                                       lfn_start.cln * bts2rd,
                                       &lfn_start.cln);
@@ -1547,5 +1547,5 @@
         }
 
-        ret = fat_file_write(mt_entry, fat_fd,
+        ret = fat_file_write(&fs_info->fat, fat_fd,
                              (empty_space_offset * bts2rd) + empty_space_entry,
                              length, fs_info->cl_buf + empty_space_entry);
@@ -1601,5 +1601,5 @@
         bts2rd = fs_info->fat.vol.bpc;
 
-    while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
+    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
                                   fs_info->cl_buf)) != FAT_EOF)
     {
@@ -1627,5 +1627,5 @@
             {
                 /* on success fill aux structure and copy all 32 bytes */
-                rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
+                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
                                     &dir_pos->sname.cln);
                 if (rc != RC_OK)
Index: cpukit/libfs/src/dosfs/msdos_rmnod.c
===================================================================
--- cpukit/libfs/src/dosfs/msdos_rmnod.c	(revision c5ba8ba72708f89ad37356a46e6cfe2a22794480)
+++ cpukit/libfs/src/dosfs/msdos_rmnod.c	(revision c65afce4300a14c77dd8b7557e919af5afd8d18a)
@@ -21,4 +21,5 @@
 {
     int                rc = RC_OK;
+    msdos_fs_info_t   *fs_info = pathloc->mt_entry->fs_info;
     fat_file_fd_t     *fat_fd = pathloc->node_access;
 
@@ -72,5 +73,5 @@
     }
 
-    fat_file_mark_removed(pathloc->mt_entry, fat_fd);
+    fat_file_mark_removed(&fs_info->fat, fat_fd);
 
     return rc;
