Remove stray whitespaces.

44 files changed, 536 insertions, 536 deletions

diff --git a/cpukit/libfs/src/devfs/devfs_init.c b/cpukit/libfs/src/devfs/devfs_init.c
index 5f6521a045..62f31e86b9 100644
--- a/cpukit/libfs/src/devfs/devfs_init.c
+++ b/cpukit/libfs/src/devfs/devfs_init.c
@@ -35,7 +35,7 @@ rtems_filesystem_operations_table devFS_ops =
     rtems_filesystem_default_symlink,
     rtems_filesystem_default_readlink,
     rtems_filesystem_default_rename,
-    rtems_filesystem_default_statvfs 
+    rtems_filesystem_default_statvfs
 };
 
 
diff --git a/cpukit/libfs/src/devfs/devstat.c b/cpukit/libfs/src/devfs/devstat.c
index db17595621..e0c52b8b3d 100644
--- a/cpukit/libfs/src/devfs/devstat.c
+++ b/cpukit/libfs/src/devfs/devstat.c
@@ -36,7 +36,7 @@ int devFS_stat(
   #if defined(RTEMS_DEBUG)
     if (!the_dev)
       rtems_set_errno_and_return_minus_one( EFAULT );
-  #endif 
+  #endif
 
   buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
   buf->st_mode = the_dev->mode;
diff --git a/cpukit/libfs/src/dosfs/msdos_dir.c b/cpukit/libfs/src/dosfs/msdos_dir.c
index 916f2c8069..9a8ed1e54e 100644
--- a/cpukit/libfs/src/dosfs/msdos_dir.c
+++ b/cpukit/libfs/src/dosfs/msdos_dir.c
@@ -497,7 +497,7 @@ msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
  *     RC_OK on success, or -1 if error occured (errno
  *     set apropriately).
  */
-off_t        
+off_t
 msdos_dir_lseek(rtems_libio_t *iop, off_t offset, int whence)
 {
     switch (whence)
diff --git a/cpukit/libfs/src/dosfs/msdos_file.c b/cpukit/libfs/src/dosfs/msdos_file.c
index 3e53704a47..b0eeba97bf 100644
--- a/cpukit/libfs/src/dosfs/msdos_file.c
+++ b/cpukit/libfs/src/dosfs/msdos_file.c
@@ -222,7 +222,7 @@ msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
  *     new offset on success, or -1 if error occured (errno set
  *     appropriately).
  */
-off_t        
+off_t
 msdos_file_lseek(rtems_libio_t *iop, off_t offset, int whence)
 {
     int                rc = RC_OK;
diff --git a/cpukit/libfs/src/dosfs/msdos_misc.c b/cpukit/libfs/src/dosfs/msdos_misc.c
index d49b89048b..f272d842a2 100644
--- a/cpukit/libfs/src/dosfs/msdos_misc.c
+++ b/cpukit/libfs/src/dosfs/msdos_misc.c
@@ -125,7 +125,7 @@ msdos_name_type(const char *name, int name_len)
 #if MSDOS_NAME_TYPE_PRINT
         printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
 #endif
-        
+
         if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
             return type;
 
@@ -170,7 +170,7 @@ msdos_name_type(const char *name, int name_len)
 #endif
         return MSDOS_NAME_LONG;
     }
-    
+
 #if MSDOS_NAME_TYPE_PRINT
     printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
 #endif
@@ -283,7 +283,7 @@ msdos_get_token(const char  *path,
 
     if (pathlen == 0)
         return MSDOS_NO_MORE_PATH;
-    
+
     /*
      *  Check for a separator.
      */
diff --git a/cpukit/libfs/src/dosfs/msdos_rename.c b/cpukit/libfs/src/dosfs/msdos_rename.c
index 1f5a6d9c6a..1d285bd01d 100644
--- a/cpukit/libfs/src/dosfs/msdos_rename.c
+++ b/cpukit/libfs/src/dosfs/msdos_rename.c
@@ -79,14 +79,14 @@ msdos_rename(rtems_filesystem_location_info_t  *old_parent_loc,
         rtems_semaphore_release(fs_info->vol_sema);
         return rc;
     }
-    
+
     /*
      * mark file removed
      */
     rc = msdos_set_first_char4file_name(old_loc->mt_entry,
                                         &old_fat_fd->dir_pos,
                                         MSDOS_THIS_DIR_ENTRY_EMPTY);
-    
+
     rtems_semaphore_release(fs_info->vol_sema);
     return rc;
 }
diff --git a/cpukit/libfs/src/imfs/imfs_eval.c b/cpukit/libfs/src/imfs/imfs_eval.c
index b1f11b672f..3d093b0b3f 100644
--- a/cpukit/libfs/src/imfs/imfs_eval.c
+++ b/cpukit/libfs/src/imfs/imfs_eval.c
@@ -578,7 +578,7 @@ int IMFS_eval_path(
         if ( node->type == IMFS_HARD_LINK ) {
           IMFS_evaluate_hard_link( pathloc, 0 );
           node = pathloc->node_access;
-       
+
           /*
            * It would be a design error if we evaluated the link and
            * was broken.
diff --git a/cpukit/libfs/src/imfs/imfs_fifo.c b/cpukit/libfs/src/imfs/imfs_fifo.c
index e98a8df10d..0e21fe345e 100644
--- a/cpukit/libfs/src/imfs/imfs_fifo.c
+++ b/cpukit/libfs/src/imfs/imfs_fifo.c
@@ -56,7 +56,7 @@ int IMFS_fifo_close(
 
   iop->flags &= ~LIBIO_FLAGS_OPEN;
   IMFS_check_node_remove(jnode);
-  
+
   IMFS_FIFO_RETURN(err);
 }
 
diff --git a/cpukit/libfs/src/imfs/imfs_link.c b/cpukit/libfs/src/imfs/imfs_link.c
index 4c2136ba71..c7dc6475f9 100644
--- a/cpukit/libfs/src/imfs/imfs_link.c
+++ b/cpukit/libfs/src/imfs/imfs_link.c
@@ -55,7 +55,7 @@ int IMFS_link(
    *        was ONLY passed a NULL when we created the root node.  We
    *        added a new IMFS_create_root_node() so this path no longer
    *        existed.  The result was simpler code which should not have
-   *        this path. 
+   *        this path.
    */
   new_node = IMFS_create_node(
     parent_loc,
diff --git a/cpukit/libfs/src/imfs/imfs_load_tar.c b/cpukit/libfs/src/imfs/imfs_load_tar.c
index 3cb3c4e195..69c69c3e6d 100644
--- a/cpukit/libfs/src/imfs/imfs_load_tar.c
+++ b/cpukit/libfs/src/imfs/imfs_load_tar.c
@@ -19,7 +19,7 @@
  * Directories from the TAR file are created as usual in the IMFS.
  * File entries are created as IMFS_LINEAR_FILE nodes with their nods
  * pointing to addresses in the TAR image.
- */ 
+ */
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -160,7 +160,7 @@ int rtems_tarfs_load(
      *        IMFS_create_node was ONLY passed a NULL when we created the
      *        root node.  We added a new IMFS_create_root_node() so this
      *        path no longer existed.  The result was simpler code which
-     *        should not have this path. 
+     *        should not have this path.
      */
     else if (linkflag == REGTYPE) {
       const char  *name;
diff --git a/cpukit/libfs/src/imfs/imfs_mknod.c b/cpukit/libfs/src/imfs/imfs_mknod.c
index 2d09c73db5..747391e9fd 100644
--- a/cpukit/libfs/src/imfs/imfs_mknod.c
+++ b/cpukit/libfs/src/imfs/imfs_mknod.c
@@ -55,7 +55,7 @@ int IMFS_mknod(
     rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
   } else if (S_ISFIFO(mode))
     type = IMFS_FIFO;
-  else 
+  else
     IMFS_assert( 0 );
 
   /*
@@ -66,7 +66,7 @@ int IMFS_mknod(
    *        was ONLY passed a NULL when we created the root node.  We
    *        added a new IMFS_create_root_node() so this path no longer
    *        existed.  The result was simpler code which should not have
-   *        this path. 
+   *        this path.
    */
   new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
   if ( !new_node )
diff --git a/cpukit/libfs/src/imfs/imfs_rename.c b/cpukit/libfs/src/imfs/imfs_rename.c
index f45aa5b694..95c27fa9fd 100644
--- a/cpukit/libfs/src/imfs/imfs_rename.c
+++ b/cpukit/libfs/src/imfs/imfs_rename.c
@@ -36,15 +36,15 @@ int IMFS_rename(
   the_jnode = old_loc->node_access;
 
   strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
-  
+
   if ( the_jnode->Parent != NULL )
     rtems_chain_extract( (rtems_chain_node *) the_jnode );
 
   new_parent = new_parent_loc->node_access;
   the_jnode->Parent = new_parent;
-  
+
   rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
-  
+
   /*
    * Update the time.
    */
diff --git a/cpukit/libfs/src/imfs/imfs_stat.c b/cpukit/libfs/src/imfs/imfs_stat.c
index 0172680409..2b4b2d6eef 100644
--- a/cpukit/libfs/src/imfs/imfs_stat.c
+++ b/cpukit/libfs/src/imfs/imfs_stat.c
@@ -66,7 +66,7 @@ int IMFS_stat(
   fs_info = loc->mt_entry->fs_info;
   buf->st_dev =
     rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
-  
+
   buf->st_mode  = the_jnode->st_mode;
   buf->st_nlink = the_jnode->st_nlink;
   buf->st_ino   = the_jnode->st_ino;
diff --git a/cpukit/libfs/src/imfs/imfs_symlink.c b/cpukit/libfs/src/imfs/imfs_symlink.c
index 7094f219fb..863ad23510 100644
--- a/cpukit/libfs/src/imfs/imfs_symlink.c
+++ b/cpukit/libfs/src/imfs/imfs_symlink.c
@@ -58,7 +58,7 @@ int IMFS_symlink(
    *        was ONLY passed a NULL when we created the root node.  We
    *        added a new IMFS_create_root_node() so this path no longer
    *        existed.  The result was simpler code which should not have
-   *        this path. 
+   *        this path.
    */
   new_node = IMFS_create_node(
     parent_loc,
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
index 1240940bc2..db77a5177c 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
@@ -60,7 +60,7 @@ rtems_rfs_bitmap_ut_test_range (rtems_rfs_bitmap_control* control,
       return false;
     }
   }
-  
+
   printf (" %2d. Test bit range (%" PRId32 ",%ld] all %s: pass\n",
           test, bit, bit + size - 1, set ? "set" : "clear");
 
@@ -76,7 +76,7 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
   bool state;
   int  i;
   int  rc;
-  
+
   printf (" %2d. Set all bits\n", test);
   rc = rtems_rfs_bitmap_map_set_all (control);
   if (rc > 0)
@@ -84,13 +84,13 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
     printf (" %2d. set all bits: FAIL (%s)\n", test, strerror (rc));
     return false;
   }
-  
+
   for (i = 0; i < size; i++)
     rtems_rfs_bitmap_map_clear (control, bit + i);
-  
+
   printf (" %2d. Cleared bits (%" PRId32 ", %ld] (%zd)\n",
           test, bit, bit + size - 1, size);
-  
+
   for (i = 0; i < rtems_rfs_bitmap_element_bits (); i++)
   {
     rc = rtems_rfs_bitmap_map_test (control, bit + i, &state);
@@ -105,7 +105,7 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
       return false;
     }
   }
-  
+
   for (i = 0, bit = 0; i < size; i++)
   {
     rtems_rfs_bitmap_bit seed = bit;
@@ -127,7 +127,7 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
 
   printf (" %2d. Alloc'ed all bits (%" PRId32 ", %ld] (%zd)\n",
           test, bit, bit + size - 1, size);
-  
+
   return true;
 }
 
@@ -151,7 +151,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
 
   memset (&fs, 0, sizeof (fs));
   memset (&buffer, 0, sizeof (buffer));
-  
+
   buffer.buffer = malloc (bytes);
   buffer.block = 1;
 
@@ -166,7 +166,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
 #else
   memset (buffer.buffer, 0xff, bytes);
 #endif
-  
+
   /*
    * Do not close the handle so no writes need occur.
    */
@@ -180,10 +180,10 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
 
   handle.buffer = &buffer;
   handle.bnum = 1;
-  
+
   printf ("\nRFS Bitmap Test : size = %zd (%zd)\n",
           size, rtems_rfs_bitmap_elements (size));
-  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1); 
+  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1);
   if (rc > 0)
   {
     printf (" Cannot open the bitmap: %s\n", strerror (rc));
@@ -199,7 +199,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   printf ("  1. Find bit with seed > size: %s (%s)\n",
           result ? "FAIL" : "pass", strerror (rc));
   rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, size, &result, &bit);
   printf ("  2. Find bit with seed = size: %s (%s)\n",
           result ? "FAIL" : "pass", strerror (rc));
@@ -210,14 +210,14 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   printf ("  3. Find bit 0 with seed = 0: %s (%s): bit = %" PRId32 "\n",
           result ? "pass" : "FAIL", strerror (rc),  bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
   result = result && (bit == (size - 1));
   printf ("  4. Find bit (size - 1) with seed = (size - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
           size - 1, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
-  
+
   /*
    * Test the bits allocated to make sure they are set.
    */
@@ -226,12 +226,12 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   printf ("  5. Test bit 0: %s (%s)\n",
           result ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_test (&control, size - 1, &result);
   printf ("  6. Test bit (size - 1) (%zd): %s (%s)\n",
           size - 1, result ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   if (!rtems_rfs_bitmap_ut_test_range (&control, 7, false, 1, size - 2))
     rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
 
@@ -244,7 +244,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
 
   bit = rand () % size;
-  
+
   rc = rtems_rfs_bitmap_map_clear (&control, bit);
   printf ("  9. Clear bit %" PRId32 ": %s (%s)\n",
           bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
@@ -256,18 +256,18 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   printf (" 10. Find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
           result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
   result = !result || (bit != last_bit);
   printf (" 11. Fail to find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
           result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_clear (&control, 0);
   printf (" 12. Clear bit 0: %s (%s)\n",
           rc == 0 ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
   result = result && (bit == 0);
   printf (" 13. Find bit with seed = (size - 1): %s (%s): bit = %" PRId32 "\n",
@@ -288,7 +288,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   rc = rtems_rfs_bitmap_map_clear (&control, 0);
   printf (" 16. Clear bit 0: %s (%s)\n",
           rc == 0 ? "pass" : "FAIL", strerror (rc));
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
   result = result && (bit == 0);
   printf (" 17. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %" PRId32 "\n",
@@ -299,7 +299,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   printf (" 18. Clear bit (size - 1) (%zd): %s, (%s)\n",
           size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
   result = result && (bit == (size - 1));
   printf (" 19. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %" PRId32 "\n",
@@ -309,7 +309,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   rc = rtems_rfs_bitmap_map_clear (&control, 0);
   printf (" 20. Clear bit 0: %s (%s)\n",
           rc == 0 ? "pass" : "FAIL", strerror (rc));
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
   result = result && (bit == 0);
   printf (" 21. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
@@ -319,7 +319,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
   printf (" 22. Clear bit (size - 1) (%zd): %s (%s)\n",
           size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
-  
+
   rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
   result = result && (bit == (size - 1));
   printf (" 23. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
@@ -330,7 +330,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 23, bit,
                                                rtems_rfs_bitmap_element_bits ());
   rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
-  
+
   bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
   result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 24, bit, 57);
   rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
@@ -344,7 +344,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
           rc == 0 ? "PASS" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
 
-  first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits (); 
+  first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
   last_bit = first_bit + rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
 
   for (bit = first_bit; bit < last_bit; bit++)
@@ -357,10 +357,10 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
       rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
     }
   }
-  
+
   printf (" 26. Clear bit (%" PRId32 ", %" PRId32 "]: %s (%s)\n",
           first_bit, last_bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
-  
+
   clear = rtems_rfs_bitmap_map_free (&control);
   result = clear == (last_bit - first_bit);
   printf (" 27. Check free count is %zd: %" PRId32 ": %s (%s)\n",
@@ -373,7 +373,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
           clear, rtems_rfs_bitmap_map_free (&control),
           result ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
-  
+
   rtems_rfs_bitmap_close (&control);
   free (buffer.buffer);
 }
@@ -391,7 +391,7 @@ rtems_rfs_bitmap_unit_test (void)
 #else
   srand (0x2398);
 #endif
-  
+
   rtems_rfs_bitmap_ut_test_bitmap (2048);
   rtems_rfs_bitmap_ut_test_bitmap (420);
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c
index 98715488f9..d6e006ea68 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c
@@ -44,7 +44,7 @@
  * @retval false The bit is clear.
  */
 static bool
-rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target, 
+rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
                        rtems_rfs_bitmap_bit     bit)
 {
   return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
@@ -59,7 +59,7 @@ rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
  *             same bit in the target.
  */
 static rtems_rfs_bitmap_element
-rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target, 
+rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
                       rtems_rfs_bitmap_element bits)
 {
   return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
@@ -106,7 +106,7 @@ rtems_rfs_bitmap_merge (rtems_rfs_bitmap_element bits1,
  * @param bits1 One set of bits to match.
  * @param bits2 The second set of bits to match.
  * @retval true The bits match.
- * @retval false The bits do not match. 
+ * @retval false The bits do not match.
  */
 static bool
 rtems_rfs_bitmap_match (rtems_rfs_bitmap_element bits1,
@@ -124,7 +124,7 @@ rtems_rfs_bitmap_match (rtems_rfs_bitmap_element bits1,
  * @param bits1 One set of bits to match.
  * @param bits2 The second set of bits to match.
  * @retval true The bits match.
- * @retval false The bits do not match. 
+ * @retval false The bits do not match.
  */
 static bool
 rtems_rfs_bitmap_match_masked (rtems_rfs_bitmap_element mask,
@@ -147,19 +147,19 @@ rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
                            rtems_rfs_bitmap_map*     map)
 {
   int rc;
-  
+
   if (!control->buffer)
     return ENXIO;
 
   *map = NULL;
-  
+
   rc = rtems_rfs_buffer_handle_request (control->fs,
                                         control->buffer,
                                         control->block,
                                         true);
   if (rc)
     return rc;
-  
+
   *map = rtems_rfs_buffer_data (control->buffer);
   return 0;
 }
@@ -267,16 +267,16 @@ rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
   rc = rtems_rfs_bitmap_load_map (control, &map);
   if (rc > 0)
     return rc;
-  
+
   elements = rtems_rfs_bitmap_elements (control->size);
 
   control->free = 0;
-  
+
   for (e = 0; e < elements; e++)
     map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
-  
+
   elements = rtems_rfs_bitmap_elements (elements);
-  
+
   for (e = 0; e < elements; e++)
     control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
 
@@ -293,15 +293,15 @@ rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
   size_t               elements;
   int                  e;
   int                  rc;
-  
+
   rc = rtems_rfs_bitmap_load_map (control, &map);
   if (rc > 0)
     return rc;
-  
+
   elements = rtems_rfs_bitmap_elements (control->size);
-  
+
   control->free = elements;
-  
+
   for (e = 0; e < elements; e++)
     map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
 
@@ -313,12 +313,12 @@ rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
 
   if (last_search_bit == 0)
     last_search_bit = rtems_rfs_bitmap_element_bits ();
-  
+
   elements = rtems_rfs_bitmap_elements (elements);
-  
+
   for (e = 0; e < (elements - 1); e++)
     control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
-  
+
   control->search_bits[elements - 1] =
     rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
                             RTEMS_RFS_BITMAP_ELEMENT_SET,
@@ -348,14 +348,14 @@ rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   int                       rc;
 
   *found = false;
-  
+
   /*
    * Load the bitmap.
    */
   rc = rtems_rfs_bitmap_load_map (control, &map);
   if (rc > 0)
     return rc;
-  
+
   /*
    * Calculate the bit we are testing plus the end point we search over.
    */
@@ -366,7 +366,7 @@ rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
     end_bit = 0;
   else if (end_bit >= control->size)
     end_bit = control->size - 1;
-  
+
   map_index     = rtems_rfs_bitmap_map_index (test_bit);
   map_offset    = rtems_rfs_bitmap_map_offset (test_bit);
   search_index  = rtems_rfs_bitmap_map_index (map_index);
@@ -374,7 +374,7 @@ rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 
   search_bits = &control->search_bits[search_index];
   map_bits    = &map[map_index];
-  
+
   /*
    * Check each bit from the search map offset for a clear bit.
    */
@@ -424,11 +424,11 @@ rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
         map_bits  += direction;
         map_index += direction;
         map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
-        
+
         test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
-    
+
         search_offset += direction;
-      
+
         if (((direction < 0) && (test_bit <= end_bit))
             || ((direction > 0) && (test_bit >= end_bit)))
           break;
@@ -473,7 +473,7 @@ rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
   }
   while (((direction < 0) && (test_bit >= end_bit))
          || ((direction > 0) && (test_bit <= end_bit)));
-    
+
   return 0;
 }
 
@@ -492,7 +492,7 @@ rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
    * By default we assume the allocation failed.
    */
   *allocated = false;
-  
+
   /*
    * The window is the number of bits we search over in either direction each
    * time.
@@ -549,7 +549,7 @@ rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
     if (lower_seed >= 0)
       lower_seed -= window;
   }
-  
+
   return 0;
 }
 
@@ -561,7 +561,7 @@ rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
   size_t               size;
   rtems_rfs_bitmap_bit bit;
   int                  rc;
-  
+
   rc = rtems_rfs_bitmap_load_map (control, &map);
   if (rc > 0)
     return rc;
@@ -570,7 +570,7 @@ rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
   search_map = control->search_bits;
   size = control->size;
   bit = 0;
-  
+
   *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
   while (size)
   {
@@ -588,7 +588,7 @@ rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
       bits      = *map;
       available = rtems_rfs_bitmap_element_bits ();
     }
-    
+
     if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
       rtems_rfs_bitmap_set (*search_map, bit);
     else
@@ -600,7 +600,7 @@ rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
     }
 
     size -= available;
-    
+
     if (bit == rtems_rfs_bitmap_element_bits ())
     {
       bit = 0;
@@ -623,15 +623,15 @@ rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
                        rtems_rfs_buffer_block    block)
 {
   size_t elements = rtems_rfs_bitmap_elements (size);
-  
+
   control->buffer = buffer;
   control->fs = fs;
   control->block = block;
   control->size = size;
-  
+
   elements = rtems_rfs_bitmap_elements (elements);
   control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
-  
+
   if (!control->search_bits)
     return ENOMEM;
 
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h
index 50759b529d..f8915aae5d 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h
@@ -197,7 +197,7 @@ rtems_rfs_bitmap_element rtems_rfs_bitmap_mask (unsigned int size);
  * @param end The end bit of the mask numbered from 0.
  * @return Mask section as defined by the start and end arguments.
  */
-rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, 
+rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start,
                                                         unsigned int end);
 
 /**
@@ -240,7 +240,7 @@ rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
  *
  * @param control The bitmap control.
  * @return int The error number (errno). No error if 0.
- */ 
+ */
 int rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control);
 
 /**
@@ -248,7 +248,7 @@ int rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control);
  *
  * @param control The bitmap control.
  * @return int The error number (errno). No error if 0.
- */ 
+ */
 int rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control);
 
 /**
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-block-pos.h b/cpukit/libfs/src/rfs/rtems-rfs-block-pos.h
index b15f0ba113..85a10b69da 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-block-pos.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-block-pos.h
@@ -126,7 +126,7 @@ rtems_rfs_block_add_pos (rtems_rfs_file_system*  fs,
                          rtems_rfs_pos_rel       offset,
                          rtems_rfs_block_pos*    bpos)
 {
-  rtems_rfs_block_get_bpos (fs, 
+  rtems_rfs_block_get_bpos (fs,
                             rtems_rfs_block_get_pos (fs, bpos) + offset,
                             bpos);
   bpos->block = 0;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-block.c b/cpukit/libfs/src/rfs/rtems-rfs-block.c
index 776c7f314d..22b9271f6b 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-block.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-block.c
@@ -109,7 +109,7 @@ rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,
   map->inode = NULL;
   rtems_rfs_block_set_size_zero (&map->size);
   rtems_rfs_block_set_bpos_zero (&map->bpos);
-  
+
   rc = rtems_rfs_buffer_handle_open (fs, &map->singly_buffer);
   if (rc > 0)
     return rc;
@@ -124,7 +124,7 @@ rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,
     rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
     return rc;
   }
-  
+
   /*
    * Extract the block and block count data from the inode into the targets
    * byte order.
@@ -138,7 +138,7 @@ rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,
   map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
 
   rc = rtems_rfs_inode_unload (fs, inode, false);
-  
+
   return rc;
 }
 
@@ -154,7 +154,7 @@ rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
     brc = rtems_rfs_inode_load (fs, map->inode);
     if (brc > 0)
       rc = brc;
-    
+
     if (rc == 0)
     {
       int b;
@@ -169,7 +169,7 @@ rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
       brc = rtems_rfs_inode_unload (fs, map->inode, true);
       if (brc > 0)
         rc = brc;
-      
+
       map->dirty = false;
     }
   }
@@ -225,7 +225,7 @@ rtems_rfs_block_find_indirect (rtems_rfs_file_system*   fs,
     *result = 0;
     rc = EIO;
   }
-  
+
   return 0;
 }
 
@@ -238,7 +238,7 @@ rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
   int rc = 0;
 
   *block = 0;
-  
+
   /*
    * Range checking here makes the remaining logic simpler.
    */
@@ -270,7 +270,7 @@ rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
        */
       rtems_rfs_block_no direct;
       rtems_rfs_block_no singly;
-    
+
       direct = bpos->bno % fs->blocks_per_block;
       singly = bpos->bno / fs->blocks_per_block;
 
@@ -316,7 +316,7 @@ rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
            */
           rc = ENXIO;
         }
-      }    
+      }
     }
   }
 
@@ -325,7 +325,7 @@ rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
     rtems_rfs_block_copy_bpos (&map->bpos, bpos);
     map->bpos.block = *block;
   }
-  
+
   return rc;
 }
 
@@ -409,7 +409,7 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
                           rtems_rfs_block_no*    new_block)
 {
   int b;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
     printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
             blocks, map->size.count);
@@ -425,12 +425,12 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
   {
     rtems_rfs_bitmap_bit block;
     int                  rc;
-    
+
     /*
      * Allocate the block. If an indirect block is needed and cannot be
      * allocated free this block.
      */
-    
+
     rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
                                        false, &block);
     if (rc > 0)
@@ -445,7 +445,7 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
        */
       rtems_rfs_block_no direct;
       rtems_rfs_block_no singly;
-      
+
       direct = map->size.count % fs->blocks_per_block;
       singly = map->size.count / fs->blocks_per_block;
 
@@ -561,7 +561,7 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
 
           singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
                                                      singly);
-          
+
           rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                 singly_block, true);
           if (rc > 0)
@@ -577,7 +577,7 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
 
     map->size.count++;
     map->size.offset = 0;
-    
+
     if (b == 0)
       *new_block = block;
     map->last_data_block = block;
@@ -617,7 +617,7 @@ rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system*   fs,
       ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
   {
     rtems_rfs_block_no block_to_free = map->blocks[indirect];
-  
+
     if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
     {
       /*
@@ -634,14 +634,14 @@ rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system*   fs,
        */
       map->blocks[indirect] = 0;
     }
-    
+
     rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
     if (rc > 0)
       return rc;
-    
+
     map->last_map_block = block_to_free;
   }
-  
+
   return rc;
 }
 
@@ -653,10 +653,10 @@ rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
     printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
             blocks, map->size.count);
-            
+
   if (map->size.count == 0)
     return 0;
-    
+
   if (blocks > map->size.count)
     blocks = map->size.count;
 
@@ -667,7 +667,7 @@ rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
     int                rc;
 
     block = map->size.count - 1;
-    
+
     if (block < RTEMS_RFS_INODE_BLOCKS)
     {
       /*
@@ -702,7 +702,7 @@ rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
                                               map->blocks[singly], true);
         if (rc > 0)
           return rc;
-        
+
         block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
                                                     direct);
 
@@ -752,14 +752,14 @@ rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
           rc = rtems_rfs_group_bitmap_free (fs, false, singly);
           if (rc > 0)
             return rc;
-          
+
           map->last_map_block = singly;
-          
+
           rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
                                                     doubly, doubly_singly);
           if (rc)
             return rc;
-        }        
+        }
       }
       else
       {
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-block.h b/cpukit/libfs/src/rfs/rtems-rfs-block.h
index e4e3f95830..473233e1b0 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-block.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-block.h
@@ -51,7 +51,7 @@
                          ((_b) * sizeof (rtems_rfs_block_no)), (_n)); \
     rtems_rfs_buffer_mark_dirty (_h); \
   } while (0)
-  
+
 /**
  * A block map manges the block lists that originate from an inode. The inode
  * contains a number of block numbers. A block map takes those block numbers
@@ -196,7 +196,7 @@ typedef struct rtems_rfs_block_map_s
  * @param map Pointer to the open map to set the offset in.
  * @param offset The offset to set in the map's size.
  */
-static inline void 
+static inline void
 rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
                                      rtems_rfs_block_off  offset)
 {
@@ -210,7 +210,7 @@ rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
  * @param map Pointer to the open map to set the offset in.
  * @param size The size to set in the map's size.
  */
-static inline void 
+static inline void
 rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,
                               rtems_rfs_block_size* size)
 {
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c b/cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c
index 536b136ed6..5144b1d51f 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c
@@ -85,7 +85,7 @@ rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
 #endif
     rc = EIO;
   }
-  
+
   return rc;
 }
 
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c b/cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c
index 714c2bf300..18550ac89b 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c
@@ -34,7 +34,7 @@
 
 int
 rtems_rfs_buffer_deviceio_request (rtems_rfs_buffer_handle* handle,
-                                   dev_t                    device, 
+                                   dev_t                    device,
                                    rtems_rfs_buffer_block   block,
                                    bool                     read)
 {
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-buffer.c b/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
index 43fb586895..ea5cbb3fb3 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
@@ -41,7 +41,7 @@ rtems_rfs_scan_chain (rtems_chain_control*   chain,
 {
   rtems_rfs_buffer* buffer;
   rtems_chain_node* node;
-  
+
   node = rtems_chain_last (chain);
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
@@ -81,7 +81,7 @@ rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
                                  bool                     read)
 {
   int rc;
-  
+
   /*
    * If the handle has a buffer release it. This allows a handle to be reused
    * without needing to close then open it again.
@@ -158,7 +158,7 @@ rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
         rtems_rfs_buffer_mark_dirty (handle);
     }
   }
-    
+
   /*
    * If not located we request the buffer from the I/O layer.
    */
@@ -183,15 +183,15 @@ rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
   rtems_rfs_buffer_refs_up (handle);
   rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
   fs->buffers_count++;
-  
+
   handle->buffer->user = (void*) ((intptr_t) block);
   handle->bnum = block;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
     printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
             block, read ? "read" : "get", handle->buffer->block,
             handle->buffer->references);
-  
+
   return 0;
 }
 
@@ -200,7 +200,7 @@ rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
                                  rtems_rfs_buffer_handle* handle)
 {
   int rc = 0;
-  
+
   if (rtems_rfs_buffer_handle_has_block (handle))
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
@@ -212,12 +212,12 @@ rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
 
     if (rtems_rfs_buffer_refs (handle) > 0)
       rtems_rfs_buffer_refs_down (handle);
-    
+
     if (rtems_rfs_buffer_refs (handle) == 0)
     {
       rtems_chain_extract (rtems_rfs_buffer_link (handle));
       fs->buffers_count--;
-      
+
       if (rtems_rfs_fs_no_local_cache (fs))
       {
         handle->buffer->user = (void*) 0;
@@ -240,11 +240,11 @@ rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
         {
           rtems_rfs_buffer* buffer;
           bool              modified;
-        
+
           if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
             printf ("rtems-rfs: buffer-release: local cache overflow:"
                     " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
-        
+
           if (fs->release_count > fs->release_modified_count)
           {
             buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
@@ -261,7 +261,7 @@ rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
           buffer->user = (void*) 0;
           rc = rtems_rfs_buffer_io_release (buffer, modified);
         }
-      
+
         if (rtems_rfs_buffer_dirty (handle))
         {
           rtems_chain_append (&fs->release_modified,
@@ -277,7 +277,7 @@ rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
     }
     handle->buffer = NULL;
   }
-  
+
   return rc;
 }
 
@@ -288,7 +288,7 @@ rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
     printf ("rtems-rfs: buffer-open: opening: %s\n", name);
-  
+
   if (stat (name, &st) < 0)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
@@ -333,7 +333,7 @@ rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
     printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
             rtems_rfs_fs_media_blocks (fs),
             rtems_rfs_fs_media_block_size (fs));
-  
+
   return 0;
 }
 
@@ -354,7 +354,7 @@ rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
   if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
     printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
             rc, strerror (rc));
-  
+
 #if RTEMS_RFS_USE_LIBBLOCK
   rtems_disk_release (fs->disk);
 #else
@@ -366,7 +366,7 @@ rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
               rc, strerror (rc));
   }
 #endif
-  
+
   return rc;
 }
 
@@ -418,12 +418,12 @@ rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
   if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
     printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
             rc, strerror (rc));
