int rtems_rfs_group_usage (rtems_rfs_file_system* fs, size_t* blocks, size_t* inodes) { int g; *blocks = 0; *inodes = 0; for (g = 0; g < fs->group_count; g++) { rtems_rfs_group* group = &fs->groups[g]; *blocks += rtems_rfs_bitmap_map_size(&group->block_bitmap) - rtems_rfs_bitmap_map_free (&group->block_bitmap); *inodes += rtems_rfs_bitmap_map_size (&group->inode_bitmap) - rtems_rfs_bitmap_map_free (&group->inode_bitmap); } if (*blocks > rtems_rfs_fs_blocks (fs)) *blocks = rtems_rfs_fs_blocks (fs); if (*inodes > rtems_rfs_fs_inodes (fs)) *inodes = rtems_rfs_fs_inodes (fs); return 0; }
static int rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[]) { size_t blocks; size_t inodes; int bpcent; int ipcent; printf ("RFS Filesystem Data\n"); printf (" flags: %08" PRIx32 "\n", fs->flags); #if 0 printf (" device: %08lx\n", rtems_rfs_fs_device (fs)); #endif printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs)); printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs)); printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs)); printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs)); printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs)); printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs)); printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks); printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs)); printf (" groups: %d\n", fs->group_count); printf (" group blocks: %zd\n", fs->group_blocks); printf (" group inodes: %zd\n", fs->group_inodes); printf (" inodes per block: %zd\n", fs->inodes_per_block); printf (" blocks per block: %zd\n", fs->blocks_per_block); printf (" singly blocks: %zd\n", fs->block_map_singly_blocks); printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks); printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers); 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; }
/** * Return the file system stat data. * * @param pathloc * @param sb * @return int */ static int rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc, struct statvfs* sb) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); size_t blocks; 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); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; 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; }
int rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no, bool* state) { rtems_rfs_bitmap_control* bitmap; unsigned int group; rtems_rfs_bitmap_bit bit; size_t size; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS)) printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n", inode ? "inode" : "block", no); if (inode) { if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (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; }
int rtems_rfs_inode_open (rtems_rfs_file_system* fs, rtems_rfs_ino ino, rtems_rfs_inode_handle* handle, bool load) { int group; 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; index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK; handle->offset = gino % fs->inodes_per_block; handle->block = rtems_rfs_group_block (&fs->groups[group], index); rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer); if ((rc == 0) && load) rc = rtems_rfs_inode_load (fs, handle); return rc; }
rtems_rfs_rtems_statvfs ( const rtems_filesystem_location_info_t *__restrict pathloc, struct statvfs *__restrict sb) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); size_t blocks; 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); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks - 1; /* do not count the superblock */ sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; 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; } /** * Handler table for RFS link nodes */ const rtems_filesystem_file_handlers_r rtems_rfs_rtems_link_handlers = { .open_h = rtems_filesystem_default_open,
static int rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[]) { rtems_rfs_buffer_handle buffer; rtems_rfs_block_no block; uint8_t* data; bool state; int entry; int b; int rc; if (argc <= 1) { printf ("error: no block number provided\n"); return 1; } 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) { rtems_rfs_shell_unlock_rfs (fs); printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n", block, rc, strerror (rc)); return 1; } printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free"); rc = rtems_rfs_buffer_handle_open (fs, &buffer); if (rc > 0) { rtems_rfs_shell_unlock_rfs (fs); printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n", block, rc, strerror (rc)); return 1; } rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_shell_unlock_rfs (fs); printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n", block, rc, strerror (rc)); return 1; } 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; int elength; int length; int c; eino = rtems_rfs_dir_entry_ino (data); elength = rtems_rfs_dir_entry_length (data); if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) break; if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) || (elength >= rtems_rfs_fs_max_name (fs))) { 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), rtems_rfs_dir_entry_hash (data), length); 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) printf ("..."); printf ("\n"); b += elength; data += elength; entry++; } rc = rtems_rfs_buffer_handle_close (fs, &buffer); if (rc > 0) { rtems_rfs_shell_unlock_rfs (fs); printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n", block, rc, strerror (rc)); return 1; } rtems_rfs_shell_unlock_rfs (fs); return 0; }