static void nullpointer_test(void){ rtems_rfs_bitmap_control control; rtems_rfs_bitmap_bit bit = 0; rtems_rfs_bitmap_bit seed_bit = 0; int rc; bool result; memset(&control, 0, sizeof(control)); printf ("\n Testing bitmap_map functions with zero " "initialized bitmap control pointer\n"); /* Invoke all functions with control initialized to zero */ rc = rtems_rfs_bitmap_map_set(&control, bit); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_map_clear(&control, bit); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_map_test(&control, bit, &result); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_map_set_all(&control); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_map_clear_all(&control); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_create_search(&control); rtems_test_assert(rc == ENXIO); rc = rtems_rfs_bitmap_map_alloc(&control, seed_bit, &result, &bit); rtems_test_assert(rc == 0); rtems_test_assert(!result); rc = rtems_rfs_bitmap_map_set(&control, bit); rtems_test_assert(rc == ENXIO); }
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); }
static bool rtems_rfs_write_group (rtems_rfs_file_system* fs, int group, bool initialise_inodes, bool verbose) { rtems_rfs_buffer_handle handle; rtems_rfs_bitmap_control bitmap; rtems_rfs_buffer_block group_base; size_t group_size; int blocks; int b; int rc; group_base = rtems_rfs_fs_block (fs, group, 0); if (group_base > rtems_rfs_fs_blocks (fs)) { printf ("rtems-rfs: write-group: group %d base beyond disk limit\n", group); return false; } group_size = fs->group_blocks; /* * Be nice to strange sizes of disks. These are embedded systems after all * and nice numbers do not always work out. Let the last block pick up the * remainder of the blocks. */ if ((group_base + group_size) > rtems_rfs_fs_blocks (fs)) group_size = rtems_rfs_fs_blocks (fs) - group_base; if (verbose) printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd", group, group_base, group_size); /* * Open a handle and request an empty buffer. */ rc = rtems_rfs_buffer_handle_open (fs, &handle); if (rc > 0) { printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n", rc, strerror (rc)); return false; } if (verbose) printf (", blocks"); /* * Open the block bitmap using the new buffer. */ rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size, group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n", group, 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)); /* * Clear the bitmap. */ rc = rtems_rfs_bitmap_map_clear_all (&bitmap); if (rc > 0) { rtems_rfs_bitmap_close (&bitmap); rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Forced allocation of the block bitmap. */ rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK); /* * Forced allocation of the inode bitmap. */ rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK); /* * Determine the number of inodes blocks in the group. */ blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block); /* * Forced allocation of the inode blocks which follow the block bitmap. */ for (b = 0; b < blocks; b++) rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK); /* * Close the block bitmap. */ rc = rtems_rfs_bitmap_close (&bitmap); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } rtems_rfs_buffer_mark_dirty (&handle); if (verbose) printf (", inodes"); /* * Open the inode bitmap using the old buffer. Should release any changes. */ rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size, group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n", group, 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), 0x00, rtems_rfs_fs_block_size (fs)); /* * Clear the inode bitmap. */ rc = rtems_rfs_bitmap_map_clear_all (&bitmap); if (rc > 0) { rtems_rfs_bitmap_close (&bitmap); rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \ " clear all failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Close the inode bitmap. */ rc = rtems_rfs_bitmap_close (&bitmap); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: close inode" \ " bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } rtems_rfs_buffer_mark_dirty (&handle); /* * Initialise the inode tables if required to do so. */ if (initialise_inodes) { for (b = 0; b < blocks; b++) { rc = rtems_rfs_buffer_handle_request (fs, &handle, group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK, false); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n", group, group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK, 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) { printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n", rc, strerror (rc)); return false; } return true; }