-  
+
   rc = rtems_rfs_buffer_sync (fs);
   if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
     printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
             rc, strerror (rc));
-  
+
 #if RTEMS_RFS_USE_LIBBLOCK
   rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
   if (rc < 0)
@@ -450,7 +450,7 @@ rtems_rfs_release_chain (rtems_chain_control* chain,
     (*count)--;
 
     buffer->user = (void*) 0;
-    
+
     rc = rtems_rfs_buffer_io_release (buffer, modified);
     if ((rc > 0) && (rrc == 0))
       rrc = rc;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-buffer.h b/cpukit/libfs/src/rfs/rtems-rfs-buffer.h
index e207f5c7d3..3bb09490e1 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-buffer.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-buffer.h
@@ -168,7 +168,7 @@ typedef struct rtems_rfs_buffer_handle_t
  * @param read Read the data from the disk.
  * @return int The error number (errno). No error if 0.
  */
-int rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs, 
+int rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
                                      rtems_rfs_buffer_handle* handle,
                                      rtems_rfs_buffer_block   block,
                                      bool                     read);
@@ -197,7 +197,7 @@ rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,
                               rtems_rfs_buffer_handle* handle)
 {
   handle->dirty = false;
-  handle->bnum  = 0; 
+  handle->bnum  = 0;
   handle->buffer = NULL;
   return 0;
 }
