mu2pwryse
/
pmhuj4vri
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rename FileInfo to Metadata. complete FsInfo

Browse Source
master
WangRunji 7 years ago
parent 9b8f730e8e
commit 6e6b33f6fc
8 changed files with 125 additions and 60 deletions
Show Stats Download Patch File Download Diff File

7
Cargo.toml
Unescape View File

@ -0,0 +1,7 @@
[workspace]
members = [
"rcore-fs",
"rcore-fs-sfs",
"rcore-fs-sefs",
"rcore-fs-fuse"
]

29
rcore-fs-fuse/src/lib.rs
Unescape View File

@ -1,4 +1,4 @@
use fuse::{FileAttr, Filesystem, FileType, ReplyAttr, ReplyData, ReplyDirectory, ReplyEmpty, ReplyEntry, ReplyWrite, Request}; use fuse::{FileAttr, Filesystem, FileType, ReplyAttr, ReplyData, ReplyDirectory, ReplyEmpty, ReplyEntry, ReplyWrite, ReplyStatfs, Request};
use rcore_fs::vfs; use rcore_fs::vfs;
use std::collections::btree_map::BTreeMap; use std::collections::btree_map::BTreeMap;
use std::ffi::OsStr; use std::ffi::OsStr;
@ -25,7 +25,7 @@ impl<T: vfs::FileSystem> VfsFuse<T> {
nsec: time.nsec, nsec: time.nsec,
} }
} }
fn trans_attr(info: vfs::FileInfo) -> FileAttr { fn trans_attr(info: vfs::Metadata) -> FileAttr {
FileAttr { FileAttr {
ino: info.inode as u64, ino: info.inode as u64,
size: info.size as u64, size: info.size as u64,
@ -50,6 +50,8 @@ impl<T: vfs::FileSystem> VfsFuse<T> {
vfs::FileType::SymLink => FileType::Symlink, vfs::FileType::SymLink => FileType::Symlink,
vfs::FileType::CharDevice => FileType::CharDevice, vfs::FileType::CharDevice => FileType::CharDevice,
vfs::FileType::BlockDevice => FileType::BlockDevice, vfs::FileType::BlockDevice => FileType::BlockDevice,
vfs::FileType::NamedPipe => FileType::NamedPipe,
vfs::FileType::Socket => FileType::Socket,
} }
} }
fn trans_error(err: vfs::FsError) -> i32 { fn trans_error(err: vfs::FsError) -> i32 {
@ -96,7 +98,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
fn lookup(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEntry) { fn lookup(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEntry) {
let inode = try_vfs!(reply, self.get_inode(parent)); let inode = try_vfs!(reply, self.get_inode(parent));
let target = try_vfs!(reply, inode.lookup(name.to_str().unwrap())); let target = try_vfs!(reply, inode.lookup(name.to_str().unwrap()));
let info = try_vfs!(reply, target.info()); let info = try_vfs!(reply, target.metadata());
self.inodes.insert(info.inode, target); self.inodes.insert(info.inode, target);
let attr = Self::trans_attr(info); let attr = Self::trans_attr(info);
reply.entry(&TTL, &attr, 0); reply.entry(&TTL, &attr, 0);
@ -104,7 +106,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
fn getattr(&mut self, _req: &Request, ino: u64, reply: ReplyAttr) { fn getattr(&mut self, _req: &Request, ino: u64, reply: ReplyAttr) {
let inode = try_vfs!(reply, self.get_inode(ino)); let inode = try_vfs!(reply, self.get_inode(ino));
let info = try_vfs!(reply, inode.info()); let info = try_vfs!(reply, inode.metadata());
let attr = Self::trans_attr(info); let attr = Self::trans_attr(info);
reply.attr(&TTL, &attr); reply.attr(&TTL, &attr);
} }
@ -113,7 +115,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
let name = name.to_str().unwrap(); let name = name.to_str().unwrap();
let inode = try_vfs!(reply, self.get_inode(parent)); let inode = try_vfs!(reply, self.get_inode(parent));
let target = try_vfs!(reply, inode.create(name, vfs::FileType::File, mode)); let target = try_vfs!(reply, inode.create(name, vfs::FileType::File, mode));
let info = try_vfs!(reply, target.info()); let info = try_vfs!(reply, target.metadata());
self.inodes.insert(info.inode, target); self.inodes.insert(info.inode, target);
let attr = Self::trans_attr(info); let attr = Self::trans_attr(info);
reply.entry(&TTL, &attr, 0); reply.entry(&TTL, &attr, 0);
@ -123,7 +125,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
let name = name.to_str().unwrap(); let name = name.to_str().unwrap();
let inode = try_vfs!(reply, self.get_inode(parent)); let inode = try_vfs!(reply, self.get_inode(parent));
let target = try_vfs!(reply, inode.create(name, vfs::FileType::Dir, mode)); let target = try_vfs!(reply, inode.create(name, vfs::FileType::Dir, mode));
let info = try_vfs!(reply, target.info()); let info = try_vfs!(reply, target.metadata());
let attr = Self::trans_attr(info); let attr = Self::trans_attr(info);
reply.entry(&TTL, &attr, 0); reply.entry(&TTL, &attr, 0);
} }
@ -158,7 +160,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
let inode = try_vfs!(reply, self.get_inode(ino)); let inode = try_vfs!(reply, self.get_inode(ino));
let newparent = try_vfs!(reply, self.get_inode(newparent)); let newparent = try_vfs!(reply, self.get_inode(newparent));
try_vfs!(reply, newparent.link(newname, inode)); try_vfs!(reply, newparent.link(newname, inode));
let info = try_vfs!(reply, inode.info()); let info = try_vfs!(reply, inode.metadata());
let attr = Self::trans_attr(info); let attr = Self::trans_attr(info);
reply.entry(&TTL, &attr, 0); reply.entry(&TTL, &attr, 0);
} }
@ -173,7 +175,7 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
fn write(&mut self, _req: &Request, ino: u64, _fh: u64, offset: i64, data: &[u8], _flags: u32, reply: ReplyWrite) { fn write(&mut self, _req: &Request, ino: u64, _fh: u64, offset: i64, data: &[u8], _flags: u32, reply: ReplyWrite) {
let inode = try_vfs!(reply, self.get_inode(ino)); let inode = try_vfs!(reply, self.get_inode(ino));
let info = try_vfs!(reply, inode.info()); let info = try_vfs!(reply, inode.metadata());
let end = offset as usize + data.len(); let end = offset as usize + data.len();
if end > info.size { if end > info.size {
try_vfs!(reply, inode.resize(end)); try_vfs!(reply, inode.resize(end));
@ -196,12 +198,12 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
fn readdir(&mut self, _req: &Request, ino: u64, _fh: u64, offset: i64, mut reply: ReplyDirectory) { fn readdir(&mut self, _req: &Request, ino: u64, _fh: u64, offset: i64, mut reply: ReplyDirectory) {
let inode = try_vfs!(reply, self.get_inode(ino)); let inode = try_vfs!(reply, self.get_inode(ino));
let info = try_vfs!(reply, inode.info()); let info = try_vfs!(reply, inode.metadata());
let count = info.size; let count = info.size;
for i in offset as usize..count { for i in offset as usize..count {
let name = inode.get_entry(i).unwrap(); let name = inode.get_entry(i).unwrap();
let inode = try_vfs!(reply, inode.find(name.as_str())); let inode = try_vfs!(reply, inode.find(name.as_str()));
let info = try_vfs!(reply, inode.info()); let info = try_vfs!(reply, inode.metadata());
let kind = Self::trans_type(info.type_); let kind = Self::trans_type(info.type_);
let full = reply.add(info.inode as u64, i as i64 + 1, kind, name); let full = reply.add(info.inode as u64, i as i64 + 1, kind, name);
if full { if full {
@ -210,4 +212,11 @@ impl<T: vfs::FileSystem> Filesystem for VfsFuse<T> {
} }
reply.ok(); reply.ok();
} }
fn statfs(&mut self, _req: &Request, _ino: u64, reply: ReplyStatfs) {
let info = self.fs.info();
reply.statfs(info.blocks as u64, info.bfree as u64, info.bavail as u64,
info.files as u64, info.ffree as u64, info.bsize as u32,
info.namemax as u32, info.frsize as u32);
}
} }

43
rcore-fs-sefs/src/lib.rs
Unescape View File

@ -143,9 +143,10 @@ impl vfs::INode for INodeImpl {
Ok(len) Ok(len)
} }
/// the size returned here is logical size(entry num for directory), not the disk space used. /// the size returned here is logical size(entry num for directory), not the disk space used.
fn info(&self) -> vfs::Result<vfs::FileInfo> { fn metadata(&self) -> vfs::Result<vfs::Metadata> {
let disk_inode = self.disk_inode.read(); let disk_inode = self.disk_inode.read();
Ok(vfs::FileInfo { Ok(vfs::Metadata {
dev: 0,
inode: self.id, inode: self.id,
size: match disk_inode.type_ { size: match disk_inode.type_ {
FileType::File => disk_inode.size as usize, FileType::File => disk_inode.size as usize,
@ -161,6 +162,7 @@ impl vfs::INode for INodeImpl {
nlinks: disk_inode.nlinks as usize, nlinks: disk_inode.nlinks as usize,
uid: disk_inode.uid as usize, uid: disk_inode.uid as usize,
gid: disk_inode.gid as usize, gid: disk_inode.gid as usize,
blk_size: 0x1000,
}) })
} }
fn sync(&self) -> vfs::Result<()> { fn sync(&self) -> vfs::Result<()> {
@ -185,7 +187,7 @@ impl vfs::INode for INodeImpl {
vfs::FileType::Dir => FileType::Dir, vfs::FileType::Dir => FileType::Dir,
_ => return Err(vfs::FsError::InvalidParam), _ => return Err(vfs::FsError::InvalidParam),
}; };
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir); return Err(FsError::NotDir);
} }
@ -219,7 +221,7 @@ impl vfs::INode for INodeImpl {
Ok(inode) Ok(inode)
} }
fn unlink(&self, name: &str) -> vfs::Result<()> { fn unlink(&self, name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -254,7 +256,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn link(&self, name: &str, other: &Arc<INode>) -> vfs::Result<()> { fn link(&self, name: &str, other: &Arc<INode>) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -268,7 +270,7 @@ impl vfs::INode for INodeImpl {
if !Arc::ptr_eq(&self.fs, &child.fs) { if !Arc::ptr_eq(&self.fs, &child.fs) {
return Err(FsError::NotSameFs); return Err(FsError::NotSameFs);
} }
if child.info()?.type_ == vfs::FileType::Dir { if child.metadata()?.type_ == vfs::FileType::Dir {
return Err(FsError::IsDir); return Err(FsError::IsDir);
} }
let entry = DiskEntry { let entry = DiskEntry {
@ -280,7 +282,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn rename(&self, old_name: &str, new_name: &str) -> vfs::Result<()> { fn rename(&self, old_name: &str, new_name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -311,7 +313,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn move_(&self, old_name: &str, target: &Arc<INode>, new_name: &str) -> vfs::Result<()> { fn move_(&self, old_name: &str, target: &Arc<INode>, new_name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -329,10 +331,10 @@ impl vfs::INode for INodeImpl {
if !Arc::ptr_eq(&self.fs, &dest.fs) { if !Arc::ptr_eq(&self.fs, &dest.fs) {
return Err(FsError::NotSameFs); return Err(FsError::NotSameFs);
} }
if dest.info()?.type_ != vfs::FileType::Dir { if dest.metadata()?.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
if dest.info()?.nlinks <= 0 { if dest.metadata()?.nlinks <= 0 {
return Err(FsError::DirRemoved) return Err(FsError::DirRemoved)
} }
@ -350,7 +352,7 @@ impl vfs::INode for INodeImpl {
dest.dirent_append(&entry)?; dest.dirent_append(&entry)?;
self.dirent_remove(entry_id)?; self.dirent_remove(entry_id)?;
if inode.info()?.type_ == vfs::FileType::Dir { if inode.metadata()?.type_ == vfs::FileType::Dir {
self.nlinks_dec(); self.nlinks_dec();
dest.nlinks_inc(); dest.nlinks_inc();
} }
@ -358,7 +360,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn find(&self, name: &str) -> vfs::Result<Arc<vfs::INode>> { fn find(&self, name: &str) -> vfs::Result<Arc<vfs::INode>> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != vfs::FileType::Dir { if info.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -593,11 +595,18 @@ impl vfs::FileSystem for SEFS {
self.get_inode(BLKN_ROOT) self.get_inode(BLKN_ROOT)
} }
fn info(&self) -> &'static vfs::FsInfo { fn info(&self) -> vfs::FsInfo {
static INFO: vfs::FsInfo = vfs::FsInfo { let sb = self.super_block.read();
max_file_size: MAX_FILE_SIZE, vfs::FsInfo {
}; bsize: BLKSIZE,
&INFO frsize: BLKSIZE,
blocks: sb.blocks as usize,
bfree: sb.unused_blocks as usize,
bavail: sb.unused_blocks as usize,
files: sb.blocks as usize, // inaccurate
ffree: sb.unused_blocks as usize, // inaccurate
namemax: MAX_FNAME_LEN,
}
} }
} }

9
rcore-fs-sfs/src/bin/mksfs.rs
Unescape View File

@ -8,6 +8,8 @@ use std::sync::{Arc, Mutex};
use rcore_fs::vfs::*; use rcore_fs::vfs::*;
use rcore_fs_sfs::SimpleFileSystem; use rcore_fs_sfs::SimpleFileSystem;
const DEFAULT_MODE: u32 = 0o664;
fn main() -> Result<()> { fn main() -> Result<()> {
let args: Vec<_> = env::args().collect(); let args: Vec<_> = env::args().collect();
let cmd = &args[1]; let cmd = &args[1];
@ -41,7 +43,7 @@ fn zip_dir(path: &Path, inode: Arc<INode>) -> Result<()> {
let name = name_.to_str().unwrap(); let name = name_.to_str().unwrap();
let type_ = entry.file_type()?; let type_ = entry.file_type()?;
if type_.is_file() { if type_.is_file() {
let inode = inode.create(name, FileType::File).expect("Failed to create INode"); let inode = inode.create(name, FileType::File, DEFAULT_MODE).expect("Failed to create INode");
let mut file = fs::File::open(entry.path())?; let mut file = fs::File::open(entry.path())?;
inode.resize(file.metadata().unwrap().len() as usize).expect("Failed to resize INode"); inode.resize(file.metadata().unwrap().len() as usize).expect("Failed to resize INode");
let mut buf: [u8; 4096] = unsafe { uninitialized() }; let mut buf: [u8; 4096] = unsafe { uninitialized() };
@ -53,7 +55,7 @@ fn zip_dir(path: &Path, inode: Arc<INode>) -> Result<()> {
offset += len; offset += len;
} }
} else if type_.is_dir() { } else if type_.is_dir() {
let inode = inode.create(name, FileType::Dir).expect("Failed to create INode"); let inode = inode.create(name, FileType::Dir, DEFAULT_MODE).expect("Failed to create INode");
zip_dir(entry.path().as_path(), inode)?; zip_dir(entry.path().as_path(), inode)?;
} }
} }
@ -75,7 +77,7 @@ fn unzip_dir(path: &Path, inode: Arc<INode>) -> Result<()> {
let inode = inode.lookup(name.as_str()).expect("Failed to lookup"); let inode = inode.lookup(name.as_str()).expect("Failed to lookup");
let mut path = path.to_path_buf(); let mut path = path.to_path_buf();
path.push(name); path.push(name);
let info = inode.info().expect("Failed to get file info"); let info = inode.metadata().expect("Failed to get file info");
match info.type_ { match info.type_ {
FileType::File => { FileType::File => {
let mut file = fs::File::create(&path)?; let mut file = fs::File::create(&path)?;
@ -92,6 +94,7 @@ fn unzip_dir(path: &Path, inode: Arc<INode>) -> Result<()> {
fs::create_dir(&path)?; fs::create_dir(&path)?;
unzip_dir(path.as_path(), inode)?; unzip_dir(path.as_path(), inode)?;
} }
_ => panic!("unsupported file type"),
} }
} }
Ok(()) Ok(())

43
rcore-fs-sfs/src/lib.rs
Unescape View File

@ -276,9 +276,10 @@ impl vfs::INode for INodeImpl {
self._write_at(offset, buf) self._write_at(offset, buf)
} }
/// the size returned here is logical size(entry num for directory), not the disk space used. /// the size returned here is logical size(entry num for directory), not the disk space used.
fn info(&self) -> vfs::Result<vfs::FileInfo> { fn metadata(&self) -> vfs::Result<vfs::Metadata> {
let disk_inode = self.disk_inode.read(); let disk_inode = self.disk_inode.read();
Ok(vfs::FileInfo { Ok(vfs::Metadata {
dev: 0,
inode: self.id, inode: self.id,
size: match disk_inode.type_ { size: match disk_inode.type_ {
FileType::File => disk_inode.size as usize, FileType::File => disk_inode.size as usize,
@ -294,6 +295,7 @@ impl vfs::INode for INodeImpl {
nlinks: disk_inode.nlinks as usize, nlinks: disk_inode.nlinks as usize,
uid: 0, uid: 0,
gid: 0, gid: 0,
blk_size: BLKSIZE,
}) })
} }
fn sync(&self) -> vfs::Result<()> { fn sync(&self) -> vfs::Result<()> {
@ -311,7 +313,7 @@ impl vfs::INode for INodeImpl {
self._resize(len) self._resize(len)
} }
fn create(&self, name: &str, type_: vfs::FileType, _mode: u32) -> vfs::Result<Arc<vfs::INode>> { fn create(&self, name: &str, type_: vfs::FileType, _mode: u32) -> vfs::Result<Arc<vfs::INode>> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir); return Err(FsError::NotDir);
} }
@ -348,7 +350,7 @@ impl vfs::INode for INodeImpl {
Ok(inode) Ok(inode)
} }
fn unlink(&self, name: &str) -> vfs::Result<()> { fn unlink(&self, name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -383,7 +385,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn link(&self, name: &str, other: &Arc<INode>) -> vfs::Result<()> { fn link(&self, name: &str, other: &Arc<INode>) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -397,7 +399,7 @@ impl vfs::INode for INodeImpl {
if !Arc::ptr_eq(&self.fs, &child.fs) { if !Arc::ptr_eq(&self.fs, &child.fs) {
return Err(FsError::NotSameFs); return Err(FsError::NotSameFs);
} }
if child.info()?.type_ == vfs::FileType::Dir { if child.metadata()?.type_ == vfs::FileType::Dir {
return Err(FsError::IsDir); return Err(FsError::IsDir);
} }
let entry = DiskEntry { let entry = DiskEntry {
@ -411,7 +413,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn rename(&self, old_name: &str, new_name: &str) -> vfs::Result<()> { fn rename(&self, old_name: &str, new_name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -441,7 +443,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn move_(&self, old_name: &str, target: &Arc<INode>, new_name: &str) -> vfs::Result<()> { fn move_(&self, old_name: &str, target: &Arc<INode>, new_name: &str) -> vfs::Result<()> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -459,10 +461,10 @@ impl vfs::INode for INodeImpl {
if !Arc::ptr_eq(&self.fs, &dest.fs) { if !Arc::ptr_eq(&self.fs, &dest.fs) {
return Err(FsError::NotSameFs); return Err(FsError::NotSameFs);
} }
if dest.info()?.type_ != vfs::FileType::Dir { if dest.metadata()?.type_ != vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
if dest.info()?.nlinks <= 0 { if dest.metadata()?.nlinks <= 0 {
return Err(FsError::DirRemoved) return Err(FsError::DirRemoved)
} }
@ -483,7 +485,7 @@ impl vfs::INode for INodeImpl {
self.remove_dirent_page(entry_id)?; self.remove_dirent_page(entry_id)?;
if inode.info()?.type_ == vfs::FileType::Dir { if inode.metadata()?.type_ == vfs::FileType::Dir {
self.nlinks_dec(); self.nlinks_dec();
dest.nlinks_inc(); dest.nlinks_inc();
} }
@ -491,7 +493,7 @@ impl vfs::INode for INodeImpl {
Ok(()) Ok(())
} }
fn find(&self, name: &str) -> vfs::Result<Arc<vfs::INode>> { fn find(&self, name: &str) -> vfs::Result<Arc<vfs::INode>> {
let info = self.info()?; let info = self.metadata()?;
if info.type_!=vfs::FileType::Dir { if info.type_!=vfs::FileType::Dir {
return Err(FsError::NotDir) return Err(FsError::NotDir)
} }
@ -716,11 +718,18 @@ impl vfs::FileSystem for SimpleFileSystem {
self.get_inode(BLKN_ROOT) self.get_inode(BLKN_ROOT)
} }
fn info(&self) -> &'static vfs::FsInfo { fn info(&self) -> vfs::FsInfo {
static INFO: vfs::FsInfo = vfs::FsInfo { let sb = self.super_block.read();
max_file_size: MAX_FILE_SIZE, vfs::FsInfo {
}; bsize: BLKSIZE,
&INFO frsize: BLKSIZE,
blocks: sb.blocks as usize,
bfree: sb.unused_blocks as usize,
bavail: sb.unused_blocks as usize,
files: sb.blocks as usize, // inaccurate
ffree: sb.unused_blocks as usize, // inaccurate
namemax: MAX_FNAME_LEN,
}
} }
} }

6
rcore-fs/src/file.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::vfs::{INode, Result, FileInfo}; use crate::vfs::{INode, Result, Metadata};
use alloc::{sync::Arc, string::String}; use alloc::{sync::Arc, string::String};
pub struct File { pub struct File {
@ -27,8 +27,8 @@ impl File {
Ok(len) Ok(len)
} }
pub fn info(&self) -> Result<FileInfo> { pub fn info(&self) -> Result<Metadata> {
self.inode.info() self.inode.metadata()
} }
pub fn get_entry(&self, id: usize) -> Result<String> { pub fn get_entry(&self, id: usize) -> Result<String> {

2
rcore-fs/src/tests.rs
Unescape View File

@ -38,7 +38,7 @@ fn create_file() -> Result<()> {
let root = sfs.root_inode(); let root = sfs.root_inode();
let file1 = root.create("file1", FileType::File)?; let file1 = root.create("file1", FileType::File)?;
assert_eq!(file1.info()?, FileInfo { assert_eq!(file1.info()?, Metadata {
inode: 5, inode: 5,
size: 0, size: 0,
type_: FileType::File, type_: FileType::File,

46
rcore-fs/src/vfs.rs
Unescape View File

@ -6,7 +6,7 @@ use core::result;
pub trait INode: Any + Sync + Send { pub trait INode: Any + Sync + Send {
fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize>; fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize>;
fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize>; fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize>;
fn info(&self) -> Result<FileInfo>; fn metadata(&self) -> Result<Metadata>;
fn sync(&self) -> Result<()>; fn sync(&self) -> Result<()>;
fn resize(&self, len: usize) -> Result<()>; fn resize(&self, len: usize) -> Result<()>;
fn create(&self, name: &str, type_: FileType, mode: u32) -> Result<Arc<INode>>; fn create(&self, name: &str, type_: FileType, mode: u32) -> Result<Arc<INode>>;
@ -33,7 +33,7 @@ impl INode {
self.as_any_ref().downcast_ref::<T>() self.as_any_ref().downcast_ref::<T>()
} }
pub fn list(&self) -> Result<Vec<String>> { pub fn list(&self) -> Result<Vec<String>> {
let info = self.info()?; let info = self.metadata()?;
if info.type_ != FileType::Dir { if info.type_ != FileType::Dir {
return Err(FsError::NotDir); return Err(FsError::NotDir);
} }
@ -42,13 +42,13 @@ impl INode {
}).collect() }).collect()
} }
pub fn lookup(&self, path: &str) -> Result<Arc<INode>> { pub fn lookup(&self, path: &str) -> Result<Arc<INode>> {
if self.info()?.type_ != FileType::Dir { if self.metadata()?.type_ != FileType::Dir {
return Err(FsError::NotDir); return Err(FsError::NotDir);
} }
let mut result = self.find(".")?; let mut result = self.find(".")?;
let mut rest_path = path; let mut rest_path = path;
while rest_path != "" { while rest_path != "" {
if result.info()?.type_!= FileType::Dir { if result.metadata()?.type_!= FileType::Dir {
return Err(FsError::NotDir); return Err(FsError::NotDir);
} }
let name; let name;
@ -71,8 +71,13 @@ impl INode {
} }
} }
/// Metadata of INode
///
/// Ref: [http://pubs.opengroup.org/onlinepubs/009604499/basedefs/sys/stat.h.html]
#[derive(Debug, Eq, PartialEq)] #[derive(Debug, Eq, PartialEq)]
pub struct FileInfo { pub struct Metadata {
/// Device ID
pub dev: usize,
/// Inode number /// Inode number
pub inode: usize, pub inode: usize,
/// Size in bytes /// Size in bytes
@ -80,6 +85,9 @@ pub struct FileInfo {
/// SFS Note: for normal file size is the actuate file size /// SFS Note: for normal file size is the actuate file size
/// for directory this is count of dirent. /// for directory this is count of dirent.
pub size: usize, pub size: usize,
/// A file system-specific preferred I/O block size for this object.
/// In some file system types, this may vary from file to file.
pub blk_size: usize,
/// Size in blocks /// Size in blocks
pub blocks: usize, pub blocks: usize,
/// Time of last access /// Time of last access
@ -97,9 +105,9 @@ pub struct FileInfo {
/// SFS Note: different from linux, "." and ".." count in nlinks /// SFS Note: different from linux, "." and ".." count in nlinks
/// this is same as original ucore. /// this is same as original ucore.
pub nlinks: usize, pub nlinks: usize,
/// User id /// User ID
pub uid: usize, pub uid: usize,
/// Group id /// Group ID
pub gid: usize, pub gid: usize,
} }
@ -116,11 +124,31 @@ pub enum FileType {
SymLink, SymLink,
CharDevice, CharDevice,
BlockDevice, BlockDevice,
NamedPipe,
Socket,
} }
/// Metadata of FileSystem
///
/// Ref: [http://pubs.opengroup.org/onlinepubs/9699919799/]
#[derive(Debug)] #[derive(Debug)]
pub struct FsInfo { pub struct FsInfo {
pub max_file_size: usize, /// File system block size
pub bsize: usize,
/// Fundamental file system block size
pub frsize: usize,
/// Total number of blocks on file system in units of `frsize`
pub blocks: usize,
/// Total number of free blocks
pub bfree: usize,
/// Number of free blocks available to non-privileged process
pub bavail: usize,
/// Total number of file serial numbers
pub files: usize,
/// Total number of free file serial numbers
pub ffree: usize,
/// Maximum filename length
pub namemax: usize,
} }
// Note: IOError/NoMemory always lead to a panic since it's hard to recover from it. // Note: IOError/NoMemory always lead to a panic since it's hard to recover from it.
@ -148,5 +176,5 @@ pub type Result<T> = result::Result<T,FsError>;
pub trait FileSystem: Sync { pub trait FileSystem: Sync {
fn sync(&self) -> Result<()>; fn sync(&self) -> Result<()>;
fn root_inode(&self) -> Arc<INode>; fn root_inode(&self) -> Arc<INode>;
fn info(&self) -> &'static FsInfo; fn info(&self) -> FsInfo;
} }

Write Preview
Loading…
Cancel
Save