2010-03-22 Joel Sherrill <joel.sherrill@oarcorp.com>

	* libfs/src/rfs/rtems-rfs-bitmaps-ut.c,
	libfs/src/rfs/rtems-rfs-block.c, libfs/src/rfs/rtems-rfs-buffer.c,
	libfs/src/rfs/rtems-rfs-dir.c, libfs/src/rfs/rtems-rfs-file.c,
	libfs/src/rfs/rtems-rfs-format.c, libfs/src/rfs/rtems-rfs-group.c,
	libfs/src/rfs/rtems-rfs-rtems-file.c,
	libfs/src/rfs/rtems-rfs-shell.c: Fix printf format warning. Primarily
	for size_t.

9 files changed, 48 insertions, 47 deletions

diff --git a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
index ad571af1bb..a7b05b2265 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
@@ -83,7 +83,7 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
   for (i = 0; i < size; i++)
     rtems_rfs_bitmap_map_clear (control, bit + i);
   
-  printf (" %2d. Cleared bits (%ld, %ld] (%ld)\n",
+  printf (" %2d. Cleared bits (%ld, %ld] (%zd)\n",
           test, bit, bit + size - 1, size);
   
   for (i = 0; i < rtems_rfs_bitmap_element_bits (); i++)
@@ -120,7 +120,7 @@ rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
     }
   }
 
-  printf (" %2d. Alloc'ed all bits (%ld, %ld] (%ld)\n",
+  printf (" %2d. Alloc'ed all bits (%ld, %ld] (%zd)\n",
           test, bit, bit + size - 1, size);
   
   return true;
@@ -176,7 +176,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   handle.buffer = &buffer;
   handle.bnum = 1;
   
-  printf ("\nRFS Bitmap Test : size = %ld (%ld)\n",
+  printf ("\nRFS Bitmap Test : size = %zd (%zd)\n",
           size, rtems_rfs_bitmap_elements (size));
   rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1); 
   if (rc > 0)
@@ -208,7 +208,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   
   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) (%ld): %s (%s): bit = %ld\n",
+  printf ("  4. Find bit (size - 1) with seed = (size - 1) (%zd): %s (%s): bit = %ld\n",
           size - 1, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
@@ -223,7 +223,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   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) (%ld): %s (%s)\n",
+  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);
   
@@ -270,7 +270,7 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
   rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