@@ -215,7 +215,7 @@ rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,
 {
   rtems_rfs_buffer_handle_release (fs, handle);
   handle->dirty = false;
-  handle->bnum  = 0; 
+  handle->bnum  = 0;
   handle->buffer = NULL;
   return 0;
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c b/cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c
index 0aaf405213..8611f58571 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c
@@ -56,10 +56,10 @@
   If four pairs of (a,b,c) inputs are run through mix(), or through mix() in
   reverse, there are at least 32 bits of the output that are sometimes the same
   for one pair and different for another pair.  This was tested for:
-  
+
   * pairs that differed by one bit, by two bits, in any combination of top bits
     of (a,b,c), or in any combination of bottom bits of (a,b,c).
-      
+
   * "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed the
     output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly
     produced by subtraction) look like a single 1-bit difference.
@@ -69,11 +69,11 @@
 
   Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that satisfy this
   are:
-  
+
      4  6  8 16 19  4
      9 15  3 18 27 15
     14  9  3  7 17  3
-    
+
   Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for "differ" defined
   as + with a one-bit base and a two-bit delta.  I used
   http://burtleburtle.net/bob/hash/avalanche.html to choose the operations,
@@ -106,10 +106,10 @@
 
   Pairs of (a,b,c) values differing in only a few bits will usually produce
   values of c that look totally different.  This was tested for
-  
+
   * pairs that differed by one bit, by two bits, in any combination of top bits
     of (a,b,c), or in any combination of bottom bits of (a,b,c).
-  
+
   * "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed the
     output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly
     produced by subtraction) look like a single 1-bit difference.  * the base
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-dir.c b/cpukit/libfs/src/rfs/rtems-rfs-dir.c
index 0b0275cec0..fc53e528fb 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-dir.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-dir.c
@@ -77,7 +77,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
 
   *ino = RTEMS_RFS_EMPTY_INO;
   *offset = 0;
-  
+
   rc = rtems_rfs_block_map_open (fs, inode, &map);
   if (rc > 0)
   {
@@ -86,7 +86,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
               rtems_rfs_inode_ino (inode), rc, strerror (rc));
     return rc;
   }
