2008-07-29 Chris Johns <chrisj@rtems.org>

	* libblock/Makefile.am: Removed src/show_bdbuf.c.

	* libblock/src/show_bdbuf.c: Removed.

	* libblock/include/rtems/bdbuf.h, cpukit/libblock/src/bdbuf.c:
	Rewritten the bdbuf code. Remove pre-emption disable, score
	access, fixed many bugs and increased performance.

	* libblock/include/rtems/blkdev.h: Added
	RTEMS_BLKDEV_CAPABILITIES block device request. Cleaned up
	comments. Added block and user fields to the sg buffer
	request. Move to rtems_* namespace.

	* libblock/include/rtems/diskdevs.h,
	cpukit/libblock/src/diskdevs.c: Move to rtems_* namespace. Add a
	capabilities field for drivers. Change rtems_disk_lookup to
	rtems_disk_obtain to match the release call. You do not lookup and
	release a disk, you obtain and release a disk.

	* libblock/include/rtems/ide_part_table.h,
	libblock/include/rtems/ramdisk.h, libblock/src/ide_part_table.c:
	Move to rtems_* namespace.

	* libblock/include/rtems/nvdisk.h: Formatting change.

	* libblock/src/blkdev.c: Move to rtems_* namespace. Change
	rtems_disk_lookup to rtems_disk_obtain

	* libblock/src/flashdisk.c: Move to rtems_* namespace. Use the new
	support for the block number in the scatter/grather request
	struct. This allows non-continuous buffer requests for those
	drivers that can support increasing performance.

	* libblock/src/nvdisk.c: Move to rtems_* namespace. Removed
	warnings. Added better error checking. Fixed some comments.

	* libblock/src/ramdisk.c: Move to rtems_* namespace. Added some
	trace functions to help debugging upper layers. Use the new
	support for the block number in the scatter/grather request
	struct. This allows non-continuous buffer requests for those
	drivers that can support increasing performance.

	* libfs/src/dosfs/fat.c, libfs/src/dosfs/fat.h: Use new chains
	API. Removed temporary hack and changed
	set_errno_and_return_minus_one to
	rtems_set_errno_and_return_minus_one. Move fat_buf_access from
	header and stopped it being inlined. Updated to libblock changes.

	* libfs/src/dosfs/fat_fat_operations.c,
	libfs/src/dosfs/fat_file.c, libfs/src/dosfs/msdos_create.c,
	libfs/src/dosfs/msdos_dir.c, libfs/src/dosfs/msdos_eval.c,
	libfs/src/dosfs/msdos_file.c, libfs/src/dosfs/msdos_format.c,
	libfs/src/dosfs/msdos_free.c, libfs/src/dosfs/msdos_initsupp.c,
	libfs/src/dosfs/msdos_misc.c, libfs/src/dosfs/msdos_mknod.c: Use
	new chains API. Removed temporary hack and changed
	set_errno_and_return_minus_one to
	rtems_set_errno_and_return_minus_one. Updated to libblock changes.

	* libmisc/Makefile.am: Add new ls and rm command files.

	* libmisc/shell/cmp-ls.c, libmisc/shell/extern-ls.h,
	libmisc/shell/filemode.c, libmisc/shell/print-ls.c,
	libmisc/shell/pwcache.c, libmisc/shell/utils-ls.c,
	libmisc/shell/vis.c, shell/vis.h: New.

	* libmisc/shell/extern-cp.h, libmisc/shell/main_cp.c,
	libmisc/shell/utils-cp.c: Fixed the usage call bug.

	* libmisc/shell/main_blksync.c: Updated to the new block IO ioctl
	command.

	* libmisc/shell/main_ls.c, libmisc/shell/main_rm.c: Updated to BSD
	commands with more features.

	* score/src/coremutex.c: Fix the strick order mutex code.

	* libmisc/shell/shell.c: Change shell tasks mode to be timeslice
	and no ASR.

	* sapi/include/confdefs.h: Change ata_driver_task_priority to
	rtems_ata_driver_task_priority. Add the new BD buf cache
	parameters with defaults.

	* score/src/interr.c: Do not return if the CPU halt call returns.

13 files changed, 296 insertions, 298 deletions

diff --git a/cpukit/libfs/src/dosfs/fat.c b/cpukit/libfs/src/dosfs/fat.c
index 65bf30e624..4dd61afdd9 100644
--- a/cpukit/libfs/src/dosfs/fat.c
+++ b/cpukit/libfs/src/dosfs/fat.c
@@ -26,6 +26,137 @@
 #include "fat.h"
 #include "fat_fat_operations.h"
 
