int rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs, rtems_rfs_buffer_block block, bool read, rtems_rfs_buffer** buffer) { rtems_status_code sc; int rc = 0; if (read) sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer); else sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer); if (sc != RTEMS_SUCCESSFUL) { #if RTEMS_RFS_BUFFER_ERRORS printf ("rtems-rfs: buffer-bdbuf-request: block=%lu: bdbuf-%s: %d: %s\n", block, read ? "read" : "get", sc, rtems_status_text (sc)); #endif rc = EIO; } return rc; }
int rtems_rfs_buffer_sync (rtems_rfs_file_system* fs) { int result = 0; #if RTEMS_RFS_USE_LIBBLOCK rtems_status_code sc; #endif if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) printf ("rtems-rfs: buffer-sync: syncing\n"); /* * @todo Split in the separate files for each type. */ #if RTEMS_RFS_USE_LIBBLOCK sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs)); if (sc != RTEMS_SUCCESSFUL) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) printf ("rtems-rfs: buffer-sync: device sync failed: %s\n", rtems_status_text (sc)); result = EIO; } rtems_disk_release (fs->disk); #else if (fsync (fs->device) < 0) { result = errno; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n", result, strerror (result)); } #endif return result; }
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; }
int rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc, struct stat* buf) { rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_file_shared* shared; uint16_t mode; int rc; if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT)) printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino); rc = rtems_rfs_inode_open (fs, ino, &inode, true); if (rc) { return rtems_rfs_rtems_error ("stat: opening inode", rc); } mode = rtems_rfs_inode_get_mode (&inode); if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode)) { 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); buf->st_nlink = rtems_rfs_inode_get_links (&inode); buf->st_uid = rtems_rfs_inode_get_uid (&inode); buf->st_gid = rtems_rfs_inode_get_gid (&inode); /* * Need to check is the ino is an open file. If so we take the values from * the open file rather than the inode. */ shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode)); if (shared) { buf->st_atime = rtems_rfs_file_shared_get_atime (shared); buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared); buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared); buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared); if (S_ISLNK (buf->st_mode)) buf->st_size = rtems_rfs_file_shared_get_block_offset (shared); else buf->st_size = rtems_rfs_file_shared_get_size (fs, shared); } else { buf->st_atime = rtems_rfs_inode_get_atime (&inode); buf->st_mtime = rtems_rfs_inode_get_mtime (&inode); buf->st_ctime = rtems_rfs_inode_get_ctime (&inode); buf->st_blocks = rtems_rfs_inode_get_block_count (&inode); if (S_ISLNK (buf->st_mode)) buf->st_size = rtems_rfs_inode_get_block_offset (&inode); 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) { return rtems_rfs_rtems_error ("stat: closing inode", rc); } return 0; }