-  
+
   rc = rtems_rfs_buffer_handle_open (fs, &entries);
   if (rc > 0)
   {
@@ -105,7 +105,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
      * Calculate the hash of the look up string.
      */
     hash = rtems_rfs_dir_hash (name, length);
-  
+
     /*
      * Locate the first block. The map points to the start after open so just
      * seek 0. If an error the block will be 0.
@@ -122,16 +122,16 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
       rtems_rfs_block_map_close (fs, &map);
       return rc;
     }
-        
+
     while ((rc == 0) && block)
     {
       uint8_t* entry;
-      
+
       if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
         printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
                 rtems_rfs_inode_ino (inode), map.bpos.bno);
-      
-      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 
+
+      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
       if (rc > 0)
       {
         if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
@@ -146,21 +146,21 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
        */
 
       entry = rtems_rfs_buffer_data (&entries);
-      
+
       map.bpos.boff = 0;
 
       while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
       {
         uint32_t ehash;
         int      elength;
-      
+
         ehash  = rtems_rfs_dir_entry_hash (entry);
         elength = rtems_rfs_dir_entry_length (entry);
         *ino = rtems_rfs_dir_entry_ino (entry);
 
         if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
           break;
-        
+
         if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
         {
           if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
@@ -170,7 +170,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
           rc = EIO;
           break;
         }
-          
+
         if (ehash == hash)
         {
           if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
@@ -183,7 +183,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
           if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
           {
             *offset = rtems_rfs_block_map_pos (fs, &map);
-            
+
             if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
               printf ("rtems-rfs: dir-lookup-ino: "
                       "entry found in ino %" PRIu32 ", ino=%" PRIu32 " offset=%" PRIu32 "\n",
@@ -222,7 +222,7 @@ rtems_rfs_dir_lookup_ino (rtems_rfs_file_system*  fs,
                 rtems_rfs_inode_ino (inode), rc, strerror (rc));
     }
   }
-  
+
   rtems_rfs_buffer_handle_close (fs, &entries);
   rtems_rfs_block_map_close (fs, &map);
   return rc;
@@ -249,7 +249,7 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
       printf ("%c", name[c]);
     printf (", len=%zd\n", length);
   }
-        
+
   rc = rtems_rfs_block_map_open (fs, dir, &map);
   if (rc > 0)
     return rc;
@@ -260,19 +260,19 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
     rtems_rfs_block_map_close (fs, &map);
     return rc;
   }
-  
+
   /*
    * Search the map from the beginning to find any empty space.
    */
   rtems_rfs_block_set_bpos_zero (&bpos);
-  
+
   while (true)
   {
     rtems_rfs_block_no block;
     uint8_t*           entry;
     int                offset;
     bool               read = true;
-    
+
     /*
      * Locate the first block. If an error the block will be 0. If the map is
      * empty which happens when creating a directory and adding the first entry
@@ -307,7 +307,7 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
     }
 
     bpos.bno++;
-    
+
     rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
     if (rc > 0)
     {
@@ -317,14 +317,14 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
                 rtems_rfs_inode_ino (dir), rc, strerror (rc));
       break;
     }
-    
+
     entry  = rtems_rfs_buffer_data (&buffer);
-    
+
     if (!read)
       memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
 
     offset = 0;
-    
+
     while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
     {
       rtems_rfs_ino eino;
@@ -353,7 +353,7 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
 
         break;
       }
-      
+
       if (rtems_rfs_dir_entry_valid (fs, elength, eino))
       {
         if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
@@ -364,12 +364,12 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
         rtems_rfs_block_map_close (fs, &map);
         return EIO;
       }
-        
+
       entry  += elength;
       offset += elength;
     }
   }
-  
+
   rtems_rfs_buffer_handle_close (fs, &buffer);
   rtems_rfs_block_map_close (fs, &map);
   return rc;
@@ -380,7 +380,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
                          rtems_rfs_inode_handle* dir,
                          rtems_rfs_ino           ino,
                          uint32_t                offset)
-{  
+{
   rtems_rfs_block_map     map;
   rtems_rfs_block_no      block;
   rtems_rfs_buffer_handle buffer;
@@ -420,7 +420,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
   {
     uint8_t* entry;
     int      eoffset;
-    
+
     rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
     if (rc > 0)
     {
@@ -439,9 +439,9 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
       eoffset = 0;
     else
       eoffset = offset % rtems_rfs_fs_block_size (fs);
-    
+
     entry = rtems_rfs_buffer_data (&buffer) + eoffset;
-    
+
     while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
     {
       rtems_rfs_ino eino;
@@ -452,7 +452,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
 
       if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
         break;
-      
+
       if (rtems_rfs_dir_entry_valid (fs, elength, eino))
       {
         if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
@@ -499,7 +499,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
                       rtems_rfs_inode_ino (dir), rc, strerror (rc));
           }
         }
-        
+
         rtems_rfs_buffer_mark_dirty (&buffer);
         rtems_rfs_buffer_handle_close (fs, &buffer);
         rtems_rfs_block_map_close (fs, &map);
@@ -511,7 +511,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
         rc = EIO;
         break;
       }
-      
+
       entry   += elength;
       eoffset += elength;
     }
@@ -523,7 +523,7 @@ rtems_rfs_dir_del_entry (rtems_rfs_file_system*  fs,
         rc = ENOENT;
     }
   }
-  
+
   rtems_rfs_buffer_handle_close (fs, &buffer);
   rtems_rfs_block_map_close (fs, &map);
   return rc;
@@ -546,7 +546,7 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
             rtems_rfs_inode_ino (dir), offset);
 
   *length = 0;
-  
+
   rc = rtems_rfs_block_map_open (fs, dir, &map);
   if (rc > 0)
     return rc;
@@ -555,7 +555,7 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
         (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
     offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
               rtems_rfs_fs_block_size (fs));
-  
+
   rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
   if (rc > 0)
   {
@@ -564,7 +564,7 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
     rtems_rfs_block_map_close (fs, &map);
     return rc;
   }
-  
+
   rc = rtems_rfs_buffer_handle_open (fs, &buffer);
   if (rc > 0)
   {
@@ -580,9 +580,9 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
   {
     uint8_t*      entry;
     rtems_rfs_ino eino;
-    int           elength;    
+    int           elength;
     int           remaining;
-    
+
     rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
     if (rc > 0)
     {
@@ -593,7 +593,7 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
 
     entry  = rtems_rfs_buffer_data (&buffer);
     entry += map.bpos.boff;
-    
+
     elength = rtems_rfs_dir_entry_length (entry);
     eino    = rtems_rfs_dir_entry_ino (entry);
 
@@ -608,7 +608,7 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
         rc = EIO;
         break;
       }
-        
+
       memset (dirent, 0, sizeof (struct dirent));
       dirent->d_off = offset;
       dirent->d_reclen = sizeof (struct dirent);
@@ -616,19 +616,19 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
       *length += elength;
 
       remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
-      
+
       if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
         *length += remaining;
-      
+
       elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
       if (elength > NAME_MAX)
         elength = NAME_MAX;
-      
+
       memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
 
       dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
       dirent->d_namlen = elength;
-      
+
       if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
         printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
                 dirent->d_off, dirent->d_ino, dirent->d_name);
@@ -636,11 +636,11 @@ rtems_rfs_dir_read (rtems_rfs_file_system*  fs,
     }
 
     *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
-    
+
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
       printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
               offset, *length);
-      
+
     rc = rtems_rfs_block_map_next_block (fs, &map, &block);
     if (rc == ENXIO)
       rc = ENOENT;
@@ -665,7 +665,7 @@ rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,
     printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
 
   empty = true;
-  
+
   rc = rtems_rfs_block_map_open (fs, dir, &map);
   if (rc > 0)
     return rc;
@@ -676,7 +676,7 @@ rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,
     rtems_rfs_block_map_close (fs, &map);
     return rc;
   }
-  
+
   rc = rtems_rfs_buffer_handle_open (fs, &buffer);
   if (rc > 0)
   {
@@ -692,14 +692,14 @@ rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,
   {
     uint8_t* entry;
     int      offset;
-    
+
     rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
     if (rc > 0)
       break;
 
     entry  = rtems_rfs_buffer_data (&buffer);
     offset = 0;
-    
+
     while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
     {
       rtems_rfs_ino eino;
@@ -720,7 +720,7 @@ rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,
         rc = EIO;
         break;
       }
-        
+
       /*
        * Ignore the current (.) and parent (..) entries. Anything else means
        * the directory is not empty.
@@ -753,7 +753,7 @@ rtems_rfs_dir_empty (rtems_rfs_file_system*  fs,
 
   if ((rc == 0) && !empty)
     rc = ENOTEMPTY;
-  
+
   rtems_rfs_buffer_handle_close (fs, &buffer);
   rtems_rfs_block_map_close (fs, &map);
   return rc;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-file-system.c b/cpukit/libfs/src/rfs/rtems-rfs-file-system.c
index 40b3f549e8..58e10f1285 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-file-system.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-file-system.c
@@ -71,9 +71,9 @@ rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
   }
 
   sb = rtems_rfs_buffer_data (&handle);
-  
+
 #define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
-  
+
   if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
@@ -102,7 +102,7 @@ rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
     rtems_rfs_buffer_handle_close (fs, &handle);
     return EIO;
   }
-      
+
   if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
@@ -111,7 +111,7 @@ rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
     rtems_rfs_buffer_handle_close (fs, &handle);
     return EIO;
   }
-      
+
   fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
   fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
   fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
@@ -120,7 +120,7 @@ rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
 
   fs->blocks_per_block =
     rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
-  
+
   fs->block_map_singly_blocks =
     fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
   fs->block_map_doubly_blocks =
@@ -129,7 +129,7 @@ rtems_rfs_fs_read_superblock (rtems_rfs_file_system* fs)
   fs->inodes = fs->group_count * fs->group_inodes;
 
   fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
-  
+
   if (fs->group_blocks >
       rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
   {
@@ -206,10 +206,10 @@ rtems_rfs_fs_open (const char*             name,
   rtems_rfs_inode_handle inode;
   uint16_t               mode;
   int                    rc;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
     printf ("rtems-rfs: open: %s\n", name);
-  
+
   *fs = malloc (sizeof (rtems_rfs_file_system));
   if (!*fs)
   {
@@ -291,7 +291,7 @@ rtems_rfs_fs_open (const char*             name,
       return -1;
     }
   }
-  
+
   rc = rtems_rfs_inode_close (*fs, &inode);
   if (rc > 0)
   {
@@ -302,7 +302,7 @@ rtems_rfs_fs_open (const char*             name,
     errno = rc;
     return -1;
   }
-    
+
   errno = 0;
   return 0;
 }
@@ -311,7 +311,7 @@ int
 rtems_rfs_fs_close (rtems_rfs_file_system* fs)
 {
   int group;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
     printf ("rtems-rfs: close\n");
 
@@ -319,7 +319,7 @@ rtems_rfs_fs_close (rtems_rfs_file_system* fs)
     rtems_rfs_group_close (fs, &fs->groups[group]);
 
   rtems_rfs_buffer_close (fs);
-  
+
   free (fs);
-  return 0;  
+  return 0;
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-file.c b/cpukit/libfs/src/rfs/rtems-rfs-file.c
index 777726a23a..6087f764d6 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-file.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-file.c
@@ -40,7 +40,7 @@ rtems_rfs_file_open (rtems_rfs_file_system*  fs,
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
     printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
-            
+
   *file = NULL;
 
   /*
@@ -63,7 +63,7 @@ rtems_rfs_file_open (rtems_rfs_file_system*  fs,
     free (handle);
     return rc;
   }
-  
+
   /*
    * Scan the file system data list of open files for this ino. If found up
    * the reference count and return the pointer to the data.
@@ -90,7 +90,7 @@ rtems_rfs_file_open (rtems_rfs_file_system*  fs,
     }
 
     memset (shared, 0, sizeof (rtems_rfs_file_shared));
-    
+
     rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
     if (rc > 0)
     {
@@ -134,9 +134,9 @@ rtems_rfs_file_open (rtems_rfs_file_system*  fs,
 
   handle->flags  = flags;
   handle->shared = shared;
-  
+
   *file = handle;
-  
+
   return 0;
 }
 
@@ -148,7 +148,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
   int rc;
 
   rrc = 0;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
     printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
             handle->shared->inode.ino);
@@ -177,7 +177,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
         rtems_rfs_block_map_set_size (&handle->shared->map,
                                       &handle->shared->size);
     }
-    
+
     rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
     if (rc > 0)
     {
@@ -187,7 +187,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
       if (rrc == 0)
         rrc = rc;
     }
-    
+
     rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
     if (rc > 0)
     {
@@ -197,7 +197,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
       if (rrc == 0)
         rrc = rc;
     }
-    
+
     rtems_chain_extract (&handle->shared->link);
     free (handle->shared);
   }
@@ -205,7 +205,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
   rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
   if ((rrc == 0) && (rc > 0))
     rrc = rc;
-  
+
   if (rrc > 0)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
@@ -213,7 +213,7 @@ rtems_rfs_file_close (rtems_rfs_file_system* fs,
   }
 
   free (handle);
-  
+
   return rrc;
 }
 
@@ -223,19 +223,19 @@ rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
                          bool                   read)
 {
   size_t size;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
             read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
-  
+
   if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
   {
     rtems_rfs_buffer_block block;
     bool                   request_read;
     int                    rc;
-     
+
     request_read = read;
-    
+
     rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
                                    rtems_rfs_file_map (handle),
                                    rtems_rfs_file_bpos (handle),
@@ -250,13 +250,13 @@ rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
         *available = 0;
         return 0;
       }
-      
+
       if (rc != ENXIO)
         return rc;
 
       if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
         printf ("rtems-rfs: file-io: start: grow\n");
-      
+
       rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
                                      rtems_rfs_file_map (handle),
                                      1, &block);
@@ -277,31 +277,31 @@ rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
            (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
         request_read = true;
     }
-    
+
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
       printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
               block, request_read ? "yes" : "no");
-    
+
     rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
                                           rtems_rfs_file_buffer (handle),
                                           block, request_read);
     if (rc > 0)
       return rc;
   }
-  
+
   if (read
       && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
       && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
     size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
   else
     size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
-  
+
   *available = size - rtems_rfs_file_block_offset (handle);
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
             *available, size);
-    
+
   return 0;
 }
 
@@ -318,7 +318,7 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     printf ("rtems-rfs: file-io:   end: %s size=%zu\n",
             read ? "read" : "write", size);
-  
+
   if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
   {
     if (!read)
@@ -330,7 +330,7 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
       printf (
         "rtems-rfs: file-io:   end: error on release: %s size=%zu: %d: %s\n",
         read ? "read" : "write", size, rc, strerror (rc));
-      
+
       return rc;
     }
   }
@@ -354,7 +354,7 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
 
   length = false;
   mtime = false;
-  
+
   if (!read &&
       rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
                                     rtems_rfs_file_bpos (handle)))
@@ -364,16 +364,16 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
     length = true;
     mtime = true;
   }
-  
+
   atime  = rtems_rfs_file_update_atime (handle);
   mtime  = rtems_rfs_file_update_mtime (handle) && mtime;
   length = rtems_rfs_file_update_length (handle) && length;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     printf ("rtems-rfs: file-io:   end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
             handle->bpos.bno, handle->bpos.boff,
             atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
-  
+
   if (atime || mtime)
   {
     time_t now = time (NULL);
@@ -389,7 +389,7 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
     handle->shared->size.offset =
       rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
   }
-  
+
   return rc;
 }
 
@@ -410,7 +410,7 @@ rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
 {
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
     printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
-  
+
   /*
    * This call only sets the position if it is in a valid part of the file. The
    * user can request past the end of the file then write to extend the
@@ -425,7 +425,7 @@ rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
   if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
                                             handle->shared))
     rtems_rfs_file_set_bpos (handle, pos);
-  
+
   *new_pos = pos;
   return 0;
 }
@@ -453,7 +453,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
   else
   {
     size = rtems_rfs_file_size (handle);
-  
+
     /*
      * If the file is same size do nothing else grow or shrink it ?
      */
@@ -471,7 +471,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
         count = new_size - size;
         length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
         read_block = false;
-        
+
         while (count)
         {
           rtems_rfs_buffer_block block;
@@ -529,7 +529,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
                                                 rtems_rfs_file_buffer (handle));
           if (rc > 0)
             return rc;
-        
+
           count -= length - bpos.boff;
         }
       }