+int
+fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,
+               rtems_bdbuf_buffer **buf)
+{
+    rtems_status_code sc = RTEMS_SUCCESSFUL;
+    uint8_t           i;
+    rtems_boolean     sec_of_fat;
+
+
+    if (fs_info->c.state == FAT_CACHE_EMPTY)
+    {
+        if (op_type == FAT_OP_TYPE_READ)
+            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
+        else
+            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
+        if (sc != RTEMS_SUCCESSFUL)
+            rtems_set_errno_and_return_minus_one(EIO);
+        fs_info->c.blk_num = blk;
+        fs_info->c.modified = 0;
+        fs_info->c.state = FAT_CACHE_ACTUAL;
+    }
+
+    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
+                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
+
+    if (fs_info->c.blk_num != blk)
+    {
+        if (fs_info->c.modified)
+        {
+            if (sec_of_fat && !fs_info->vol.mirror)
+                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
+                       fs_info->vol.bps);
+
+            sc = rtems_bdbuf_release_modified(fs_info->c.buf);
+            fs_info->c.state = FAT_CACHE_EMPTY;
+            fs_info->c.modified = 0;
+            if (sc != RTEMS_SUCCESSFUL)
+                rtems_set_errno_and_return_minus_one(EIO);
+
+            if (sec_of_fat && !fs_info->vol.mirror)
+            {
+                rtems_bdbuf_buffer *b;
+
+                for (i = 1; i < fs_info->vol.fats; i++)
+                {
+                    sc = rtems_bdbuf_get(fs_info->vol.dev,
+                                         fs_info->c.blk_num +
+                                         fs_info->vol.fat_length * i,
+                                         &b);
+                    if ( sc != RTEMS_SUCCESSFUL)
+                        rtems_set_errno_and_return_minus_one(ENOMEM);
+                    memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
+                    sc = rtems_bdbuf_release_modified(b);
+                    if ( sc != RTEMS_SUCCESSFUL)
+                        rtems_set_errno_and_return_minus_one(ENOMEM);
+                }
+            }
+        }
+        else
+        {
+            sc = rtems_bdbuf_release(fs_info->c.buf);
+            fs_info->c.state = FAT_CACHE_EMPTY;
+            if (sc != RTEMS_SUCCESSFUL)
+                rtems_set_errno_and_return_minus_one(EIO);
+
+        }
+        if (op_type == FAT_OP_TYPE_READ)
+            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
+        else
+            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
+        if (sc != RTEMS_SUCCESSFUL)
+            rtems_set_errno_and_return_minus_one(EIO);
+        fs_info->c.blk_num = blk;
+        fs_info->c.state = FAT_CACHE_ACTUAL;
+    }
+    *buf = fs_info->c.buf;
+    return RC_OK;
+}
+
+int
+fat_buf_release(fat_fs_info_t *fs_info)
+{
+    rtems_status_code sc = RTEMS_SUCCESSFUL;
+    uint8_t           i;
+    rtems_boolean     sec_of_fat;
+
+    if (fs_info->c.state == FAT_CACHE_EMPTY)
+        return RC_OK;
+
+    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
+                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
+
+    if (fs_info->c.modified)
+    {
+        if (sec_of_fat && !fs_info->vol.mirror)
+            memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
+
+        sc = rtems_bdbuf_release_modified(fs_info->c.buf);
+        if (sc != RTEMS_SUCCESSFUL)
+            rtems_set_errno_and_return_minus_one(EIO);
+        fs_info->c.modified = 0;
+
+        if (sec_of_fat && !fs_info->vol.mirror)
+        {
+            rtems_bdbuf_buffer *b;
+
+            for (i = 1; i < fs_info->vol.fats; i++)
+            {
+                sc = rtems_bdbuf_get(fs_info->vol.dev,
+                                     fs_info->c.blk_num +
+                                     fs_info->vol.fat_length * i,
+                                     &b);
+                if ( sc != RTEMS_SUCCESSFUL)
+                    rtems_set_errno_and_return_minus_one(ENOMEM);
+                memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
+                sc = rtems_bdbuf_release_modified(b);
+                if ( sc != RTEMS_SUCCESSFUL)
+                    rtems_set_errno_and_return_minus_one(ENOMEM);
+            }
+        }
+    }
+    else
+    {
+        sc = rtems_bdbuf_release(fs_info->c.buf);
+        if (sc != RTEMS_SUCCESSFUL)
+            rtems_set_errno_and_return_minus_one(EIO);
+    }
+    fs_info->c.state = FAT_CACHE_EMPTY;
+    return RC_OK;
+}
+
 /* _fat_block_read --
  *     This function reads 'count' bytes from device filesystem is mounted on,
  *     starts at 'start+offset' position where 'start' computed in sectors
@@ -57,7 +188,7 @@ _fat_block_read(
     ssize_t                 cmpltd = 0;
     uint32_t                blk = start;
     uint32_t                ofs = offset;
-    bdbuf_buffer           *block = NULL;
+    rtems_bdbuf_buffer     *block = NULL;
     uint32_t                c = 0;
 
     while (count > 0)
@@ -102,13 +233,13 @@ _fat_block_write(
     uint32_t                              count,
     const void                           *buff)
 {
-    int            rc = RC_OK;
-    fat_fs_info_t *fs_info = mt_entry->fs_info;
-    ssize_t        cmpltd = 0;
-    uint32_t       blk  = start;
-    uint32_t       ofs = offset;
-    bdbuf_buffer  *block = NULL;
-    uint32_t       c = 0;
+    int                 rc = RC_OK;
+    fat_fs_info_t      *fs_info = mt_entry->fs_info;
+    ssize_t             cmpltd = 0;
+    uint32_t            blk  = start;
+    uint32_t            ofs = offset;
+    rtems_bdbuf_buffer *block = NULL;
+    uint32_t            c = 0;
 
     while(count > 0)
     {
@@ -133,9 +264,6 @@ _fat_block_write(
     return cmpltd;
 }
 
-
-
-
 /* fat_cluster_read --
  *     wrapper for reading a whole cluster at once
  *
@@ -215,7 +343,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     ssize_t             ret = 0;
     struct stat         stat_buf;
     int                 i = 0;
-    bdbuf_buffer       *block = NULL;
+    rtems_bdbuf_buffer *block = NULL;
 
     rc = stat(mt_entry->dev, &stat_buf);
     if (rc == -1)
@@ -223,12 +351,12 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
 
     /* rtmes feature: no block devices, all are character devices */
     if (!S_ISCHR(stat_buf.st_mode))
-        set_errno_and_return_minus_one(ENOTBLK);
+        rtems_set_errno_and_return_minus_one(ENOTBLK);
 
-    /* check that  device is registred as block device and lock it */
-    vol->dd = rtems_disk_lookup(stat_buf.st_dev);
+    /* check that device is registred as block device and lock it */
+    vol->dd = rtems_disk_obtain(stat_buf.st_dev);
     if (vol->dd == NULL)
-        set_errno_and_return_minus_one(ENOTBLK);
+        rtems_set_errno_and_return_minus_one(ENOTBLK);
 
     vol->dev = stat_buf.st_dev;
 
@@ -238,7 +366,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     if (sc != RTEMS_SUCCESSFUL)
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one( EIO);
+        rtems_set_errno_and_return_minus_one( EIO);
     }
 
     memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
