int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
break;
case 3:
start = strtoul (argv[1], 0, 0);
end = strtoul (argv[2], 0, 0);
break;
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
(start >= fs->group_count) || (end >= fs->group_count))
{
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++)
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
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=%-7" PRIu32 " 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);
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
static void
rtems_rfs_bitmap_ut_test_bitmap (size_t size)
{
rtems_rfs_file_system fs;
rtems_rfs_bitmap_control control;
rtems_rfs_buffer_handle handle;
rtems_rfs_buffer buffer;
rtems_rfs_bitmap_bit bit = 0;
rtems_rfs_bitmap_bit first_bit;
rtems_rfs_bitmap_bit last_bit;
bool result;
size_t bytes;
size_t clear;
int rc;
bytes = (rtems_rfs_bitmap_elements (size) *
sizeof (rtems_rfs_bitmap_element));
memset (&fs, 0, sizeof (fs));
memset (&buffer, 0, sizeof (buffer));
buffer.buffer = malloc (bytes);
buffer.block = 1;
if (!buffer.buffer)
{
printf (" Cannot allocate bitmap memory\n");
return;
}
#if RTEMS_RFS_BITMAP_CLEAR_ZERO
memset (buffer.buffer, 0, bytes);
#else
memset (buffer.buffer, 0xff, bytes);
#endif
/*
* Do not close the handle so no writes need occur.
*/
rc = rtems_rfs_buffer_handle_open (&fs, &handle);
if (rc > 0)
{
printf (" Cannot open the handle: %d: %s\n", rc, strerror (rc));
free (buffer.buffer);
return;
}
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);
if (rc > 0)
{
printf (" Cannot open the bitmap: %s\n", strerror (rc));
free (buffer.buffer);
return;
}
/*
* This is a new bitmap with no bits set. Try and find a bit with a few
* seeds.
*/
rc = rtems_rfs_bitmap_map_alloc (&control, size * 2, &result, &bit);
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));
rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
result = result && (bit == 0);
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.
*/
rc = rtems_rfs_bitmap_map_test (&control, 0, &result);
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);
/*
* Set all bits then clear one and find it.
*/
rc = rtems_rfs_bitmap_map_set_all (&control);
printf (" 8. Set all bits: %s (%s)\n",
rc == 0 ? "PASS" : "FAIL", strerror (rc));
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));
rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
last_bit = bit;
rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
result = result && (bit == last_bit);
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",
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 (" 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);
rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
result = result && (bit == (size - 1));
printf (" 15. 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 (" 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",
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) (%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",
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, 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",
(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) (%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",
(size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
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);
/*
* Set all bits, clear a random numberone then create a search map and make
* sure the clear count is correct.
*/
rc = rtems_rfs_bitmap_map_set_all (&control);
printf (" 25. Set all bits: %s (%s)\n",
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 ();
last_bit = first_bit + rand () % (size / 2) + rtems_rfs_bitmap_element_bits();
for (bit = first_bit; bit < last_bit; bit++)
{
rc = rtems_rfs_bitmap_map_clear (&control, bit);
if (rc > 0)
{
printf (" 26. Clear bit %" PRId32 ": %s (%s)\n",
bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
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",
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 %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);
rtems_rfs_bitmap_bit mybit = control.size +2;
printf (" 29. Map set check with bit (%d) larger than size (%d)\n",
(int)mybit, (int)control.size);
rc = rtems_rfs_bitmap_map_set(&control, mybit);
rtems_test_assert( rc == EINVAL );
printf (" 30. Map clear check with bit (%d) larger than size (%d)\n",
(int)mybit, (int)control.size);
rc = rtems_rfs_bitmap_map_clear(&control, mybit);
rtems_test_assert( rc == EINVAL );
printf (" 31. Map test check with bit (%d) larger than size (%d)\n",
(int)mybit, (int)control.size);
rc = rtems_rfs_bitmap_map_test(&control, mybit ,&result);
rtems_test_assert( rc == EINVAL );
/* Set all bits, clear one and then set this cleared bit once again */
printf (" 32. Set all bits in the map, then clear bit (%zu) and set this bit once again:",control.size/2);
rc = rtems_rfs_bitmap_map_set_all(&control);
rtems_test_assert( rc == 0 );
rc = rtems_rfs_bitmap_map_clear(&control, control.size/2);
rtems_test_assert (rc == 0 );
rc = rtems_rfs_bitmap_map_set(&control, control.size/2);
rtems_test_assert (rc == 0 );
printf (" PASSED\n");
/* Attempt to find free bit (with different seeds) when all bits are set */
printf (" 33. Attempt to find bit when all bits are set (expected FAILED):");
rc = rtems_rfs_bitmap_map_alloc(&control, 0, &result, &bit);
rtems_test_assert(rc == 0 );
rtems_test_assert ( result == false );
rc = rtems_rfs_bitmap_map_alloc(&control, size-1, &result, &bit);
rtems_test_assert(rc == 0 );
rtems_test_assert ( result == false );
rc = rtems_rfs_bitmap_map_alloc(&control, size/2, &result, &bit);
rtems_test_assert(rc == 0 );
rtems_test_assert ( result == false );
rc = rtems_rfs_bitmap_map_alloc(&control, 1, &result, &bit);
rtems_test_assert(rc == 0 );
rtems_test_assert ( result == false );
rc = rtems_rfs_bitmap_map_alloc(&control, -2, &result, &bit);
rtems_test_assert(rc == 0 );
rtems_test_assert ( result == false );
printf(" FAILED\n");
/* Simply clear all bits */
printf (" 34. Clear all bits in the map.\n");
rc = rtems_rfs_bitmap_map_clear_all(&control);
rtems_test_assert( rc == 0 );
rtems_rfs_bitmap_close (&control);
free (buffer.buffer);
}