@@ -540,7 +540,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
          */
         rtems_rfs_block_no blocks;
         uint32_t           offset;
-    
+
         blocks =
           rtems_rfs_block_map_count (map) -
           (((new_size - 1) /
@@ -548,7 +548,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
 
         offset =
           new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
-      
+
         if (blocks)
         {
           int rc;
@@ -574,7 +574,7 @@ rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
 
   if (rtems_rfs_file_update_mtime (handle))
     handle->shared->mtime = time (NULL);
-  
+
   return 0;
 }
 
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-file.h b/cpukit/libfs/src/rfs/rtems-rfs-file.h
index 54a2187df3..284e6273d8 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-file.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-file.h
@@ -55,9 +55,9 @@ typedef struct _rtems_rfs_file_shared
    * map.
    */
   rtems_rfs_block_map map;
-  
+
   /**
-   * The size of the file as taken from the inode. The map's size and 
+   * The size of the file as taken from the inode. The map's size and
    * this size should be the same.
    */
   rtems_rfs_block_size size;
@@ -152,7 +152,7 @@ rtems_rfs_file_shared_get_block_offset (rtems_rfs_file_shared* shared)
  * @oaram shared The shared file data.
  * @return rtems_rfs_pos The data size in bytes.
  */
-static inline rtems_rfs_pos 
+static inline rtems_rfs_pos
 rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
                                 rtems_rfs_file_shared* shared)
 {
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-format.c b/cpukit/libfs/src/rfs/rtems-rfs-format.c
index 77aa02c0cd..b176e17fe8 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-format.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-format.c
@@ -112,11 +112,11 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
 
     if (fs->block_size < 512)
       fs->block_size = 512;
-    
+
     if (fs->block_size > (4 * 1024))
       fs->block_size = (4 * 1024);
   }
-  
+
   if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
   {
     printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
@@ -139,14 +139,14 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
     printf ("group block count is higher than bits in block\n");
     return false;
   }
-  
+
   fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
 
   /*
    * The bits per block sets the upper limit for the number of blocks in a
    * group. The disk will be divided into groups which are the number of bits
    * per block.
-   */  
+   */
   fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
                                             rtems_rfs_bits_per_block (fs));
 
@@ -154,13 +154,13 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
   if (!fs->group_inodes)
   {
     int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
-    
+
     /*
      * The number of inodes per group is set as a percentage.
      */
     if (config->inode_overhead)
       inode_overhead = config->inode_overhead;
-      
+
     fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
   }
 
@@ -171,7 +171,7 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
   fs->group_inodes =
     rtems_rfs_rup_quotient (fs->group_inodes,
                             fs->inodes_per_block) * fs->inodes_per_block;
-  
+
   if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
     fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
 
@@ -180,7 +180,7 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
   {
     fs->max_name_length = 512;
   }
-  
+
   return true;
 }
 
@@ -197,7 +197,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
   int                      blocks;
   int                      b;
   int                      rc;
-  
+
   group_base = rtems_rfs_fs_block (fs, group, 0);
 
   if (group_base > rtems_rfs_fs_blocks (fs))
@@ -234,7 +234,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
 
   if (verbose)
     printf (", blocks");
-  
+
   /*
    * Open the block bitmap using the new buffer.
    */
@@ -253,7 +253,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
    * whole block.
    */
   memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
-  
+
   /*
    * Clear the bitmap.
    */
@@ -266,7 +266,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
             group, rc, strerror (rc));
     return false;
   }
-  
+
   /*
    * Forced allocation of the block bitmap.
    */
@@ -304,7 +304,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
 
   if (verbose)
     printf (", inodes");
-  
+
   /*
    * Open the inode bitmap using the old buffer. Should release any changes.
    */
@@ -323,7 +323,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
    * whole block.
    */
   memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
-  
+
   /*
    * Clear the inode bitmap.
    */
@@ -336,7 +336,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
             " clear all failed: %d: %s\n", group, rc, strerror (rc));
     return false;
   }
-  
+
   /*
    * Close the inode bitmap.
    */
@@ -369,17 +369,17 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
                 rc, strerror (rc));
         return false;
       }
-    
+
       /*
        * Force the whole buffer to a known state. The bit map may not occupy the
        * whole block.
        */
       memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
-  
+
       rtems_rfs_buffer_mark_dirty (&handle);
     }
   }
-  
+
   rc = rtems_rfs_buffer_handle_close (fs, &handle);
   if (rc > 0)
   {
@@ -387,7 +387,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
             rc, strerror (rc));
     return false;
   }
-  
+
   return true;
 }
 
@@ -416,9 +416,9 @@ rtems_rfs_write_superblock (rtems_rfs_file_system* fs)
   }
 
   sb = rtems_rfs_buffer_data (&handle);
-  
+
 #define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
-  
+
   memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
 
   write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
@@ -450,7 +450,7 @@ rtems_rfs_write_superblock (rtems_rfs_file_system* fs)
             rc, strerror (rc));
     return false;
   }
-  
+
   return true;
 }
 
@@ -474,7 +474,7 @@ rtems_rfs_write_root_dir (const char* name)
             errno, strerror (errno));
     return -1;
   }
-  
+
   rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
   if (rc > 0)
   {
@@ -490,7 +490,7 @@ rtems_rfs_write_root_dir (const char* name)
     rtems_rfs_fs_close (fs);
     return rc;
   }
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc > 0)
   {
@@ -508,22 +508,22 @@ rtems_rfs_write_root_dir (const char* name)
   if (rc > 0)
     printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
             rc, strerror (rc));
-  
+
   rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
   if (rc > 0)
     printf ("rtems-rfs: format: directory add failed: %d: %s\n",
             rc, strerror (rc));
-  
+
   rc = rtems_rfs_inode_close (fs, &inode);
   if (rc > 0)
     printf ("rtems-rfs: format: inode close failed: %d: %s\n",
             rc, strerror (rc));
-  
+
   rc = rtems_rfs_fs_close (fs);
   if (rc < 0)
     printf ("rtems-rfs: format: file system close failed: %d: %s\n",
             errno, strerror (errno));
-  
+
   return rc;
 }
 
@@ -536,7 +536,7 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
 
   if (config->verbose)
     printf ("rtems-rfs: format: %s\n", name);
-  
+
   memset (&fs, 0, sizeof (rtems_rfs_file_system));
 
   rtems_chain_initialize_empty (&fs.buffers);
@@ -550,7 +550,7 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
   fs.release_modified_count = 0;
 
   fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
-  
+
   /*
    * Open the buffer interface.
    */
@@ -571,7 +571,7 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
             rtems_rfs_fs_media_block_size (&fs));
     return -1;
   }
-  
+
   /*
    * Check the configuration data.
    */
@@ -611,7 +611,7 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
             rc, strerror (rc));
     return -1;
   }
-  
+
   if (!rtems_rfs_write_superblock (&fs))
   {
     printf ("rtems-rfs: format: superblock write failed\n");
@@ -625,7 +625,7 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
 
   if (config->verbose)
     printf ("\n");
-  
+
   rc = rtems_rfs_buffer_close (&fs);
   if (rc > 0)
   {
@@ -641,6 +641,6 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
             rc, strerror (rc));
     return -1;
   }
-  
+
   return 0;
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-group.c b/cpukit/libfs/src/rfs/rtems-rfs-group.c
index a6c2fce1ba..3fefb62b8c 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-group.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-group.c
@@ -35,7 +35,7 @@ rtems_rfs_group_open (rtems_rfs_file_system* fs,
                       rtems_rfs_group*       group)
 {
   int rc;
-  
+
   if (base >= rtems_rfs_fs_blocks (fs))
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
@@ -55,15 +55,15 @@ rtems_rfs_group_open (rtems_rfs_file_system* fs,
    */
   if (inodes > size)
     inodes = size;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
     printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
             base, size, inodes);
 
   group->base = base;
   group->size = size;
-  
-  rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);  
+
+  rc = rtems_rfs_buffer_handle_open (fs, &group->block_bitmap_buffer);
   if (rc > 0)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
@@ -114,7 +114,7 @@ rtems_rfs_group_open (rtems_rfs_file_system* fs,
     rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
     rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
   }
-  
+
   return 0;
 }
 
@@ -144,7 +144,7 @@ rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
   rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
   if (rc > 0)
     result = rc;
-  
+
   return result;
 }
 
@@ -168,13 +168,13 @@ rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
   }
   else
     size = fs->group_blocks;
-    
+
   group_start = goal / size;
   bit = (rtems_rfs_bitmap_bit) (goal % size);
   offset = 0;
   updown = true;
   direction = 1;
-      
+
   /*
    * Try the goal group first and if that group fails try the groups either
    * side until the whole file system has be tried.
@@ -193,7 +193,7 @@ rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
     group = group_start + (direction * offset);
     if (offset)
       bit = direction > 0 ? 0 : size - 1;
-    
+
     /*
      * If we are still looking up and down and if the group is out of range we
      * have reached one end. Stopping looking up and down and just move in the
@@ -212,14 +212,14 @@ rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
       bitmap = &fs->groups[group].inode_bitmap;
     else
       bitmap = &fs->groups[group].block_bitmap;
-    
+
     rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
     if (rc > 0)
       return rc;
-    
+
     if (rtems_rfs_fs_release_bitmaps (fs))
       rtems_rfs_bitmap_release_buffer (fs, bitmap);
-      
+
     if (allocated)
     {
       if (inode)
@@ -237,7 +237,7 @@ rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
 
     offset++;
   }
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
     printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
 
@@ -263,25 +263,25 @@ rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
   {
     no -= RTEMS_RFS_ROOT_INO;
     size = fs->group_inodes;
-  }    
+  }
   else
   {
     no -= RTEMS_RFS_SUPERBLOCK_SIZE;
     size = fs->group_blocks;
   }
-  
+
   group = no / size;
   bit = (rtems_rfs_bitmap_bit) (no % size);
-  
+
   if (inode)
     bitmap = &fs->groups[group].inode_bitmap;
   else
     bitmap = &fs->groups[group].block_bitmap;
 
   rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
-  
+
   rtems_rfs_bitmap_release_buffer (fs, bitmap);
-  
+
   return rc;
 }
 
@@ -307,26 +307,26 @@ rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
         return EINVAL;
     no -= RTEMS_RFS_ROOT_INO;
     size = fs->group_inodes;
-  }    
+  }
   else
   {
     if (no >= rtems_rfs_fs_blocks (fs))
         return EINVAL;
     size = fs->group_blocks;
   }
-  
+
   group = no / size;
   bit = (rtems_rfs_bitmap_bit) (no % size);
-  
+
   if (inode)
     bitmap = &fs->groups[group].inode_bitmap;
   else
     bitmap = &fs->groups[group].block_bitmap;
 
   rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
-  
+
   rtems_rfs_bitmap_release_buffer (fs, bitmap);
-  
+
   return rc;
 }
 
@@ -336,10 +336,10 @@ rtems_rfs_group_usage (rtems_rfs_file_system* fs,
                        size_t*                inodes)
 {
   int g;
-  
+
   *blocks = 0;
   *inodes = 0;
-  
+
   for (g = 0; g < fs->group_count; g++)
   {
     rtems_rfs_group* group = &fs->groups[g];
@@ -355,7 +355,7 @@ rtems_rfs_group_usage (rtems_rfs_file_system* fs,
     *blocks = rtems_rfs_fs_blocks (fs);
   if (*inodes > rtems_rfs_fs_inodes (fs))
     *inodes = rtems_rfs_fs_inodes (fs);
-  
+
   return 0;
 }
 
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-group.h b/cpukit/libfs/src/rfs/rtems-rfs-group.h
index 1ec0107f89..9cf1f65925 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-group.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-group.h
@@ -37,7 +37,7 @@
  * bit allocator for blocks in the group simpler plus is allows a simple way to
  * localise access to files and directories.
  */