@@ -247,7 +375,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     if (sc != RTEMS_SUCCESSFUL)
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one( EIO);
+        rtems_set_errno_and_return_minus_one( EIO );
     }
 
     /* Evaluate boot record */
@@ -259,7 +387,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
          (vol->bps != 4096))
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one( EINVAL );
+        rtems_set_errno_and_return_minus_one( EINVAL );
     }
 
     for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
@@ -275,7 +403,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     if (vol->spc == 0)
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one(EINVAL);
+        rtems_set_errno_and_return_minus_one(EINVAL);
     }
 
     for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
@@ -287,7 +415,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one(EINVAL);
+        rtems_set_errno_and_return_minus_one(EINVAL);
     }
 
     for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
@@ -361,7 +489,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
         if( vol->info_sec == 0 )
         {
             rtems_disk_release(vol->dd);
-            set_errno_and_return_minus_one( EINVAL );
+            rtems_set_errno_and_return_minus_one( EINVAL );
         }
         else
         {
@@ -377,7 +505,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
                 FAT_FSINFO_LEAD_SIGNATURE_VALUE)
             {
                 rtems_disk_release(vol->dd);
-                set_errno_and_return_minus_one( EINVAL );
+                rtems_set_errno_and_return_minus_one( EINVAL );
             }
             else
             {
@@ -412,25 +540,25 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
     vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
 
     /* set up collection of fat-files fd */
-    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(Chain_Control));
+    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
     if ( fs_info->vhash == NULL )
     {
         rtems_disk_release(vol->dd);
-        set_errno_and_return_minus_one( ENOMEM );
+        rtems_set_errno_and_return_minus_one( ENOMEM );
     }
 
     for (i = 0; i < FAT_HASH_SIZE; i++)
-        _Chain_Initialize_empty(fs_info->vhash + i);
+        rtems_chain_initialize_empty(fs_info->vhash + i);
 
-    fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(Chain_Control));
+    fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
     if ( fs_info->rhash == NULL )
     {
         rtems_disk_release(vol->dd);
         free(fs_info->vhash);
-        set_errno_and_return_minus_one( ENOMEM );
+        rtems_set_errno_and_return_minus_one( ENOMEM );
     }
     for (i = 0; i < FAT_HASH_SIZE; i++)
-        _Chain_Initialize_empty(fs_info->rhash + i);
+        rtems_chain_initialize_empty(fs_info->rhash + i);
 
     fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
     fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
@@ -441,7 +569,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
         rtems_disk_release(vol->dd);
         free(fs_info->vhash);
         free(fs_info->rhash);
-        set_errno_and_return_minus_one( ENOMEM );
+        rtems_set_errno_and_return_minus_one( ENOMEM );
     }
     fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
     if (fs_info->sec_buf == NULL)
@@ -450,7 +578,7 @@ fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
         free(fs_info->vhash);
         free(fs_info->rhash);
         free(fs_info->uino);
-        set_errno_and_return_minus_one( ENOMEM );
+        rtems_set_errno_and_return_minus_one( ENOMEM );
     }
 
     return RC_OK;
@@ -488,19 +616,19 @@ fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
 
     for (i = 0; i < FAT_HASH_SIZE; i++)
     {
-        Chain_Node    *node = NULL;
-        Chain_Control *the_chain = fs_info->vhash + i;
+        rtems_chain_node    *node = NULL;
+        rtems_chain_control *the_chain = fs_info->vhash + i;
 
-        while ( (node = _Chain_Get(the_chain)) != NULL )
+        while ( (node = rtems_chain_get(the_chain)) != NULL )
             free(node);
     }
 
     for (i = 0; i < FAT_HASH_SIZE; i++)
     {
-        Chain_Node    *node = NULL;
-        Chain_Control *the_chain = fs_info->rhash + i;
+        rtems_chain_node    *node = NULL;
+        rtems_chain_control *the_chain = fs_info->rhash + i;
 
-        while ( (node = _Chain_Get(the_chain)) != NULL )
+        while ( (node = rtems_chain_get(the_chain)) != NULL )
             free(node);
     }
 
