RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

Remove stray whitespaces.

Browse Source
This commit is contained in:
Ralf Corsepius
2011-11-06 12:44:24 +00:00
parent 0527367cd9
commit 66b8047e52
44 changed files with 536 additions and 536 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cpukit/libfs/src/devfs/devfs_init.c
View File

@@ -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
};

2
cpukit/libfs/src/devfs/devstat.c
View File

@@ -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;

2
cpukit/libfs/src/dosfs/msdos_dir.c
View File

@@ -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)

2
cpukit/libfs/src/dosfs/msdos_file.c
View File

@@ -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;

6
cpukit/libfs/src/dosfs/msdos_misc.c
View File

@@ -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.
*/

4
cpukit/libfs/src/dosfs/msdos_rename.c
View File

@@ -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;
}

2
cpukit/libfs/src/imfs/imfs_eval.c
View File

@@ -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.

2
cpukit/libfs/src/imfs/imfs_fifo.c
View File

@@ -56,7 +56,7 @@ int IMFS_fifo_close(
iop->flags &= ~LIBIO_FLAGS_OPEN;
IMFS_check_node_remove(jnode);
IMFS_FIFO_RETURN(err);
}

2
cpukit/libfs/src/imfs/imfs_link.c
View File

@@ -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,

4
cpukit/libfs/src/imfs/imfs_load_tar.c
View File

@@ -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;

4
cpukit/libfs/src/imfs/imfs_mknod.c
View File

@@ -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 )

6
cpukit/libfs/src/imfs/imfs_rename.c
View File

@@ -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.
*/

2
cpukit/libfs/src/imfs/imfs_stat.c
View File

@@ -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;

2
cpukit/libfs/src/imfs/imfs_symlink.c
View File

@@ -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,

60
cpukit/libfs/src/rfs/rtems-rfs-bitmaps-ut.c
View File

@@ -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);
}

70
cpukit/libfs/src/rfs/rtems-rfs-bitmaps.c
View File

@@ -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;

6
cpukit/libfs/src/rfs/rtems-rfs-bitmaps.h
View File

@@ -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);
/**

2
cpukit/libfs/src/rfs/rtems-rfs-block-pos.h
View File

@@ -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;

54
cpukit/libfs/src/rfs/rtems-rfs-block.c
View File

@@ -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
{

6
cpukit/libfs/src/rfs/rtems-rfs-block.h
View File

@@ -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)
{

2
cpukit/libfs/src/rfs/rtems-rfs-buffer-bdbuf.c
View File

@@ -85,7 +85,7 @@ rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
#endif
rc = EIO;
}
return rc;
}

2
cpukit/libfs/src/rfs/rtems-rfs-buffer-devio.c
View File

@@ -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)
{

40
cpukit/libfs/src/rfs/rtems-rfs-buffer.c
View File

@@ -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;

6
cpukit/libfs/src/rfs/rtems-rfs-buffer.h
View File

@@ -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;
}

12
cpukit/libfs/src/rfs/rtems-rfs-dir-hash.c
View File

@@ -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

102
cpukit/libfs/src/rfs/rtems-rfs-dir.c
View File

@@ -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;

26
cpukit/libfs/src/rfs/rtems-rfs-file-system.c
View File

@@ -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;
}

74
cpukit/libfs/src/rfs/rtems-rfs-file.c
View File

@@ -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;
}

6
cpukit/libfs/src/rfs/rtems-rfs-file.h
View File

@@ -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)
{

68
cpukit/libfs/src/rfs/rtems-rfs-format.c
View File

@@ -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;
}

52
cpukit/libfs/src/rfs/rtems-rfs-group.c
View File

@@ -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;
}

2
cpukit/libfs/src/rfs/rtems-rfs-group.h
View File

@@ -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.

38
cpukit/libfs/src/rfs/rtems-rfs-inode.c
View File

@@ -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;

4
cpukit/libfs/src/rfs/rtems-rfs-inode.h
View File

@@ -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);
/**

44
cpukit/libfs/src/rfs/rtems-rfs-link.c
View File

@@ -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;
}

4
cpukit/libfs/src/rfs/rtems-rfs-mutex.c
View File

@@ -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;
}

4
cpukit/libfs/src/rfs/rtems-rfs-mutex.h
View File

@@ -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;

14
cpukit/libfs/src/rfs/rtems-rfs-rtems-dev.c
View File

@@ -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)

20
cpukit/libfs/src/rfs/rtems-rfs-rtems-dir.c
View File

@@ -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)
{

60
cpukit/libfs/src/rfs/rtems-rfs-rtems-file.c
View File

@@ -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;

12
cpukit/libfs/src/rfs/rtems-rfs-rtems-utils.c
View File

@@ -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

156
cpukit/libfs/src/rfs/rtems-rfs-rtems.c
View File

@@ -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);
}

82
cpukit/libfs/src/rfs/rtems-rfs-shell.c
View File

@@ -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;
}

2
cpukit/libfs/src/rfs/rtems-rfs-trace.c
View File

@@ -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] == '-')