-typedef struct _rtems_rfs_group 
+typedef struct _rtems_rfs_group
 {
   /**
    * Base block number.
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-inode.c b/cpukit/libfs/src/rfs/rtems-rfs-inode.c
index ab3f4b7e65..cb66746324 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-inode.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-inode.c
@@ -60,20 +60,20 @@ rtems_rfs_inode_open (rtems_rfs_file_system*  fs,
   int gino;
   int index;
   int rc;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
     printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
 
   if (ino == RTEMS_RFS_EMPTY_INO)
     return EINVAL;
-  
+
   if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
     return EINVAL;
-  
+
   handle->ino = ino;
   handle->node = NULL;
   handle->loads = 0;
-  
+
   gino  = ino - RTEMS_RFS_ROOT_INO;
   group = gino / fs->group_inodes;
   gino  = gino % fs->group_inodes;
@@ -106,7 +106,7 @@ rtems_rfs_inode_close (rtems_rfs_file_system*  fs,
               handle->loads);
     rc = EIO;
   }
-  
+
   handle->ino = 0;
   return rc;
 }
@@ -127,7 +127,7 @@ rtems_rfs_inode_load (rtems_rfs_file_system*  fs,
   if (!rtems_rfs_inode_is_loaded (handle))
   {
     int rc;
-    
+
     rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
                                           handle->block, true);
     if (rc > 0)
@@ -138,7 +138,7 @@ rtems_rfs_inode_load (rtems_rfs_file_system*  fs,
   }
 
   handle->loads++;
-  
+
   return 0;
 }
 
@@ -148,19 +148,19 @@ rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,
                         bool                    update_ctime)
 {
   int rc = 0;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
     printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
             handle->ino, handle->loads,
             rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
-  
+
   if (rtems_rfs_inode_is_loaded (handle))
   {
     if (handle->loads == 0)
       return EIO;
 
     handle->loads--;
-    
+
     if (handle->loads == 0)
     {
       /*
@@ -172,7 +172,7 @@ rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,
       handle->node = NULL;
     }
   }
-  
+
   return rc;
 }
 
@@ -190,7 +190,7 @@ rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
   rtems_rfs_inode_handle parent_inode;
   rtems_rfs_inode_handle inode;
   int                    rc;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
   {
     const char* type = "unknown";
@@ -225,7 +225,7 @@ rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
     default:
       return EINVAL;
   }
-  
+
   rc = rtems_rfs_inode_alloc (fs, parent, ino);
   if (rc > 0)
     return rc;
@@ -236,7 +236,7 @@ rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
     rtems_rfs_inode_free (fs, *ino);
     return rc;
   }
-  
+
   rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
   if (rc > 0)
   {
@@ -287,7 +287,7 @@ rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
   if (RTEMS_RFS_S_ISDIR (mode))
     rtems_rfs_inode_set_links (&parent_inode,
                                rtems_rfs_inode_get_links (&parent_inode) + 1);
-  
+
   rc = rtems_rfs_inode_close (fs, &parent_inode);
   if (rc > 0)
   {
@@ -302,7 +302,7 @@ rtems_rfs_inode_create (rtems_rfs_file_system*  fs,
     rtems_rfs_inode_free (fs, *ino);
     return rc;
   }
-  
+
   return 0;
 }
 
@@ -311,7 +311,7 @@ rtems_rfs_inode_delete (rtems_rfs_file_system*  fs,
                         rtems_rfs_inode_handle* handle)
 {
   int rc = 0;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
     printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
            rtems_rfs_inode_ino (handle),
@@ -327,7 +327,7 @@ rtems_rfs_inode_delete (rtems_rfs_file_system*  fs,
     rc = rtems_rfs_inode_free (fs, handle->ino);
     if (rc > 0)
       return rc;
-    
+
     /*
      * Free the blocks the inode may have attached.
      */
@@ -377,7 +377,7 @@ rtems_rfs_inode_initialise (rtems_rfs_inode_handle* handle,
 
 int
 rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
-                                bool                    atime, 
+                                bool                    atime,
                                 bool                    mtime)
 {
   time_t now;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-inode.h b/cpukit/libfs/src/rfs/rtems-rfs-inode.h
index 5ac2868859..8c88b055dd 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-inode.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-inode.h
@@ -581,7 +581,7 @@ int rtems_rfs_inode_free (rtems_rfs_file_system* fs,
  * @param load If true load the inode into memory from the media.
  * @return int The error number (errno). No error if 0.
  */
-int rtems_rfs_inode_open (rtems_rfs_file_system*  fs, 
+int rtems_rfs_inode_open (rtems_rfs_file_system*  fs,
                           rtems_rfs_ino           ino,
                           rtems_rfs_inode_handle* handle,
                           bool                    load);
@@ -675,7 +675,7 @@ int rtems_rfs_inode_initialise (rtems_rfs_inode_handle* handle,
  *             loaded.
  */
 int rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
-                                    bool                    atime, 
+                                    bool                    atime,
                                     bool                    mtime);
 
 /**
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-link.c b/cpukit/libfs/src/rfs/rtems-rfs-link.c
index 27a08153b9..392a7520d6 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-link.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-link.c
@@ -67,7 +67,7 @@ rtems_rfs_link (rtems_rfs_file_system* fs,
     rtems_rfs_inode_close (fs, &target_inode);
     return ENOTSUP;
   }
-  
+
   rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
   if (rc)
   {
@@ -82,7 +82,7 @@ rtems_rfs_link (rtems_rfs_file_system* fs,
     rtems_rfs_inode_close (fs, &target_inode);
     return rc;
   }
-  
+
   links = rtems_rfs_inode_get_links (&target_inode) + 1;
   rtems_rfs_inode_set_links (&target_inode, links);
 
@@ -125,12 +125,12 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
   rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
   if (rc)
     return rc;
-  
+
   /*
    * If a directory process the unlink mode.
    */
-  
-  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));  
+
+  dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
   if (dir)
   {
     switch (dir_mode)
@@ -156,7 +156,7 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
         break;
     }
   }
-  
+
   rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
   if (rc)
   {
@@ -166,7 +166,7 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
     rtems_rfs_inode_close (fs, &target_inode);
     return rc;
   }
-  
+
   rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
   if (rc > 0)
   {
@@ -177,7 +177,7 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
     rtems_rfs_inode_close (fs, &target_inode);
     return rc;
   }
-  
+
   links = rtems_rfs_inode_get_links (&target_inode);
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
@@ -212,7 +212,7 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
       rtems_rfs_inode_set_links (&parent_inode, links);
     }
   }
-  
+
   rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
   if (rc > 0)
   {
@@ -239,7 +239,7 @@ rtems_rfs_unlink (rtems_rfs_file_system* fs,
   if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
     printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
             rc, strerror (rc));
-  
+
   return rc;
 }
 