@@ -541,7 +669,7 @@ fat_init_clusters_chain(
 
     buf = calloc(fs_info->vol.bpc, sizeof(char));
     if ( buf == NULL )
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
 
     while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
     {
diff --git a/cpukit/libfs/src/dosfs/fat.h b/cpukit/libfs/src/dosfs/fat.h
index 3a951b114e..244e57f087 100644
--- a/cpukit/libfs/src/dosfs/fat.h
+++ b/cpukit/libfs/src/dosfs/fat.h
@@ -25,11 +25,6 @@ extern "C" {
 
 #include <rtems/seterr.h>
 
-/* XXX: temporary hack :(( */
-#ifndef set_errno_and_return_minus_one
-#define set_errno_and_return_minus_one rtems_set_errno_and_return_minus_one
-#endif /* set_errno_and_return_minus_one */
-
 #include <rtems/score/cpu.h>
 #include <errno.h>
 #include <rtems/bdbuf.h>
@@ -297,45 +292,45 @@ extern "C" {
  */
 typedef struct fat_vol_s
 {
-    uint16_t     bps;            /* bytes per sector */
-    uint8_t      sec_log2;       /* log2 of bps */
-    uint8_t      sec_mul;        /* log2 of 512bts sectors number per sector */
-    uint8_t      spc;            /* sectors per cluster */
-    uint8_t      spc_log2;       /* log2 of spc */
-    uint16_t     bpc;            /* bytes per cluster */
-    uint8_t      bpc_log2;       /* log2 of bytes per cluster */
-    uint8_t      fats;           /* number of FATs */
-    uint8_t      type;           /* FAT type */
-    uint32_t     mask;
-    uint32_t     eoc_val;
-    uint16_t     fat_loc;        /* FAT start */
-    uint32_t     fat_length;     /* sectors per FAT */
-    uint32_t     rdir_loc;       /* root directory start */
-    uint16_t     rdir_entrs;     /* files per root directory */
-    uint32_t     rdir_secs;      /* sectors per root directory */
-    uint32_t     rdir_size;      /* root directory size in bytes */
-    uint32_t     tot_secs;       /* total count of sectors */
-    uint32_t     data_fsec;      /* first data sector */
-    uint32_t     data_cls;       /* count of data clusters */
-    uint32_t     rdir_cl;        /* first cluster of the root directory */
-    uint16_t     info_sec;       /* FSInfo Sector Structure location */
-    uint32_t     free_cls;       /* last known free clusters count */
-    uint32_t     next_cl;        /* next free cluster number */
-    uint8_t      mirror;         /* mirroring enabla/disable */
-    uint32_t     afat_loc;       /* active FAT location */
-    uint8_t      afat;           /* the number of active FAT */
-    dev_t        dev;            /* device ID */
-    disk_device *dd;             /* disk device (see libblock) */
-    void        *private_data;   /* reserved */
+    uint16_t           bps;            /* bytes per sector */
+    uint8_t            sec_log2;       /* log2 of bps */
+    uint8_t            sec_mul;        /* log2 of 512bts sectors number per sector */
+    uint8_t            spc;            /* sectors per cluster */
+    uint8_t            spc_log2;       /* log2 of spc */
+    uint16_t           bpc;            /* bytes per cluster */
+    uint8_t            bpc_log2;       /* log2 of bytes per cluster */
+    uint8_t            fats;           /* number of FATs */
+    uint8_t            type;           /* FAT type */
+    uint32_t           mask;
+    uint32_t           eoc_val;
+    uint16_t           fat_loc;        /* FAT start */
+    uint32_t           fat_length;     /* sectors per FAT */
+    uint32_t           rdir_loc;       /* root directory start */
+    uint16_t           rdir_entrs;     /* files per root directory */
+    uint32_t           rdir_secs;      /* sectors per root directory */
+    uint32_t           rdir_size;      /* root directory size in bytes */
+    uint32_t           tot_secs;       /* total count of sectors */
+    uint32_t           data_fsec;      /* first data sector */
+    uint32_t           data_cls;       /* count of data clusters */
+    uint32_t           rdir_cl;        /* first cluster of the root directory */
+    uint16_t           info_sec;       /* FSInfo Sector Structure location */
+    uint32_t           free_cls;       /* last known free clusters count */
+    uint32_t           next_cl;        /* next free cluster number */
+    uint8_t            mirror;         /* mirroring enabla/disable */
+    uint32_t           afat_loc;       /* active FAT location */
+    uint8_t            afat;           /* the number of active FAT */
+    dev_t              dev;            /* device ID */
+    rtems_disk_device *dd;             /* disk device (see libblock) */
+    void              *private_data;   /* reserved */
 } fat_vol_t;
 
 
 typedef struct fat_cache_s
 {
-    uint32_t       blk_num;
-    rtems_boolean  modified;
-    uint8_t        state;
-    bdbuf_buffer   *buf;
+    uint32_t            blk_num;
+    rtems_boolean       modified;
+    uint8_t             state;
+    rtems_bdbuf_buffer *buf;
 } fat_cache_t;
 
 /*
@@ -344,15 +339,15 @@ typedef struct fat_cache_s
  */
 typedef struct fat_fs_info_s
 {
-    fat_vol_t      vol;           /* volume descriptor */
-    Chain_Control *vhash;         /* "vhash" of fat-file descriptors */
-    Chain_Control *rhash;         /* "rhash" of fat-file descriptors */
-    char          *uino;          /* array of unique ino numbers */
-    uint32_t       index;
-    uint32_t       uino_pool_size; /* size */
-    uint32_t       uino_base;
-    fat_cache_t    c;             /* cache */
-    uint8_t       *sec_buf; /* just placeholder for anything */
+    fat_vol_t            vol;           /* volume descriptor */
+    rtems_chain_control *vhash;         /* "vhash" of fat-file descriptors */
+    rtems_chain_control *rhash;         /* "rhash" of fat-file descriptors */
+    char                *uino;          /* array of unique ino numbers */
+    uint32_t             index;
+    uint32_t             uino_pool_size; /* size */
+    uint32_t             uino_base;
+    fat_cache_t          c;             /* cache */
+    uint8_t             *sec_buf; /* just placeholder for anything */
 } fat_fs_info_t;
 
 /*
@@ -415,145 +410,18 @@ fat_cluster_num_to_sector512_num(
             fs_info->vol.sec_mul);
 }
 
-static inline int
-fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,
-               bdbuf_buffer **buf)
-{
-    rtems_status_code sc = RTEMS_SUCCESSFUL;
-    uint8_t           i;
-    rtems_boolean     sec_of_fat;
-
-
-    if (fs_info->c.state == FAT_CACHE_EMPTY)
-    {
-        if (op_type == FAT_OP_TYPE_READ)
-            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
-        else
-            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
-        if (sc != RTEMS_SUCCESSFUL)
-            set_errno_and_return_minus_one(EIO);
-        fs_info->c.blk_num = blk;
-	fs_info->c.modified = 0;
-        fs_info->c.state = FAT_CACHE_ACTUAL;
-    }
-
-    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
-                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
-
-    if (fs_info->c.blk_num != blk)
-    {
-        if (fs_info->c.modified)
-        {
-            if (sec_of_fat && !fs_info->vol.mirror)
-                memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
-                       fs_info->vol.bps);
-
-            sc = rtems_bdbuf_release_modified(fs_info->c.buf);
-	    fs_info->c.state = FAT_CACHE_EMPTY;
-            fs_info->c.modified = 0;
-            if (sc != RTEMS_SUCCESSFUL)
-                set_errno_and_return_minus_one(EIO);
-
-            if (sec_of_fat && !fs_info->vol.mirror)
-            {
-                bdbuf_buffer *b;
-
-                for (i = 1; i < fs_info->vol.fats; i++)
-                {
-                    sc = rtems_bdbuf_get(fs_info->vol.dev,
-                                         fs_info->c.blk_num +
-                                         fs_info->vol.fat_length * i,
-                                         &b);
-                    if ( sc != RTEMS_SUCCESSFUL)
-                        set_errno_and_return_minus_one(ENOMEM);
-                    memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
-                    sc = rtems_bdbuf_release_modified(b);
-                    if ( sc != RTEMS_SUCCESSFUL)
-                        set_errno_and_return_minus_one(ENOMEM);
-                }
-            }
-        }
-        else
-        {
-            sc = rtems_bdbuf_release(fs_info->c.buf);
-	    fs_info->c.state = FAT_CACHE_EMPTY;
-            if (sc != RTEMS_SUCCESSFUL)
-                set_errno_and_return_minus_one(EIO);
-
-        }
-        if (op_type == FAT_OP_TYPE_READ)
-            sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
-        else
-            sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
-        if (sc != RTEMS_SUCCESSFUL)
-            set_errno_and_return_minus_one(EIO);
-        fs_info->c.blk_num = blk;
-	fs_info->c.state = FAT_CACHE_ACTUAL;
-    }
-    *buf = fs_info->c.buf;
-    return RC_OK;
-}
-
-
-static inline int
-fat_buf_release(fat_fs_info_t *fs_info)
-{
-    rtems_status_code sc = RTEMS_SUCCESSFUL;
-    uint8_t           i;
-    rtems_boolean     sec_of_fat;
-
-    if (fs_info->c.state == FAT_CACHE_EMPTY)
-        return RC_OK;
-
-    sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
-                  (fs_info->c.blk_num < fs_info->vol.rdir_loc));
-
-    if (fs_info->c.modified)
-    {
-        if (sec_of_fat && !fs_info->vol.mirror)
-            memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
-
-        sc = rtems_bdbuf_release_modified(fs_info->c.buf);
-        if (sc != RTEMS_SUCCESSFUL)
-            set_errno_and_return_minus_one(EIO);
-        fs_info->c.modified = 0;
-
-        if (sec_of_fat && !fs_info->vol.mirror)
-        {
-            bdbuf_buffer *b;
-
-            for (i = 1; i < fs_info->vol.fats; i++)
-            {
-                sc = rtems_bdbuf_get(fs_info->vol.dev,
-                                     fs_info->c.blk_num +
-                                     fs_info->vol.fat_length * i,
-                                     &b);
-                if ( sc != RTEMS_SUCCESSFUL)
-                    set_errno_and_return_minus_one(ENOMEM);
-                memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
-                sc = rtems_bdbuf_release_modified(b);
-                if ( sc != RTEMS_SUCCESSFUL)
-                    set_errno_and_return_minus_one(ENOMEM);
-            }
-        }
-    }
-    else
-    {
-        sc = rtems_bdbuf_release(fs_info->c.buf);
-        if (sc != RTEMS_SUCCESSFUL)
-            set_errno_and_return_minus_one(EIO);
-    }
-    fs_info->c.state = FAT_CACHE_EMPTY;
-    return RC_OK;
-}
-
 static inline void
 fat_buf_mark_modified(fat_fs_info_t *fs_info)
 {
     fs_info->c.modified = TRUE;
 }
 
+int
+fat_buf_access(fat_fs_info_t *fs_info, uint32_t   blk, int op_type,
+               rtems_bdbuf_buffer **buf);
 
+int
+fat_buf_release(fat_fs_info_t *fs_info);
 
 ssize_t
 _fat_block_read(rtems_filesystem_mount_table_entry_t *mt_entry,
diff --git a/cpukit/libfs/src/dosfs/fat_fat_operations.c b/cpukit/libfs/src/dosfs/fat_fat_operations.c
index 0e6411f799..9d677dc3db 100644
--- a/cpukit/libfs/src/dosfs/fat_fat_operations.c
+++ b/cpukit/libfs/src/dosfs/fat_fat_operations.c
@@ -229,13 +229,13 @@ fat_get_fat_cluster(
 {
     int                     rc = RC_OK;
     register fat_fs_info_t *fs_info = mt_entry->fs_info;
-    bdbuf_buffer           *block0 = NULL;
+    rtems_bdbuf_buffer     *block0 = NULL;
     uint32_t                sec = 0;
     uint32_t                ofs = 0;
 
     /* sanity check */
     if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
           fs_info->vol.afat_loc;
@@ -284,7 +284,7 @@ fat_get_fat_cluster(
             break;
 
         default:
-            set_errno_and_return_minus_one(EIO);
+            rtems_set_errno_and_return_minus_one(EIO);
             break;
     }
 
@@ -311,17 +311,17 @@ fat_set_fat_cluster(
     uint32_t                              in_val
     )
 {
-    int                rc = RC_OK;
-    fat_fs_info_t     *fs_info = mt_entry->fs_info;
-    uint32_t           sec = 0;
-    uint32_t           ofs = 0;
-    uint16_t           fat16_clv = 0;
-    uint32_t           fat32_clv = 0;
-    bdbuf_buffer      *block0 = NULL;
+    int                 rc = RC_OK;
+    fat_fs_info_t      *fs_info = mt_entry->fs_info;
+    uint32_t            sec = 0;
+    uint32_t            ofs = 0;
+    uint16_t            fat16_clv = 0;
+    uint32_t            fat32_clv = 0;
+    rtems_bdbuf_buffer *block0 = NULL;
 
     /* sanity check */
     if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
           fs_info->vol.afat_loc;
@@ -428,7 +428,7 @@ fat_set_fat_cluster(
             break;
 
         default:
-            set_errno_and_return_minus_one(EIO);
+            rtems_set_errno_and_return_minus_one(EIO);
             break;
 
     }
diff --git a/cpukit/libfs/src/dosfs/fat_file.c b/cpukit/libfs/src/dosfs/fat_file.c
index 69e1d9a7e0..6bf482e927 100644
--- a/cpukit/libfs/src/dosfs/fat_file.c
+++ b/cpukit/libfs/src/dosfs/fat_file.c
@@ -10,6 +10,8 @@
  *
  */
 
+#define MSDOS_TRACE 1
+
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -112,7 +114,7 @@ fat_file_open(
 
     lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
     if ( lfat_fd == NULL )
-        set_errno_and_return_minus_one( ENOMEM );
+        rtems_set_errno_and_return_minus_one( ENOMEM );
 
     lfat_fd->links_num = 1;
     lfat_fd->flags &= ~FAT_FILE_REMOVED;
@@ -131,7 +133,7 @@ fat_file_open(
              * XXX: kernel resource is unsufficient, but not the memory,
              * but there is no suitable errno :(
              */
-            set_errno_and_return_minus_one( ENOMEM );
+            rtems_set_errno_and_return_minus_one( ENOMEM );
         }
     }
     _hash_insert(fs_info->vhash, key, lfat_fd->ino, lfat_fd);
@@ -383,11 +385,11 @@ fat_file_write(
         return cmpltd;
 
     if ( start > fat_fd->fat_file_size )
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
 
     if ((count > fat_fd->size_limit) ||
         (start > fat_fd->size_limit - count))
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
 
     rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
     if (rc != RC_OK)
@@ -493,7 +495,7 @@ fat_file_extend(
 
     if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
         (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
-        set_errno_and_return_minus_one( ENOSPC );
+        rtems_set_errno_and_return_minus_one( ENOSPC );
 
     bytes_remain = (fs_info->vol.bpc -
                    (fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
@@ -525,7 +527,7 @@ fat_file_extend(
 
     /* this means that no space left on device */
     if ((cls_added == 0) && (bytes_remain == 0))
-        set_errno_and_return_minus_one(ENOSPC);
+        rtems_set_errno_and_return_minus_one(ENOSPC);
 
     /*  check wether we satisfied request for 'cls2add' clusters */
     if (cls2add != cls_added)
@@ -687,7 +689,7 @@ fat_file_ioctl(
 
             /* sanity check */
             if ( pos >= fat_fd->fat_file_size )
-                set_errno_and_return_minus_one( EIO );
+                rtems_set_errno_and_return_minus_one( EIO );
 
             if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
                 (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
@@ -759,13 +761,13 @@ fat_file_datasync(
     fat_file_fd_t                        *fat_fd
     )
 {
-    int                rc = RC_OK;
-    rtems_status_code  sc = RTEMS_SUCCESSFUL;
-    fat_fs_info_t     *fs_info = mt_entry->fs_info;
-    uint32_t           cur_cln = fat_fd->cln;
-    bdbuf_buffer      *block = NULL;
-    uint32_t           sec = 0;
-    uint32_t           i = 0;
+    int                 rc = RC_OK;
+    rtems_status_code   sc = RTEMS_SUCCESSFUL;
+    fat_fs_info_t      *fs_info = mt_entry->fs_info;
+    uint32_t            cur_cln = fat_fd->cln;
+    rtems_bdbuf_buffer *block = NULL;
+    uint32_t            sec = 0;
+    uint32_t            i = 0;
 
     if (fat_fd->fat_file_size == 0)
         return RC_OK;
@@ -788,11 +790,11 @@ fat_file_datasync(
             /* ... sync it */
             sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
             if (sc != RTEMS_SUCCESSFUL)
-                set_errno_and_return_minus_one( EIO );
+                rtems_set_errno_and_return_minus_one( EIO );
 
             sc = rtems_bdbuf_sync(block);
             if ( sc != RTEMS_SUCCESSFUL )
-                set_errno_and_return_minus_one( EIO );
+                rtems_set_errno_and_return_minus_one( EIO );
         }
 
         rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
@@ -947,9 +949,7 @@ fat_file_lseek(
     )
 {
     int rc = RC_OK;
-/*
-    assert(fat_fd->fat_file_size);
- */
+
     if (file_cln == fat_fd->map.file_cln)
         *disk_cln = fat_fd->map.disk_cln;
     else
diff --git a/cpukit/libfs/src/dosfs/msdos_create.c b/cpukit/libfs/src/dosfs/msdos_create.c
index 8c238d396c..c790dd740f 100644
--- a/cpukit/libfs/src/dosfs/msdos_create.c
+++ b/cpukit/libfs/src/dosfs/msdos_create.c
@@ -129,9 +129,9 @@ msdos_creat_node(
       *MSDOS_DIR_FILE_SIZE(new_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
 
       *MSDOS_DIR_FIRST_CLUSTER_LOW(new_node) =
-	*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
+           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
       *MSDOS_DIR_FIRST_CLUSTER_HI(new_node) =
-	*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
+           *MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
       /*
        * set "archive bit" due to changes
        */
@@ -302,14 +302,14 @@ msdos_file_link(rtems_filesystem_location_info_t *to_loc,
      * check spelling and format new node name
      */
     if (MSDOS_NAME != msdos_get_token(token, new_name, &len)) {
-      set_errno_and_return_minus_one(ENAMETOOLONG);
+      rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
     }
     /*
      * verify, that the existing node can be linked to
      * check that nodes are in same FS/volume?
      */
     if (to_loc->mt_entry->fs_info != par_loc->mt_entry->fs_info) {
-      set_errno_and_return_minus_one(EXDEV);
+      rtems_set_errno_and_return_minus_one(EXDEV);
     }
     /*
      * lock volume
@@ -317,7 +317,7 @@ msdos_file_link(rtems_filesystem_location_info_t *to_loc,
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
 
     /*
@@ -334,7 +334,7 @@ msdos_file_link(rtems_filesystem_location_info_t *to_loc,
       to_fat_fd->cln           = FAT_EOF;
       rc = msdos_set_first_cluster_num(to_loc->mt_entry, to_fat_fd);
       if (rc == RC_OK) {
-	rc = msdos_set_file_size(par_loc->mt_entry, to_fat_fd);
+          rc = msdos_set_file_size(par_loc->mt_entry, to_fat_fd);
       }
     }
     /*
diff --git a/cpukit/libfs/src/dosfs/msdos_dir.c b/cpukit/libfs/src/dosfs/msdos_dir.c
index f76fa147a3..c2fb72aedd 100644
--- a/cpukit/libfs/src/dosfs/msdos_dir.c
+++ b/cpukit/libfs/src/dosfs/msdos_dir.c
@@ -56,7 +56,7 @@ msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
 
     rc = fat_file_reopen(fat_fd);
     if (rc != RC_OK)
@@ -91,7 +91,7 @@ msdos_dir_close(rtems_libio_t *iop)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
 
     rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
     if (rc != RC_OK)
@@ -233,7 +233,7 @@ msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     while (count > 0)
     {
@@ -248,7 +248,7 @@ msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
         if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
         {
             rtems_semaphore_release(fs_info->vol_sema);
-            set_errno_and_return_minus_one(EIO);
+            rtems_set_errno_and_return_minus_one(EIO);
         }
 
         for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
@@ -377,7 +377,7 @@ msdos_dir_lseek(rtems_libio_t *iop, off_t offset, int whence)
          */
         case SEEK_END:
         default:
-            set_errno_and_return_minus_one( EINVAL );
+            rtems_set_errno_and_return_minus_one( EINVAL );
             break;
     }
     return RC_OK;
@@ -416,7 +416,7 @@ msdos_dir_stat(
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     buf->st_dev = fs_info->fat.vol.dev;
     buf->st_ino = fat_fd->ino;
@@ -463,7 +463,7 @@ msdos_dir_sync(rtems_libio_t *iop)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
 
@@ -495,7 +495,7 @@ msdos_dir_rmnod(rtems_filesystem_location_info_t *pathloc)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /*
      * We deny attemp to delete open directory (if directory is current
@@ -504,7 +504,7 @@ msdos_dir_rmnod(rtems_filesystem_location_info_t *pathloc)
     if (fat_fd->links_num > 1)
     {
         rtems_semaphore_release(fs_info->vol_sema);
-        set_errno_and_return_minus_one(EBUSY);
+        rtems_set_errno_and_return_minus_one(EBUSY);
     }
 
     /*
@@ -520,7 +520,7 @@ msdos_dir_rmnod(rtems_filesystem_location_info_t *pathloc)
     if (!is_empty)
     {
         rtems_semaphore_release(fs_info->vol_sema);
-        set_errno_and_return_minus_one(ENOTEMPTY);
+        rtems_set_errno_and_return_minus_one(ENOTEMPTY);
     }
 
     /*
@@ -529,7 +529,7 @@ msdos_dir_rmnod(rtems_filesystem_location_info_t *pathloc)
     if (pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access)
     {
         rtems_semaphore_release(fs_info->vol_sema);
-        set_errno_and_return_minus_one(EBUSY);
+        rtems_set_errno_and_return_minus_one(EBUSY);
     }
 
     /*
diff --git a/cpukit/libfs/src/dosfs/msdos_eval.c b/cpukit/libfs/src/dosfs/msdos_eval.c
index 3e620b96a8..a1a9b4401a 100644
--- a/cpukit/libfs/src/dosfs/msdos_eval.c
+++ b/cpukit/libfs/src/dosfs/msdos_eval.c
@@ -89,7 +89,7 @@ msdos_eval_path(
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     if (!pathloc->node_access)
     {
@@ -271,7 +271,7 @@ msdos_eval4make(
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     if (!pathloc->node_access)
     {
diff --git a/cpukit/libfs/src/dosfs/msdos_file.c b/cpukit/libfs/src/dosfs/msdos_file.c
index 95c8a8d1fa..c8293d5b24 100644
--- a/cpukit/libfs/src/dosfs/msdos_file.c
+++ b/cpukit/libfs/src/dosfs/msdos_file.c
@@ -53,7 +53,7 @@ msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t   flag,
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     rc = fat_file_reopen(fat_fd);
     if (rc != RC_OK)
@@ -94,7 +94,7 @@ msdos_file_close(rtems_libio_t *iop)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /*
      * if fat-file descriptor is not marked as "removed", synchronize
@@ -154,7 +154,7 @@ msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
                         buffer);
@@ -187,7 +187,7 @@ msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
                          buffer);
@@ -235,7 +235,7 @@ msdos_file_lseek(rtems_libio_t *iop, off_t offset, int whence)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
                          &real_size);
@@ -276,7 +276,7 @@ msdos_file_stat(
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     buf->st_dev = fs_info->fat.vol.dev;
     buf->st_ino = fat_fd->ino;
@@ -315,7 +315,7 @@ msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
     if (rc != RC_OK)
@@ -356,7 +356,7 @@ msdos_file_sync(rtems_libio_t *iop)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /* synchronize file data */
     rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
@@ -416,7 +416,7 @@ msdos_file_datasync(rtems_libio_t *iop)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /* synchronize file data */
     rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
@@ -466,7 +466,7 @@ msdos_file_rmnod(rtems_filesystem_location_info_t *pathloc)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /* mark file removed */
     rc = msdos_set_first_char4file_name(pathloc->mt_entry, fat_fd->info_cln,
diff --git a/cpukit/libfs/src/dosfs/msdos_format.c b/cpukit/libfs/src/dosfs/msdos_format.c
index ba3e1042d8..bbd4689dc0 100644
--- a/cpukit/libfs/src/dosfs/msdos_format.c
+++ b/cpukit/libfs/src/dosfs/msdos_format.c
@@ -277,7 +277,7 @@ static int msdos_format_eval_sectors_per_cluster
   } while (!finished);
 
   if (ret_val != 0) {
-    set_errno_and_return_minus_one(ret_val);
+    rtems_set_errno_and_return_minus_one(ret_val);
   }
   else {
     *sectors_per_cluster_adj = sectors_per_cluster;
@@ -298,9 +298,9 @@ static int msdos_format_determine_fmt_params
 +---------------------------------------------------------------------------+
 | Input Parameters:                                                         |
 \*-------------------------------------------------------------------------*/
- const disk_device            *dd,       /* disk device structure          */
+ const rtems_disk_device            *dd,       /* disk device structure          */
  const msdos_format_request_param_t *rqdata,   /* requested fmt parameters */
- msdos_format_param_t         *fmt_params/* computed fmt parameters        */
+ msdos_format_param_t               *fmt_params/* computed fmt parameters        */
  )
 /*-------------------------------------------------------------------------*\
 | Return Value:                                                             |
@@ -613,7 +613,7 @@ static int msdos_format_determine_fmt_params
    * Phuuu.... That's it.
    */
   if (ret_val != 0) {
-    set_errno_and_return_minus_one(ret_val);
+    rtems_set_errno_and_return_minus_one(ret_val);
   }
   else {
     return 0;
@@ -791,13 +791,13 @@ int msdos_format
 |    0, if success, -1 and errno if failed                                  |
 \*=========================================================================*/
 {
-  char         tmp_sec[FAT_TOTAL_MBR_SIZE];
-  int          rc;
-  disk_device *dd        = NULL; 
-  struct stat  stat_buf;
-  int          ret_val   = 0;
-  int          fd        = -1;
-  int          i;
+  char                 tmp_sec[FAT_TOTAL_MBR_SIZE];
+  int                  rc;
+  rtems_disk_device   *dd        = NULL; 
+  struct stat          stat_buf;
+  int                  ret_val   = 0;
+  int                  fd        = -1;
+  int                  i;
   msdos_format_param_t fmt_params;
 
   /*
@@ -817,7 +817,7 @@ int msdos_format
   
   /* check that  device is registered as block device and lock it */
   if (ret_val == 0) {
-    dd = rtems_disk_lookup(stat_buf.st_dev);
+    dd = rtems_disk_obtain(stat_buf.st_dev);
     if (dd == NULL) {
       errno = ENOTBLK;
       ret_val = -1;
diff --git a/cpukit/libfs/src/dosfs/msdos_free.c b/cpukit/libfs/src/dosfs/msdos_free.c
index 2fb74e2387..90fc586a10 100644
--- a/cpukit/libfs/src/dosfs/msdos_free.c
+++ b/cpukit/libfs/src/dosfs/msdos_free.c
@@ -47,7 +47,7 @@ msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
 
diff --git a/cpukit/libfs/src/dosfs/msdos_initsupp.c b/cpukit/libfs/src/dosfs/msdos_initsupp.c
index ce86fa22b0..42495c7622 100644
--- a/cpukit/libfs/src/dosfs/msdos_initsupp.c
+++ b/cpukit/libfs/src/dosfs/msdos_initsupp.c
@@ -61,7 +61,7 @@ msdos_initialize_support(
 
     fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
     if (!fs_info)
-        set_errno_and_return_minus_one(ENOMEM);
+        rtems_set_errno_and_return_minus_one(ENOMEM);
 
     temp_mt_entry->fs_info = fs_info;
 
@@ -124,7 +124,7 @@ msdos_initialize_support(
         fat_file_close(temp_mt_entry, fat_fd);
         fat_shutdown_drive(temp_mt_entry);
         free(fs_info);
-        set_errno_and_return_minus_one(ENOMEM);
+        rtems_set_errno_and_return_minus_one(ENOMEM);
     }
 
     sc = rtems_semaphore_create(3,
@@ -138,7 +138,7 @@ msdos_initialize_support(
         fat_shutdown_drive(temp_mt_entry);
         free(fs_info->cl_buf);
         free(fs_info);
-        set_errno_and_return_minus_one( EIO );
+        rtems_set_errno_and_return_minus_one( EIO );
     }
 
     temp_mt_entry->mt_fs_root.node_access = fat_fd;
diff --git a/cpukit/libfs/src/dosfs/msdos_misc.c b/cpukit/libfs/src/dosfs/msdos_misc.c
index b7e6ab3523..077fb945b9 100644
--- a/cpukit/libfs/src/dosfs/msdos_misc.c
+++ b/cpukit/libfs/src/dosfs/msdos_misc.c
@@ -11,6 +11,8 @@
  *  @(#) $Id$
  */
 
+#define MSDOS_TRACE 1
+
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -786,7 +788,7 @@ int msdos_find_name_in_fat_file(
                                 fs_info->cl_buf)) != FAT_EOF)
     {
         if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
-            set_errno_and_return_minus_one(EIO);
+            rtems_set_errno_and_return_minus_one(EIO);
 
         assert(ret == bts2rd);
 
@@ -903,7 +905,7 @@ int msdos_find_node_by_cluster_num_in_fat_file(
                                   fs_info->cl_buf)) != FAT_EOF)
     {
         if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
-            set_errno_and_return_minus_one( EIO );
+            rtems_set_errno_and_return_minus_one( EIO );
 
         assert(ret == bts2rd);
 
diff --git a/cpukit/libfs/src/dosfs/msdos_mknod.c b/cpukit/libfs/src/dosfs/msdos_mknod.c
index cdc12da092..ac2a142cce 100644
--- a/cpukit/libfs/src/dosfs/msdos_mknod.c
+++ b/cpukit/libfs/src/dosfs/msdos_mknod.c
@@ -74,12 +74,12 @@ int msdos_mknod(
         type = MSDOS_REGULAR_FILE;
     }
     else
-        set_errno_and_return_minus_one(EINVAL);
+        rtems_set_errno_and_return_minus_one(EINVAL);
 
     sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
                                 MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
     if (sc != RTEMS_SUCCESSFUL)
-        set_errno_and_return_minus_one(EIO);
+        rtems_set_errno_and_return_minus_one(EIO);
 
     /* Create an MSDOS node */
     rc = msdos_creat_node(pathloc, type, new_name, mode, NULL);