-  printf (" 14. Clear bit (size - 1) (%ld): %s (%s)\n",
+  printf (" 14. 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);
 
@@ -286,18 +286,18 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   
   rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
   result = result && (bit == 0);
-  printf (" 17. Find bit with seed = (size / 2) (%ld): %s (%s): bit = %ld\n",
+  printf (" 17. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %ld\n",
           size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
   rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
-  printf (" 18. Clear bit (size - 1) (%ld): %s, (%s)\n",
+  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) (%ld): %s (%s): bit = %ld\n",
+  printf (" 19. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %ld\n",
           size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
@@ -307,17 +307,17 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   
   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) (%ld): %s (%s): bit = %ld\n",
+  printf (" 21. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %ld\n",
           (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
   rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
-  printf (" 22. Clear bit (size - 1) (%ld): %s (%s)\n",
+  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) (%ld): %s (%s): bit = %ld\n",
+  printf (" 23. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %ld\n",
           (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
 
@@ -358,13 +358,13 @@ rtems_rfs_bitmap_ut_test_bitmap (size_t size)
   
   clear = rtems_rfs_bitmap_map_free (&control);
   result = clear == (last_bit - first_bit);
-  printf (" 27. Check free count is %ld: %ld: %s (%s)\n",
+  printf (" 27. Check free count is %zd: %ld: %s (%s)\n",
           clear, last_bit - first_bit,
           result ? "pass" : "FAIL", strerror (rc));
 
   rc = rtems_rfs_bitmap_create_search (&control);
   result = clear == rtems_rfs_bitmap_map_free (&control);
-  printf (" 28. Create search check free count is %ld: %ld: %s (%s)\n",
+  printf (" 28. Create search check free count is %zd: %zd: %s (%s)\n",
           clear, rtems_rfs_bitmap_map_free (&control),
           result ? "pass" : "FAIL", strerror (rc));
   rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
@@ -379,7 +379,7 @@ rtems_rfs_bitmap_unit_test (void)
   printf ("RTEMS File System Bitmap Unit Test\n");
   printf (" Bit set value       : %d\n", RTEMS_RFS_BITMAP_BIT_SET);
   printf (" Bit clear value     : %d\n", RTEMS_RFS_BITMAP_BIT_CLEAR);
-  printf (" Num bit per element : %ld\n", rtems_rfs_bitmap_element_bits ());
+  printf (" Num bit per element : %zd\n", rtems_rfs_bitmap_element_bits ());
 
   srand (0x23984237);
   
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-block.c b/cpukit/libfs/src/rfs/rtems-rfs-block.c
index fd5532c46f..bf3ae7de8d 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-block.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-block.c
@@ -411,7 +411,7 @@ rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
   int b;
   
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
-    printf ("rtems-rfs: block-map-grow: entry: blocks=%ld count=%lu\n",
+    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%lu\n",
             blocks, map->size.count);
             
   if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
@@ -653,7 +653,7 @@ rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
                             size_t                 blocks)
 {
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
-    printf ("rtems-rfs: block-map-shrink: entry: blocks=%ld count=%lu\n",
+    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%lu\n",
             blocks, map->size.count);
             
   if (map->size.count == 0)
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-buffer.c b/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
index 4d9d419d5c..1f883811c6 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-buffer.c
@@ -406,7 +406,7 @@ rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
   int rc;
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
-    printf ("rtems-rfs: buffer-setblksize: block size: %lu\n", size);
+    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
 
   rc = rtems_rfs_buffers_release (fs);
   if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-dir.c b/cpukit/libfs/src/rfs/rtems-rfs-dir.c
index 03fd0d873b..3aa971c388 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-dir.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-dir.c
@@ -228,7 +228,7 @@ rtems_rfs_dir_add_entry (rtems_rfs_file_system*  fs,
             rtems_rfs_inode_ino (dir));
     for (c = 0; c < length; c++)
       printf ("%c", name[c]);
-    printf (", len=%ld\n", length);
+    printf (", len=%zd\n", length);
   }
         
   rc = rtems_rfs_block_map_open (fs, dir, &map);
@@ -612,7 +612,7 @@ 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:%ld length:%ld\n",
+      printf ("rtems-rfs: dir-read: next block: off:%ld length:%zd\n",
               (uint32_t) offset, *length);
       
     rc = rtems_rfs_block_map_next_block (fs, &map, &block);
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-file.c b/cpukit/libfs/src/rfs/rtems-rfs-file.c
index f22f360af1..05ac5051b0 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-file.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-file.c
@@ -285,7 +285,7 @@ rtems_rfs_file_io_start (rtems_rfs_file_handle* 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=%lu (%lu)\n",
+    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
             *available, size);
     
   return 0;
@@ -302,7 +302,7 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
   int  rc = 0;
 
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
-    printf ("rtems-rfs: file-io:   end: %s size=%lu\n",
+    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",
             read ? "read" : "write", size);
   
   if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
@@ -313,8 +313,9 @@ rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
                                           rtems_rfs_file_buffer (handle));
     if (rc > 0)
     {
-      printf ("rtems-rfs: file-io:   end: error on release: %s size=%lu: %d: %s\n",
-              read ? "read" : "write", size, rc, strerror (rc));
+      printf (
+        "rtems-rfs: file-io:   end: error on release: %s size=%zu: %d: %s\n",
+        read ? "read" : "write", size, rc, strerror (rc));
       
       return rc;
     }
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-format.c b/cpukit/libfs/src/rfs/rtems-rfs-format.c
index 9d26eb4bfb..e2ddddbb00 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-format.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-format.c
@@ -115,7 +115,7 @@ rtems_rfs_check_config (rtems_rfs_file_system*         fs,
   
   if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
   {
-    printf ("block size (%ld) is not a multiple of media block size (%ld)\n",
+    printf ("block size (%zd) is not a multiple of media block size (%ld)\n",
             fs->block_size, rtems_rfs_fs_media_block_size (fs));
     return false;
   }
@@ -214,7 +214,7 @@ rtems_rfs_write_group (rtems_rfs_file_system* fs,
     group_size = rtems_rfs_fs_blocks (fs) - group_base;
 
   if (verbose)
-    printf ("\rrtems-rfs: format: group %3d: base = %ld, size = %ld",
+    printf ("\rrtems-rfs: format: group %3d: base = %ld, size = %zd",
             group, group_base, group_size);
 
   /*
@@ -581,20 +581,20 @@ rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
             rtems_rfs_fs_media_block_size (&fs));
     printf ("rtems-rfs: format: size = %llu\n",
             rtems_rfs_fs_size (&fs));
-    printf ("rtems-rfs: format: blocks = %lu\n",
+    printf ("rtems-rfs: format: blocks = %zu\n",
             rtems_rfs_fs_blocks (&fs));
-    printf ("rtems-rfs: format: block size = %lu\n",
+    printf ("rtems-rfs: format: block size = %zu\n",
             rtems_rfs_fs_block_size (&fs));
     printf ("rtems-rfs: format: bits per block = %u\n",
             rtems_rfs_bits_per_block (&fs));
-    printf ("rtems-rfs: format: inode size = %lu\n", RTEMS_RFS_INODE_SIZE);
-    printf ("rtems-rfs: format: inodes = %lu (%d.%d%%)\n",
+    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
+    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
             fs.group_inodes * fs.group_count,
             rtems_rfs_inode_overhead (&fs) / 10,
             rtems_rfs_inode_overhead (&fs) % 10);
     printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
-    printf ("rtems-rfs: format: group blocks = %lu\n", fs.group_blocks);
-    printf ("rtems-rfs: format: group inodes = %lu\n", fs.group_inodes);
+    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
+    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
   }
 
   rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-group.c b/cpukit/libfs/src/rfs/rtems-rfs-group.c
index 9a1e27871e..b69bc29aab 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-group.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-group.c
@@ -42,7 +42,7 @@ rtems_rfs_group_open (rtems_rfs_file_system* fs,
     size = rtems_rfs_fs_blocks (fs) - base;
   
   if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
-    printf ("rtems-rfs: group-open: base=%ld, blocks=%ld inodes=%ld\n",
+    printf ("rtems-rfs: group-open: base=%ld, blocks=%zd inodes=%zd\n",
             base, size, inodes);
 
   group->base = base;
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c b/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
index e13e2330c5..6a47140b36 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
@@ -117,7 +117,7 @@ rtems_rfs_rtems_file_read (rtems_libio_t* iop,
   int                    rc;
 
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
-    printf("rtems-rfs: file-read: handle:%p count:%ld\n", file, count);
+    printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
 
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
 
@@ -182,7 +182,7 @@ rtems_rfs_rtems_file_write (rtems_libio_t* iop,
   int                    rc;
 
   if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
-    printf("rtems-rfs: file-write: handle:%p count:%ld\n", file, count);
+    printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
 
   rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
 
diff --git a/cpukit/libfs/src/rfs/rtems-rfs-shell.c b/cpukit/libfs/src/rfs/rtems-rfs-shell.c
index 4719d93144..b67cda9739 100644
--- a/cpukit/libfs/src/rfs/rtems-rfs-shell.c
+++ b/cpukit/libfs/src/rfs/rtems-rfs-shell.c
@@ -120,8 +120,8 @@ rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
 #if 0
   printf ("            device: %08lx\n", rtems_rfs_fs_device (fs));
 #endif
-  printf ("            blocks: %lu\n",  rtems_rfs_fs_blocks (fs));
-  printf ("        block size: %lu\n",  rtems_rfs_fs_block_size (fs));
+  printf ("            blocks: %zu\n",  rtems_rfs_fs_blocks (fs));
+  printf ("        block size: %zu\n",  rtems_rfs_fs_block_size (fs));
   printf ("              size: %llu\n", rtems_rfs_fs_size (fs));
   printf ("  media block size: %lu\n",  rtems_rfs_fs_media_block_size (fs));
   printf ("        media size: %llu\n", rtems_rfs_fs_media_size (fs));
@@ -129,12 +129,12 @@ rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
   printf ("        bad blocks: %lu\n",  fs->bad_blocks);
   printf ("  max. name length: %lu\n",  rtems_rfs_fs_max_name (fs));
   printf ("            groups: %d\n",   fs->group_count);
-  printf ("      group blocks: %ld\n",  fs->group_blocks);
-  printf ("      group inodes: %ld\n",  fs->group_inodes);
-  printf ("  inodes per block: %ld\n",  fs->inodes_per_block);
-  printf ("  blocks per block: %ld\n",  fs->blocks_per_block);
-  printf ("     singly blocks: %ld\n",  fs->block_map_singly_blocks);
-  printf ("    doublly blocks: %ld\n",  fs->block_map_doubly_blocks);
+  printf ("      group blocks: %zd\n",  fs->group_blocks);
+  printf ("      group inodes: %zd\n",  fs->group_inodes);
+  printf ("  inodes per block: %zd\n",  fs->inodes_per_block);
+  printf ("  blocks per block: %zd\n",  fs->blocks_per_block);
+  printf ("     singly blocks: %zd\n",  fs->block_map_singly_blocks);
+  printf ("    doublly blocks: %zd\n",  fs->block_map_doubly_blocks);
   printf (" max. held buffers: %ld\n",  fs->max_held_buffers);
 
   rtems_rfs_shell_lock_rfs (fs);
@@ -146,9 +146,9 @@ rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
   bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
   ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
   
-  printf ("       blocks used: %ld (%d.%d%%)\n",
+  printf ("       blocks used: %zd (%d.%d%%)\n",
           blocks, bpcent / 10, bpcent % 10);
-  printf ("       inodes used: %ld (%d.%d%%)\n",
+  printf ("       inodes used: %zd (%d.%d%%)\n",
           inodes, ipcent / 10, ipcent % 10);
   
   return 0;
@@ -364,7 +364,7 @@ rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
 
       if (!error_check_only || error)
       {
-        printf (" %5lu: pos=%06lu:%04lx %c ",
+        printf (" %5lu: pos=%06lu:%04zx %c ",
                 ino, rtems_rfs_buffer_bnum (&inode.buffer),
                 inode.offset * RTEMS_RFS_INODE_SIZE,
                 allocated ? 'A' : 'F');
@@ -571,7 +571,7 @@ rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
     size_t           inodes;
     blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
     inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
-    printf (" %4d: base=%-7lu size=%-6lu blocks=%-5lu (%3lu%%) inode=%-5lu (%3lu%%)\n",
+    printf (" %4d: base=%-7lu size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
             g, group->base, group->size,
             blocks, (blocks * 100)  / group->size,
             inodes, (inodes * 100) / fs->group_inodes);