@@ -256,7 +256,7 @@ rtems_rfs_symlink (rtems_rfs_file_system* fs,
   rtems_rfs_inode_handle inode;
   rtems_rfs_ino          ino;
   int                    rc;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
   {
     int c;
@@ -270,13 +270,13 @@ rtems_rfs_symlink (rtems_rfs_file_system* fs,
 
   if (link_length >= rtems_rfs_fs_block_size (fs))
     return ENAMETOOLONG;
-  
+
   rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
                                RTEMS_RFS_S_SYMLINK,
                                1, uid, gid, &ino);
   if (rc > 0)
     return rc;
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc > 0)
     return rc;
@@ -298,7 +298,7 @@ rtems_rfs_symlink (rtems_rfs_file_system* fs,
     rtems_rfs_block_no      block;
     rtems_rfs_buffer_handle buffer;
     uint8_t*                data;
-    
+
     rc = rtems_rfs_block_map_open (fs, &inode, &map);
     if (rc > 0)
     {
@@ -331,7 +331,7 @@ rtems_rfs_symlink (rtems_rfs_file_system* fs,
     }
 
     data = rtems_rfs_buffer_data (&buffer);
-    
+
     memset (data, 0xff, rtems_rfs_fs_block_size (fs));
     memcpy (data, link, link_length);
 
@@ -350,11 +350,11 @@ rtems_rfs_symlink (rtems_rfs_file_system* fs,
       return rc;
     }
   }
-  
+
   rtems_rfs_inode_set_block_offset (&inode, link_length);
 
   rc = rtems_rfs_inode_close (fs, &inode);
-  
+
   return rc;
 }
 
@@ -367,7 +367,7 @@ rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
 {
   rtems_rfs_inode_handle inode;
   int                    rc;
-  
+
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
     printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
 
@@ -382,13 +382,13 @@ rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
   }
 
   *length = rtems_rfs_inode_get_block_offset (&inode);
-  
+
   if (size < *length)
   {
     rtems_rfs_inode_close (fs, &inode);
     return EINVAL;
   }
-      
+
   if (rtems_rfs_inode_get_block_count (&inode) == 0)
   {
     memcpy (path, inode.node->data.name, *length);
@@ -399,7 +399,7 @@ rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
     rtems_rfs_block_no      block;
     rtems_rfs_buffer_handle buffer;
     char*                   data;
-    
+
     rc = rtems_rfs_block_map_open (fs, &inode, &map);
     if (rc > 0)
     {
@@ -453,6 +453,6 @@ rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
   path[*length] = '\0';
 
   rc = rtems_rfs_inode_close (fs, &inode);
-  
+
   return rc;
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-mutex.c b/cpukit/libfs/src/rfs/rtems-rfs-mutex.c
index 90a865fb76..04d700a916 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-mutex.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-mutex.c
@@ -46,7 +46,7 @@ rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
   if (sc != RTEMS_SUCCESSFUL)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
-      printf ("rtems-rfs: mutex: open failed: %s\n", 
+      printf ("rtems-rfs: mutex: open failed: %s\n",
               rtems_status_text (sc));
     return EIO;
   }
@@ -63,7 +63,7 @@ rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
   if (sc != RTEMS_SUCCESSFUL)
   {
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
-      printf ("rtems-rfs: mutex: close failed: %s\n", 
+      printf ("rtems-rfs: mutex: close failed: %s\n",
               rtems_status_text (sc));
     return EIO;
   }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-mutex.h b/cpukit/libfs/src/rfs/rtems-rfs-mutex.h
index 12e7fee921..fff4969fd2 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-mutex.h
+++ b/cpukit/libfs/src/rfs/rtems-rfs-mutex.h
@@ -71,7 +71,7 @@ rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
   {
 #if RTEMS_RFS_TRACE
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
-      printf ("rtems-rfs: mutex: obtain failed: %s\n", 
+      printf ("rtems-rfs: mutex: obtain failed: %s\n",
               rtems_status_text (sc));
 #endif
     return EIO;
@@ -96,7 +96,7 @@ rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
   {
 #if RTEMS_RFS_TRACE
     if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
-      printf ("rtems-rfs: mutex: release failed: %s\n", 
+      printf ("rtems-rfs: mutex: release failed: %s\n",
               rtems_status_text (sc));
 #endif
     return EIO;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c
index 5693bad1bc..8e60113f23 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c
@@ -53,9 +53,9 @@ rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
   int                           minor;
   rtems_status_code             status;
   int                           rc;
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc > 0)
   {
@@ -74,10 +74,10 @@ rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
   }
 
   rtems_rfs_rtems_unlock (fs);
-  
+
   iop->data0 = major;
   iop->data1 = (void*)((intptr_t) minor);
-  
+
   args.iop   = iop;
   args.flags = iop->flags;
   args.mode  = mode;
@@ -154,7 +154,7 @@ rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
  * @param iop
  * @param buffer
  * @param count
- * @return ssize_t 
+ * @return ssize_t
  */
 
 static ssize_t
@@ -224,10 +224,10 @@ rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
  * @param iop
  * @param offset
  * @param whence
- * @return off_t        
+ * @return off_t
  */
 
-static off_t        
+static off_t
 rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
                               off_t          offset,
                               int            whence)
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c
index 7b7c7d88f2..76b914526a 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c
@@ -55,21 +55,21 @@ rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
   int                    rc;
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc)
   {
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
   }
-  
+
   if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
   {
     rtems_rfs_inode_close (fs, &inode);
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
   }
-    
+
   iop->offset = 0;
 
   rtems_rfs_inode_close (fs, &inode);
@@ -120,9 +120,9 @@ rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
 
   count  = count / sizeof (struct dirent);
   dirent = buffer;
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc)
   {
@@ -131,7 +131,7 @@ rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
   }
 
   bytes_transferred = 0;
-  
+
   for (d = 0; d < count; d++, dirent++)
   {
     size_t size;
@@ -152,7 +152,7 @@ rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
 
   rtems_rfs_inode_close (fs, &inode);
   rtems_rfs_rtems_unlock (fs);
-  
+
   return bytes_transferred;
 }
 
@@ -171,9 +171,9 @@ rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
  * @param iop
  * @param offset
  * @param whence
- * return off_t        
+ * return off_t
  */
-static off_t        
+static off_t
 rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
                            off_t          offset,
                            int            whence)
@@ -211,7 +211,7 @@ rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
     return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
   if (rc)
   {
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
index 9f2957b0ee..9e477b5841 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
@@ -65,9 +65,9 @@ rtems_rfs_rtems_file_open (rtems_libio_t* iop,
            pathname, ino, flags, mode);
 
   rtems_rfs_rtems_lock (fs);
-  
+
   ino = rtems_rfs_rtems_get_iop_ino (iop);
-  
+
   rc = rtems_rfs_file_open (fs, ino, flags, &file);
   if (rc > 0)
   {
@@ -77,10 +77,10 @@ rtems_rfs_rtems_file_open (rtems_libio_t* iop,
 
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
     printf("rtems-rfs: file-open: handle:%p\n", file);
-  
+
   iop->size = rtems_rfs_file_size (file);
   rtems_rfs_rtems_set_iop_file_handle (iop, file);
-  
+
   rtems_rfs_rtems_unlock (fs);
   return 0;
 }
@@ -103,11 +103,11 @@ rtems_rfs_rtems_file_close (rtems_libio_t* iop)
     printf("rtems-rfs: file-close: handle:%p\n", file);
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_file_close (fs, file);
   if (rc > 0)
     rc = rtems_rfs_rtems_error ("file-close: file close", rc);
-  
+
   rtems_rfs_rtems_unlock (fs);
   return rc;
 }
@@ -137,7 +137,7 @@ rtems_rfs_rtems_file_read (rtems_libio_t* iop,
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
 
   pos = iop->offset;
-  
+
   if (pos < rtems_rfs_file_size (file))
   {
     while (count)
@@ -153,10 +153,10 @@ rtems_rfs_rtems_file_read (rtems_libio_t* iop,
 
       if (size == 0)
         break;
-    
+
       if (size > count)
         size = count;
-    
+
       memcpy (data, rtems_rfs_file_data (file), size);
 
       data  += size;
@@ -171,9 +171,9 @@ rtems_rfs_rtems_file_read (rtems_libio_t* iop,
       }
     }
   }
-  
+
   rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
-  
+
   return read;
 }
 
@@ -202,7 +202,7 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
 
   pos = iop->offset;
-  
+
   /*
    * If the iop position is past the physical end of the file we need to set
    * the file size to the new length before writing. If the position equals the
@@ -210,7 +210,7 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
    * from 0. For a specific position we need a file that has a length of one
    * more.
    */
-  
+
   if (pos >= rtems_rfs_file_size (file))
   {
     rc = rtems_rfs_file_set_size (file, pos + 1);
@@ -220,20 +220,20 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
       return rtems_rfs_rtems_error ("file-write: write extend", rc);
     }
   }
-  
+
   rtems_rfs_file_set_bpos (file, pos);
-  
+
   while (count)
   {
     size_t size = count;
-    
+
     rc = rtems_rfs_file_io_start (file, &size, false);
     if (rc)
     {
       write = rtems_rfs_rtems_error ("file-write: write open", rc);
       break;
     }
-    
+
     if (size > count)
       size = count;
 
@@ -242,7 +242,7 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
     data  += size;
     count -= size;
     write  += size;
-    
+
     rc = rtems_rfs_file_io_end (file, size, false);
     if (rc)
     {
@@ -250,11 +250,11 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
       break;
     }
   }
-  
+
   iop->size = rtems_rfs_file_size (file);
-  
+
   rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
-  
+
   return write;
 }
 
@@ -280,9 +280,9 @@ rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
  * @param iop
  * @param offset
  * @param whence
- * @return off_t        
+ * @return off_t
  */
-static off_t        
+static off_t
 rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
                             off_t          offset,
                             int            whence)
@@ -295,18 +295,18 @@ rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
     printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
 
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
-  
+
   pos = iop->offset;
-  
+
   rc = rtems_rfs_file_seek (file, pos, &pos);
   if (rc)
   {
     rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
     return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
-  
+
   return iop->offset;
 }
 
@@ -326,15 +326,15 @@ rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
 
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
     printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
-  
+
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
-  
+
   rc = rtems_rfs_file_set_size (file, length);
   if (rc)
     rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
 
   iop->size = rtems_rfs_file_size (file);
-  
+
   rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
 
   return rc;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c
index 2c8ba591f2..44c8885bbe 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c
@@ -38,7 +38,7 @@ rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
   uid = rtems_rfs_inode_get_uid (inode);
   gid = rtems_rfs_inode_get_gid (inode);
   mode = rtems_rfs_inode_get_mode (inode);
-  
+
 #if defined (RTEMS_POSIX_API)
   st_uid = geteuid ();
   st_gid = getegid ();
@@ -46,7 +46,7 @@ rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
   st_uid = uid;
   st_gid = gid;
 #endif
-  
+
   /*
    * Check if I am owner or a group member or someone else.
    */
@@ -65,7 +65,7 @@ rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
             st_uid, st_gid, uid, gid,
             flags, flags_to_test, mode & 0777,
             flags_to_test & (mode & 0777));
-  
+
   /*
    * If all of the flags are set we have permission
    * to do this.
@@ -166,7 +166,7 @@ rtems_rfs_rtems_trace_shell_command (int argc, char *argv[])
 {
   const char* table[] =
   {
-    "error-msgs",   
+    "error-msgs",
     "eval-path"
     "eval-for-make",
     "eval-perms",
@@ -190,7 +190,7 @@ rtems_rfs_rtems_trace_shell_command (int argc, char *argv[])
   bool set = true;
   int  arg;
   int  t;
-  
+
   for (arg = 1; arg < argc; arg++)
   {
     if (argv[arg][0] == '-')
@@ -230,7 +230,7 @@ rtems_rfs_rtems_trace_shell_command (int argc, char *argv[])
           }
         }
       }
-      
+
       if (set)
         rtems_rfs_rtems_trace_mask |= value;
       else
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems.c
index 41413839a7..f257c7178f 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems.c
@@ -83,7 +83,7 @@ rtems_rfs_rtems_eval_path (const char*                       path,
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
     printf ("rtems-rfs-rtems: eval-path: in: path:%s pathlen:%zi ino:%" PRId32 "\n",
             path, pathlen, ino);
-  
+
   /*
    * Eat any separators at the start of the path.
    */
@@ -92,7 +92,7 @@ rtems_rfs_rtems_eval_path (const char*                       path,
   pathlen -= stripped;
 
   rtems_rfs_rtems_lock (fs);
-  
+
   while (true)
   {
     /*
@@ -104,7 +104,7 @@ rtems_rfs_rtems_eval_path (const char*                       path,
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
     }
-    
+
     /*
      * Is this the end of the pathname we were given ?
      */
@@ -121,7 +121,7 @@ rtems_rfs_rtems_eval_path (const char*                       path,
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
     }
-    
+
     /*
      * Extract the node name we will look for this time around.
      */
@@ -210,7 +210,7 @@ rtems_rfs_rtems_eval_path (const char*                       path,
         rtems_rfs_inode_close (fs, &inode);
         rtems_rfs_rtems_unlock (fs);
         return ((errno = rc) == 0) ? 0 : -1;
-      }    
+      }
       if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
         printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
     }
@@ -221,14 +221,14 @@ rtems_rfs_rtems_eval_path (const char*                       path,
       rtems_rfs_inode_close (fs, &inode);
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_path: closing node", rc);
-    }    
+    }
   }
-  
+
   rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
   rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
 
   rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
-  
+
   rtems_rfs_inode_close (fs, &inode);
   rtems_rfs_rtems_unlock (fs);
 
@@ -266,7 +266,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
 
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
     printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
-  
+
   *name = path + strlen (path);
 
   while (*name != path)
@@ -278,7 +278,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
       break;
     }
   }
-      
+
   /*
    * Eat any separators at start of the path.
    */
@@ -286,7 +286,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
   path += stripped;
 
   rtems_rfs_rtems_lock (fs);
-  
+
   while (true)
   {
     /*
@@ -298,7 +298,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
     }
-  
+
     /*
      * If a directory the execute bit must be set for us to enter.
      */
@@ -309,13 +309,13 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
     }
-    
+
     /*
      * Is this the end of the pathname we were given ?
      */
     if (path == *name)
       break;
-    
+
     /*
      * Extract the node name we will look for this time around.
      */
@@ -349,7 +349,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
       }
       break;
     }
-     
+
     /*
      * If the node is a parent we must move up one directory. If the location
      * is on another file system we have a crossmount so we call that file
@@ -383,7 +383,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
         rtems_rfs_rtems_unlock (fs);
         return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
       }
-      
+
       /*
        * We need to find the parent of this node.
        */
@@ -422,7 +422,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
     {
       rtems_rfs_rtems_unlock (fs);
       return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
-    }    
+    }
   }
 
   if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
@@ -438,7 +438,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("eval_for_make: cannot write", EACCES);
   }
-  
+
   /*
    * Make sure the name does not already exists in the directory.
    */
@@ -457,7 +457,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
   }
-  
+
   /*
    * Set the parent ino in the path location.
    */
@@ -473,7 +473,7 @@ rtems_rfs_rtems_eval_for_make (const char*                       path,
 
   rtems_rfs_inode_close (fs, &inode);
   rtems_rfs_rtems_unlock (fs);
-  
+
   return rc;
 }
 
@@ -499,9 +499,9 @@ rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
     printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
             parent, target);
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
   if (rc)
   {
@@ -510,7 +510,7 @@ rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
 	}
 
   rtems_rfs_rtems_unlock (fs);
-  
+
 	return 0;
 }
 
@@ -533,20 +533,20 @@ rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
   int                    rc;
 
   rtems_rfs_rtems_lock (fs);
-  
+
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
     printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
            parent, doff, ino);
-  
+
   rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
   if (rc)
   {
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -576,7 +576,7 @@ rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("node_type: opening inode", rc);
   }
-  
+
   /*
    * Do not return RTEMS_FILESYSTEM_HARD_LINK because this would result in an
    * eval link which does not make sense in the case of the RFS file
@@ -601,9 +601,9 @@ rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("node_type: closing inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
-  
+
   return type;
 }
 
@@ -629,20 +629,20 @@ rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
   uid_t                  uid;
 #endif
   int                    rc;
-  
+
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
     printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
             ino, owner, group);
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc > 0)
   {
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("chown: opening inode", rc);
   }
-  
+
   /*
    *  Verify I am the owner of the node or the super user.
    */
@@ -668,7 +668,7 @@ rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
   }
 
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -693,7 +693,7 @@ rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
   int                    rc;
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc)
   {
@@ -710,9 +710,9 @@ rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("utime: closing inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -746,7 +746,7 @@ rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
 #endif
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
                           link_name, strlen (link_name),
                           uid, gid, parent);
@@ -755,9 +755,9 @@ rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("symlink: linking", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -779,12 +779,12 @@ rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
   rtems_rfs_ino           ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
   size_t                  length;
   int                     rc;
-  
+
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
     printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
   if (rc)
   {
@@ -813,9 +813,9 @@ rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
     printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
             ino, mode);
-  
+
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc)
   {
@@ -824,7 +824,7 @@ rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
   }
 
   imode = rtems_rfs_inode_get_mode (&inode);
-  
+
   /*
    *  Verify I am the owner of the node or the super user.
    */
@@ -843,16 +843,16 @@ rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
   imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
 
   rtems_rfs_inode_set_mode (&inode, imode);
-  
+
   rc = rtems_rfs_inode_close (fs, &inode);
   if (rc > 0)
   {
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -871,7 +871,7 @@ rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
     printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_open (fs, ino, &inode, true);
   if (rc)
   {
@@ -880,14 +880,14 @@ rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
   }
 
   mode = rtems_rfs_inode_get_mode (&inode);
-  
+
   if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
   {
-    buf->st_rdev = 
+    buf->st_rdev =
       rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
                                    rtems_rfs_inode_get_block (&inode, 1));
   }
-  
+
   buf->st_dev     = rtems_rfs_fs_device (fs);
   buf->st_ino     = rtems_rfs_inode_ino (&inode);
   buf->st_mode    = rtems_rfs_rtems_mode (mode);
@@ -925,16 +925,16 @@ rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
     else
       buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
   }
-  
+
   buf->st_blksize = rtems_rfs_fs_block_size (fs);
-  
+
   rc = rtems_rfs_inode_close (fs, &inode);
   if (rc > 0)
   {
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("stat: closing inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
   return 0;
 }
@@ -972,7 +972,7 @@ rtems_rfs_rtems_mknod (const char                       *name,
 #endif
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
                                rtems_rfs_rtems_imode (mode),
                                1, uid, gid, &ino);
@@ -988,7 +988,7 @@ rtems_rfs_rtems_mknod (const char                       *name,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("mknod: inode open", rc);
   }
-    
+
   if (S_ISDIR(mode) || S_ISREG(mode))
   {
   }
@@ -1000,7 +1000,7 @@ rtems_rfs_rtems_mknod (const char                       *name,
     rtems_rfs_inode_set_block (&inode, 0, major);
     rtems_rfs_inode_set_block (&inode, 1, minor);
   }
-  else 
+  else
   {
     rtems_rfs_inode_close (fs, &inode);
     rtems_rfs_rtems_unlock (fs);
@@ -1013,7 +1013,7 @@ rtems_rfs_rtems_mknod (const char                       *name,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("mknod: closing inode", rc);
   }
-  
+
   rtems_rfs_rtems_unlock (fs);
   return 0;
 }
@@ -1023,7 +1023,7 @@ rtems_rfs_rtems_mknod (const char                       *name,
  *
  * @param parent_pathloc
  * @param pathloc
- * @return int 
+ * @return int
  */
 int
 rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
@@ -1040,7 +1040,7 @@ rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
             parent, doff, ino);
 
   rtems_rfs_rtems_lock (fs);
-  
+
   rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
   if (rc)
   {
@@ -1057,13 +1057,13 @@ rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
  * everything related to this device.
  *
  * @param iop
- * @return int 
+ * @return int
  */
 int
 rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
 {
   int rc;
-  
+
   rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
   if (rc)
     return rtems_rfs_rtems_error ("fdatasync: sync", rc);
@@ -1078,7 +1078,7 @@ rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
  * @param old_loc The old name's location.
  * @param new_parent_loc The new name's parent location.
  * @param new_name The new name.
- * @return int 
+ * @return int
  */
 static int
 rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
@@ -1092,7 +1092,7 @@ rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
   rtems_rfs_ino           ino;
   uint32_t                doff;
   int                     rc;
-  
+
   old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
   new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
 
@@ -1115,7 +1115,7 @@ rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
     rtems_rfs_rtems_unlock (fs);
     return rtems_rfs_rtems_error ("rename: linking", rc);
   }
-  
+
   /*
    * Unlink all inodes even directories with the dir option as false because a
    * directory may not be empty.
@@ -1149,7 +1149,7 @@ rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
   size_t                 inodes;
 
   rtems_rfs_group_usage (fs, &blocks, &inodes);
-  
+
   sb->f_bsize   = rtems_rfs_fs_block_size (fs);
   sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);
   sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);
@@ -1161,7 +1161,7 @@ rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
   sb->f_fsid    = RTEMS_RFS_SB_MAGIC;
   sb->f_flag    = rtems_rfs_fs_flags (fs);
   sb->f_namemax = rtems_rfs_fs_max_name (fs);
-  
+
   return 0;
 }
 
@@ -1262,13 +1262,13 @@ rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
         options = NULL;
     }
   }
-  
+
   rtems = malloc (sizeof (rtems_rfs_rtems_private));
   if (!rtems)
     return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
 
   memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
-  
+
   rc = rtems_rfs_mutex_create (&rtems->access);
   if (rc > 0)
   {
@@ -1283,14 +1283,14 @@ rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
     free (rtems);
     return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
   }
-  
+
   rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
   if (rc)
   {
     free (rtems);
     return rtems_rfs_rtems_error ("initialise: open", rc);
   }
-  
+
   mt_entry->fs_info = fs;
 
   mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
@@ -1298,7 +1298,7 @@ rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
   mt_entry->mt_fs_root.ops         = &rtems_rfs_ops;
 
   rtems_rfs_rtems_unlock (fs);
-  
+
   return 0;
 }
 
@@ -1313,11 +1313,11 @@ rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
   int                      rc;
 
   rtems = rtems_rfs_fs_user (fs);
-  
+
   rc = rtems_rfs_fs_close(fs);
-  
+
   rtems_rfs_mutex_destroy (&rtems->access);
   free (rtems);
-  
+
   return rtems_rfs_rtems_error ("shutdown: close", rc);
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-shell.c b/cpukit/libfs/src/rfs/rtems-rfs-shell.c
index 63931752cf..6969f1c588 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-shell.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-shell.c
@@ -58,7 +58,7 @@ rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
 {
 #if __rtems__
   rtems_rfs_rtems_lock (fs);
-#endif  
+#endif
 }
 
 /**
@@ -69,7 +69,7 @@ rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
 {
 #if __rtems__
   rtems_rfs_rtems_unlock (fs);
-#endif  
+#endif
 }
 
 /**
@@ -108,7 +108,7 @@ rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
     rtems_filesystem_freenode (&pathloc);
   }
 #endif
-  
+
   return rc;
 }
 
@@ -145,17 +145,17 @@ rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
   rtems_rfs_shell_lock_rfs (fs);
 
   rtems_rfs_group_usage (fs, &blocks, &inodes);
-  
+
   rtems_rfs_shell_unlock_rfs (fs);
 
   bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
   ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
-  
+
   printf ("       blocks used: %zd (%d.%d%%)\n",
           blocks, bpcent / 10, bpcent % 10);
   printf ("       inodes used: %zd (%d.%d%%)\n",
           inodes, ipcent / 10, ipcent % 10);
-  
+
   return 0;
 }
 
@@ -168,7 +168,7 @@ rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
   bool                    state;
   int                     b;
   int                     rc;
-  
+
   if (argc <= 1)
   {
     printf ("error: no block number provided\n");
@@ -178,7 +178,7 @@ rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
   block = strtoul (argv[1], 0, 0);
 
   rtems_rfs_shell_lock_rfs (fs);
-  
+
   rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
   if (rc > 0)
   {
@@ -189,7 +189,7 @@ rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
   }
 
   printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
-    
+
   rc = rtems_rfs_buffer_handle_open (fs, &buffer);
   if (rc > 0)
   {
@@ -226,7 +226,7 @@ rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
   }
 
   printf ("\n");
-  
+
   rc = rtems_rfs_buffer_handle_close (fs, &buffer);
   if (rc > 0)
   {
@@ -235,9 +235,9 @@ rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
             block, rc, strerror (rc));
     return 1;
   }
-  
+
   rtems_rfs_shell_unlock_rfs (fs);
-  
+
   return 0;
 }
 
@@ -309,7 +309,7 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
   }
 
   rtems_rfs_shell_lock_rfs (fs);
-  
+
   for (ino = start; ino <= end; ino++)
   {
     rtems_rfs_inode_handle inode;
@@ -339,7 +339,7 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
       }
 
       error = false;
-      
+
       mode = rtems_rfs_inode_get_mode (&inode);
 
       if (error_check_only)
@@ -372,11 +372,11 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
                 ino, rtems_rfs_buffer_bnum (&inode.buffer),
                 inode.offset * RTEMS_RFS_INODE_SIZE,
                 allocated ? 'A' : 'F');
-    
+
         if (!allocated && !forced)
           printf (" --\n");
         else
-        {      
+        {
           const char* type;
           type = "UKN";
           if (RTEMS_RFS_S_ISDIR (mode))
@@ -399,7 +399,7 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
           printf ("%" PRIu32 "]\n", rtems_rfs_inode_get_block (&inode, b));
         }
       }
-      
+
       rc = rtems_rfs_inode_close (fs, &inode);
       if (rc > 0)
       {
@@ -410,9 +410,9 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
       }
     }
   }
-  
+
   rtems_rfs_shell_unlock_rfs (fs);
-  
+
   return 0;
 }
 
@@ -426,7 +426,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
   int                     entry;
   int                     b;
   int                     rc;
-  
+
   if (argc <= 1)
   {
     printf ("error: no block number provided\n");
@@ -436,7 +436,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
   block = strtoul (argv[1], 0, 0);
 
   rtems_rfs_shell_lock_rfs (fs);
-  
+
   rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
   if (rc > 0)
   {
@@ -470,7 +470,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
   b = 0;
   entry = 1;
   data = rtems_rfs_buffer_data (&buffer);
-  
+
   while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
   {
     rtems_rfs_ino eino;
@@ -480,7 +480,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
 
     eino    = rtems_rfs_dir_entry_ino (data);
     elength = rtems_rfs_dir_entry_length (data);
-    
+
     if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
       break;
 
@@ -490,15 +490,15 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
       printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
       break;
     }
-    
+
     if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
     {
       printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
       break;
     }
-    
+
     length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
-    
+
     printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
             entry, b,
             rtems_rfs_dir_entry_ino (data),
@@ -507,7 +507,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
 
     if (length > 50)
       length = 50;
-    
+
     for (c = 0; c < length; c++)
       printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
     if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
@@ -518,7 +518,7 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
     data += elength;
     entry++;
   }
-  
+
   rc = rtems_rfs_buffer_handle_close (fs, &buffer);
   if (rc > 0)
   {
@@ -527,9 +527,9 @@ rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
             block, rc, strerror (rc));
     return 1;
   }
-  
+
   rtems_rfs_shell_unlock_rfs (fs);
-  
+
   return 0;
 }
 
@@ -565,7 +565,7 @@ rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
     printf ("error: group out of range (0->%d).\n", fs->group_count);
     return 1;
   }
-  
+
   rtems_rfs_shell_lock_rfs (fs);
 
   for (g = start; g <= end; g++)
@@ -580,9 +580,9 @@ rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
             blocks, (blocks * 100)  / group->size,
             inodes, (inodes * 100) / fs->group_inodes);
   }
-  
+
   rtems_rfs_shell_unlock_rfs (fs);
-  
+
   return 0;
 }
 
@@ -618,7 +618,7 @@ rtems_shell_debugrfs (int argc, char *argv[])
 
   int arg;
   int t;
-  
+
   for (arg = 1; arg < argc; arg++)
   {
     if (argv[arg][0] != '-')
@@ -653,7 +653,7 @@ rtems_shell_debugrfs (int argc, char *argv[])
       printf ("error: command not found: %s\n", argv[arg + 1]);
     }
   }
-  
+
   return 1;
 }
 
@@ -675,7 +675,7 @@ rtems_shell_rfs_format (int argc, char* argv[])
         case 'v':
           config.verbose = true;
           break;
-          
+
         case 's':
           arg++;
           if (arg >= argc)
@@ -685,7 +685,7 @@ rtems_shell_rfs_format (int argc, char* argv[])
           }
           config.block_size = strtoul (argv[arg], 0, 0);
           break;
-        
+
         case 'b':
           arg++;
           if (arg >= argc)
@@ -695,7 +695,7 @@ rtems_shell_rfs_format (int argc, char* argv[])
           }
           config.group_blocks = strtoul (argv[arg], 0, 0);
           break;
-          
+
         case 'i':
           arg++;
           if (arg >= argc)
@@ -709,7 +709,7 @@ rtems_shell_rfs_format (int argc, char* argv[])
         case 'I':
           config.initialise_inodes = true;
           break;
-          
+
         case 'o':
           arg++;
           if (arg >= argc)
@@ -719,7 +719,7 @@ rtems_shell_rfs_format (int argc, char* argv[])
           }
           config.inode_overhead = strtoul (argv[arg], 0, 0);
           break;
-          
+
         default:
           printf ("error: invalid option: %s\n", argv[arg]);
           return 1;
@@ -748,6 +748,6 @@ rtems_shell_rfs_format (int argc, char* argv[])
             driver, strerror (errno));
     return 1;
   }
-  
+
   return 0;
 }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-trace.c b/cpukit/libfs/src/rfs/rtems-rfs-trace.c
index d96a63673b..5484c68d79 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-trace.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-trace.c
@@ -100,7 +100,7 @@ rtems_rfs_trace_shell_command (int argc, char *argv[])
   bool                 set = true;
   int                  arg;
   int                  t;
-  
+
   for (arg = 1; arg < argc; arg++)
   {
     if (argv[arg][0] == '-')