diff --git a/Cargo.toml b/Cargo.toml index 7a981fb..55440d9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ required-features = ["std"] [dependencies] bit-vec = { default-features = false, git = "https://github.com/AltSysrq/bit-vec.git" } # default-features contains 'std' static_assertions = "0.2.5" +spin = "0.4" [features] debug_print = [] diff --git a/src/lib.rs b/src/lib.rs index 728e46b..1be886b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,7 @@ extern crate alloc; extern crate bit_vec; #[macro_use] extern crate static_assertions; +extern crate spin; #[cfg(not(test))] macro_rules! eprintln { diff --git a/src/sfs.rs b/src/sfs.rs index 87824e0..b442e60 100644 --- a/src/sfs.rs +++ b/src/sfs.rs @@ -1,28 +1,28 @@ use bit_vec::BitVec; -use alloc::{boxed::Box, vec::Vec, collections::BTreeMap, rc::{Rc, Weak}, string::String}; -use core::cell::{RefCell, RefMut}; +use alloc::{boxed::Box, vec::Vec, collections::BTreeMap, sync::{Arc, Weak}, string::String}; use core::mem::{uninitialized, size_of}; use core::slice; use core::fmt::{Debug, Formatter, Error}; use core::any::Any; use dirty::Dirty; use structs::*; -use vfs::{self, Device}; +use vfs::{self, Device, INode, FileSystem}; use util::*; +use spin::{Mutex, RwLock}; impl Device { fn read_block(&mut self, id: BlockId, offset: usize, buf: &mut [u8]) -> vfs::Result<()> { debug_assert!(offset + buf.len() <= BLKSIZE); match self.read_at(id * BLKSIZE + offset, buf) { Some(len) if len == buf.len() => Ok(()), - _ => Err(()), + _ => panic!(), } } fn write_block(&mut self, id: BlockId, offset: usize, buf: &[u8]) -> vfs::Result<()> { debug_assert!(offset + buf.len() <= BLKSIZE); match self.write_at(id * BLKSIZE + offset, buf) { Some(len) if len == buf.len() => Ok(()), - _ => Err(()), + _ => panic!(), } } /// Load struct `T` from given block in device @@ -33,61 +33,58 @@ impl Device { } } -type Ptr = Rc>; - /// inode for sfs -pub struct INode { - /// on-disk inode - disk_inode: Dirty, +pub struct INodeImpl { /// inode number id: INodeId, + /// on-disk inode + disk_inode: RwLock>, /// Weak reference to SFS, used by almost all operations - fs: Weak, + fs: Arc, } -impl Debug for INode { +impl Debug for INodeImpl { fn fmt(&self, f: &mut Formatter) -> Result<(), Error> { write!(f, "INode {{ id: {}, disk: {:?} }}", self.id, self.disk_inode) } } -impl INode { +impl INodeImpl { /// Map file block id to disk block id - fn get_disk_block_id(&self, file_block_id: BlockId) -> Option { + fn get_disk_block_id(&self, file_block_id: BlockId) -> vfs::Result { + let disk_inode = self.disk_inode.read(); match file_block_id { - id if id >= self.disk_inode.blocks as BlockId => - None, + id if id >= disk_inode.blocks as BlockId => + panic!(), id if id < NDIRECT => - Some(self.disk_inode.direct[id] as BlockId), + Ok(disk_inode.direct[id] as BlockId), id if id < NDIRECT + BLK_NENTRY => { let mut disk_block_id: u32 = 0; - let fs = self.fs.upgrade().unwrap(); - fs.device.borrow_mut().read_block( - self.disk_inode.indirect as usize, + self.fs.device.lock().read_block( + disk_inode.indirect as usize, ENTRY_SIZE * (id - NDIRECT), disk_block_id.as_buf_mut(), - ).unwrap(); - Some(disk_block_id as BlockId) + )?; + Ok(disk_block_id as BlockId) } _ => unimplemented!("double indirect blocks is not supported"), } } - fn set_disk_block_id(&mut self, file_block_id: BlockId, disk_block_id: BlockId) -> vfs::Result<()> { + fn set_disk_block_id(&self, file_block_id: BlockId, disk_block_id: BlockId) -> vfs::Result<()> { match file_block_id { - id if id >= self.disk_inode.blocks as BlockId => - Err(()), + id if id >= self.disk_inode.read().blocks as BlockId => + panic!(), id if id < NDIRECT => { - self.disk_inode.direct[id] = disk_block_id as u32; + self.disk_inode.write().direct[id] = disk_block_id as u32; Ok(()) } id if id < NDIRECT + BLK_NENTRY => { let disk_block_id = disk_block_id as u32; - let fs = self.fs.upgrade().unwrap(); - fs.device.borrow_mut().write_block( - self.disk_inode.indirect as usize, + self.fs.device.lock().write_block( + self.disk_inode.read().indirect as usize, ENTRY_SIZE * (id - NDIRECT), disk_block_id.as_buf(), - ).unwrap(); + )?; Ok(()) } _ => unimplemented!("double indirect blocks is not supported"), @@ -95,9 +92,8 @@ impl INode { } /// Only for Dir fn get_file_inode_and_entry_id(&self, name: &str) -> Option<(INodeId, usize)> { - (0..self.disk_inode.blocks) + (0..self.disk_inode.read().blocks) .map(|i| { - use vfs::INode; let mut entry: DiskEntry = unsafe { uninitialized() }; self._read_at(i as usize * BLKSIZE, entry.as_buf_mut()).unwrap(); (entry, i) @@ -110,54 +106,53 @@ impl INode { } /// Init dir content. Insert 2 init entries. /// This do not init nlinks, please modify the nlinks in the invoker. - fn init_dir_entry(&mut self, parent: INodeId) -> vfs::Result<()> { - use vfs::INode; - let fs = self.fs.upgrade().unwrap(); + fn init_dir_entry(&self, parent: INodeId) -> vfs::Result<()> { // Insert entries: '.' '..' - self._resize(BLKSIZE * 2).unwrap(); + self._resize(BLKSIZE * 2)?; self._write_at(BLKSIZE * 1, DiskEntry { id: parent as u32, name: Str256::from(".."), - }.as_buf()).unwrap(); + }.as_buf())?; self._write_at(BLKSIZE * 0, DiskEntry { id: self.id as u32, name: Str256::from("."), - }.as_buf()).unwrap(); + }.as_buf())?; Ok(()) } /// remove a page in middle of file and insert the last page here, useful for dirent remove /// should be only used in unlink - fn remove_dirent_page(&mut self, id: usize) -> vfs::Result<()> { - assert!(id < self.disk_inode.blocks as usize); - let fs = self.fs.upgrade().unwrap(); + fn remove_dirent_page(&self, id: usize) -> vfs::Result<()> { + assert!(id < self.disk_inode.read().blocks as usize); let to_remove = self.get_disk_block_id(id).unwrap(); - let current_last = self.get_disk_block_id(self.disk_inode.blocks as usize - 1).unwrap(); + let current_last = self.get_disk_block_id(self.disk_inode.read().blocks as usize - 1).unwrap(); self.set_disk_block_id(id, current_last).unwrap(); - self.disk_inode.blocks -= 1; - let new_size = self.disk_inode.blocks as usize * BLKSIZE; + self.disk_inode.write().blocks -= 1; + let new_size = self.disk_inode.read().blocks as usize * BLKSIZE; self._set_size(new_size); - fs.free_block(to_remove); + self.fs.free_block(to_remove); Ok(()) } /// Resize content size, no matter what type it is. - fn _resize(&mut self, len: usize) -> vfs::Result<()> { + fn _resize(&self, len: usize) -> vfs::Result<()> { assert!(len <= MAX_FILE_SIZE, "file size exceed limit"); let blocks = ((len + BLKSIZE - 1) / BLKSIZE) as u32; use core::cmp::{Ord, Ordering}; - match blocks.cmp(&self.disk_inode.blocks) { + let old_blocks = self.disk_inode.read().blocks; + match blocks.cmp(&old_blocks) { Ordering::Equal => {} // Do nothing Ordering::Greater => { - let fs = self.fs.upgrade().unwrap(); - let old_blocks = self.disk_inode.blocks; - self.disk_inode.blocks = blocks; - // allocate indirect block if need - if old_blocks < NDIRECT as u32 && blocks >= NDIRECT as u32 { - self.disk_inode.indirect = fs.alloc_block().unwrap() as u32; + { + let mut disk_inode = self.disk_inode.write(); + disk_inode.blocks = blocks; + // allocate indirect block if need + if old_blocks < NDIRECT as u32 && blocks >= NDIRECT as u32 { + disk_inode.indirect = self.fs.alloc_block().unwrap() as u32; + } } // allocate extra blocks for i in old_blocks..blocks { - let disk_block_id = fs.alloc_block().expect("no more space"); - self.set_disk_block_id(i as usize, disk_block_id).unwrap(); + let disk_block_id = self.fs.alloc_block().expect("no more space"); + self.set_disk_block_id(i as usize, disk_block_id)?; } // clean up let old_size = self._size(); @@ -165,18 +160,18 @@ impl INode { self._clean_at(old_size, len).unwrap(); } Ordering::Less => { - let fs = self.fs.upgrade().unwrap(); // free extra blocks - for i in blocks..self.disk_inode.blocks { + for i in blocks..old_blocks { let disk_block_id = self.get_disk_block_id(i as usize).unwrap(); - fs.free_block(disk_block_id); + self.fs.free_block(disk_block_id); } + let mut disk_inode = self.disk_inode.write(); // free indirect block if need - if blocks < NDIRECT as u32 && self.disk_inode.blocks >= NDIRECT as u32 { - fs.free_block(self.disk_inode.indirect as usize); - self.disk_inode.indirect = 0; + if blocks < NDIRECT as u32 && disk_inode.blocks >= NDIRECT as u32 { + self.fs.free_block(disk_inode.indirect as usize); + disk_inode.indirect = 0; } - self.disk_inode.blocks = blocks; + disk_inode.blocks = blocks; } } self._set_size(len); @@ -185,27 +180,27 @@ impl INode { /// Get the actual size of this inode, /// since size in inode for dir is not real size fn _size(&self) -> usize { - match self.disk_inode.type_ { - FileType::Dir => self.disk_inode.blocks as usize * BLKSIZE, - FileType::File => self.disk_inode.size as usize, + let disk_inode = self.disk_inode.read(); + match disk_inode.type_ { + FileType::Dir => disk_inode.blocks as usize * BLKSIZE, + FileType::File => disk_inode.size as usize, _ => unimplemented!(), } } /// Set the ucore compat size of this inode, /// Size in inode for dir is size of entries - fn _set_size(&mut self, len: usize) { - self.disk_inode.size = match self.disk_inode.type_ { - FileType::Dir => self.disk_inode.blocks as usize * DIRENT_SIZE, + fn _set_size(&self, len: usize) { + let mut disk_inode = self.disk_inode.write(); + disk_inode.size = match disk_inode.type_ { + FileType::Dir => disk_inode.blocks as usize * DIRENT_SIZE, FileType::File => len, _ => unimplemented!(), } as u32 } /// Read/Write content, no matter what type it is fn _io_at(&self, begin: usize, end: usize, mut f: F) -> vfs::Result - where F: FnMut(RefMut>, &BlockRange, usize) + where F: FnMut(&mut Box, &BlockRange, usize) { - let fs = self.fs.upgrade().unwrap(); - let size = self._size(); let iter = BlockIter { begin: size.min(begin), @@ -217,85 +212,86 @@ impl INode { let mut buf_offset = 0usize; for mut range in iter { range.block = self.get_disk_block_id(range.block).unwrap(); - f(fs.device.borrow_mut(), &range, buf_offset); + f(&mut *self.fs.device.lock(), &range, buf_offset); buf_offset += range.len(); } Ok(buf_offset) } /// Read content, no matter what type it is fn _read_at(&self, offset: usize, buf: &mut [u8]) -> vfs::Result { - self._io_at(offset, offset + buf.len(), |mut device, range, offset| { + self._io_at(offset, offset + buf.len(), |device, range, offset| { device.read_block(range.block, range.begin, &mut buf[offset..offset + range.len()]).unwrap() }) } /// Write content, no matter what type it is fn _write_at(&self, offset: usize, buf: &[u8]) -> vfs::Result { - self._io_at(offset, offset + buf.len(), |mut device, range, offset| { + self._io_at(offset, offset + buf.len(), |device, range, offset| { device.write_block(range.block, range.begin, &buf[offset..offset + range.len()]).unwrap() }) } /// Clean content, no matter what type it is fn _clean_at(&self, begin: usize, end: usize) -> vfs::Result<()> { static ZEROS: [u8; BLKSIZE] = [0; BLKSIZE]; - self._io_at(begin, end, |mut device, range, _| { + self._io_at(begin, end, |device, range, _| { device.write_block(range.block, range.begin, &ZEROS[..range.len()]).unwrap() }).unwrap(); Ok(()) } - fn nlinks_inc(&mut self) { - self.disk_inode.nlinks += 1; + fn nlinks_inc(&self) { + self.disk_inode.write().nlinks += 1; } - fn nlinks_dec(&mut self) { - assert!(self.disk_inode.nlinks > 0); - self.disk_inode.nlinks -= 1; + fn nlinks_dec(&self) { + let mut disk_inode = self.disk_inode.write(); + assert!(disk_inode.nlinks > 0); + disk_inode.nlinks -= 1; } } -impl vfs::INode for INode { - fn open(&mut self, flags: u32) -> vfs::Result<()> { +impl vfs::INode for INodeImpl { + fn open(&self, flags: u32) -> vfs::Result<()> { // Do nothing Ok(()) } - fn close(&mut self) -> vfs::Result<()> { + fn close(&self) -> vfs::Result<()> { self.sync() } fn read_at(&self, offset: usize, buf: &mut [u8]) -> vfs::Result { - assert_eq!(self.disk_inode.type_, FileType::File, "read_at is only available on file"); + assert_eq!(self.disk_inode.read().type_, FileType::File, "read_at is only available on file"); self._read_at(offset, buf) } fn write_at(&self, offset: usize, buf: &[u8]) -> vfs::Result { - assert_eq!(self.disk_inode.type_, FileType::File, "write_at is only available on file"); + assert_eq!(self.disk_inode.read().type_, FileType::File, "write_at is only available on file"); self._write_at(offset, buf) } /// the size returned here is logical size(entry num for directory), not the disk space used. fn info(&self) -> vfs::Result { + let disk_inode = self.disk_inode.read(); Ok(vfs::FileInfo { - size: match self.disk_inode.type_ { - FileType::File => self.disk_inode.size as usize, - FileType::Dir => self.disk_inode.blocks as usize, + size: match disk_inode.type_ { + FileType::File => disk_inode.size as usize, + FileType::Dir => disk_inode.blocks as usize, _ => unimplemented!(), }, mode: 0, - type_: vfs::FileType::from(self.disk_inode.type_.clone()), - blocks: self.disk_inode.blocks as usize, - nlinks: self.disk_inode.nlinks as usize, + type_: vfs::FileType::from(disk_inode.type_.clone()), + blocks: disk_inode.blocks as usize, + nlinks: disk_inode.nlinks as usize, }) } - fn sync(&mut self) -> vfs::Result<()> { - if self.disk_inode.dirty() { - let fs = self.fs.upgrade().unwrap(); - fs.device.borrow_mut().write_block(self.id, 0, self.disk_inode.as_buf()).unwrap(); - self.disk_inode.sync(); + fn sync(&self) -> vfs::Result<()> { + let mut disk_inode = self.disk_inode.write(); + if disk_inode.dirty() { + self.fs.device.lock().write_block(self.id, 0, disk_inode.as_buf()).unwrap(); + disk_inode.sync(); } Ok(()) } - fn resize(&mut self, len: usize) -> vfs::Result<()> { - assert_eq!(self.disk_inode.type_, FileType::File, "resize is only available on file"); + fn resize(&self, len: usize) -> vfs::Result<()> { + assert_eq!(self.disk_inode.read().type_, FileType::File, "resize is only available on file"); self._resize(len) } - fn create(&mut self, name: &str, type_: vfs::FileType) -> vfs::Result> { - let fs = self.fs.upgrade().unwrap(); - let info = self.info().unwrap(); + fn create(&self, name: &str, type_: vfs::FileType) -> vfs::Result> { + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); assert!(info.nlinks > 0); @@ -304,63 +300,57 @@ impl vfs::INode for INode { // Create new INode let inode = match type_ { - vfs::FileType::File => fs.new_inode_file().unwrap(), - vfs::FileType::Dir => fs.new_inode_dir(self.id).unwrap(), + vfs::FileType::File => self.fs.new_inode_file().unwrap(), + vfs::FileType::Dir => self.fs.new_inode_dir(self.id).unwrap(), }; // Write new entry let entry = DiskEntry { - id: inode.borrow().id as u32, + id: inode.id as u32, name: Str256::from(name), }; let old_size = self._size(); self._resize(old_size + BLKSIZE).unwrap(); self._write_at(old_size, entry.as_buf()).unwrap(); - inode.borrow_mut().nlinks_inc(); + inode.nlinks_inc(); if type_ == vfs::FileType::Dir { - inode.borrow_mut().nlinks_inc();//for . - self.nlinks_inc();//for .. + inode.nlinks_inc(); //for . + self.nlinks_inc(); //for .. } Ok(inode) } - fn unlink(&mut self, name: &str) -> vfs::Result<()> { + fn unlink(&self, name: &str) -> vfs::Result<()> { assert!(name != "."); assert!(name != ".."); - let fs = self.fs.upgrade().unwrap(); - let info = self.info().unwrap(); + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); - let inode_and_entry_id = self.get_file_inode_and_entry_id(name); - if inode_and_entry_id.is_none() { - return Err(()); - } - let (inode_id, entry_id) = inode_and_entry_id.unwrap(); - let inode = fs.get_inode(inode_id); + let (inode_id, entry_id) = self.get_file_inode_and_entry_id(name).ok_or(())?; + let inode = self.fs.get_inode(inode_id); - let type_ = inode.borrow().disk_inode.type_; + let type_ = inode.disk_inode.read().type_; if type_ == FileType::Dir { // only . and .. - assert_eq!(inode.borrow().disk_inode.blocks, 2); + assert_eq!(inode.disk_inode.read().blocks, 2); } - inode.borrow_mut().nlinks_dec(); + inode.nlinks_dec(); if type_ == FileType::Dir { - inode.borrow_mut().nlinks_dec();//for . - self.nlinks_dec();//for .. + inode.nlinks_dec(); //for . + self.nlinks_dec(); //for .. } self.remove_dirent_page(entry_id); Ok(()) } - fn link(&mut self, name: &str, other: &mut vfs::INode) -> vfs::Result<()> { - let fs = self.fs.upgrade().unwrap(); - let info = self.info().unwrap(); + fn link(&self, name: &str, other: &Arc) -> vfs::Result<()> { + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); assert!(info.nlinks > 0); assert!(self.get_file_inode_id(name).is_none(), "file name exist"); - let child = other.downcast_mut::().unwrap(); - assert!(Rc::ptr_eq(&fs, &child.fs.upgrade().unwrap())); - assert!(child.info().unwrap().type_ != vfs::FileType::Dir); + let child = other.downcast_ref::().unwrap(); + assert!(Arc::ptr_eq(&self.fs, &child.fs)); + assert!(child.info()?.type_ != vfs::FileType::Dir); let entry = DiskEntry { id: child.id as u32, name: Str256::from(name), @@ -371,18 +361,14 @@ impl vfs::INode for INode { child.nlinks_inc(); Ok(()) } - fn rename(&mut self, old_name: &str, new_name: &str) -> vfs::Result<()> { - let info = self.info().unwrap(); + fn rename(&self, old_name: &str, new_name: &str) -> vfs::Result<()> { + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); assert!(info.nlinks > 0); assert!(self.get_file_inode_id(new_name).is_none(), "file name exist"); - let inode_and_entry_id = self.get_file_inode_and_entry_id(old_name); - if inode_and_entry_id.is_none() { - return Err(()); - } - let (_, entry_id) = inode_and_entry_id.unwrap(); + let (_, entry_id) = self.get_file_inode_and_entry_id(old_name).ok_or(())?; // in place modify name let mut entry: DiskEntry = unsafe { uninitialized() }; @@ -393,24 +379,19 @@ impl vfs::INode for INode { Ok(()) } - fn move_(&mut self, old_name: &str, target: &mut vfs::INode, new_name: &str) -> vfs::Result<()> { - let fs = self.fs.upgrade().unwrap(); - let info = self.info().unwrap(); + fn move_(&self, old_name: &str, target: &Arc, new_name: &str) -> vfs::Result<()> { + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); assert!(info.nlinks > 0); - let dest = target.downcast_mut::().unwrap(); - assert!(Rc::ptr_eq(&fs, &dest.fs.upgrade().unwrap())); - assert!(dest.info().unwrap().type_ == vfs::FileType::Dir); - assert!(dest.info().unwrap().nlinks > 0); + let dest = target.downcast_ref::().unwrap(); + assert!(Arc::ptr_eq(&self.fs, &dest.fs)); + assert!(dest.info()?.type_ == vfs::FileType::Dir); + assert!(dest.info()?.nlinks > 0); assert!(dest.get_file_inode_id(new_name).is_none(), "file name exist"); - let inode_and_entry_id = self.get_file_inode_and_entry_id(old_name); - if inode_and_entry_id.is_none() { - return Err(()); - } - let (inode_id, entry_id) = inode_and_entry_id.unwrap(); - let inode = fs.get_inode(inode_id); + let (inode_id, entry_id) = self.get_file_inode_and_entry_id(old_name).ok_or(())?; + let inode = self.fs.get_inode(inode_id); let entry = DiskEntry { id: inode_id as u32, @@ -422,53 +403,42 @@ impl vfs::INode for INode { self.remove_dirent_page(entry_id); - if inode.borrow().info().unwrap().type_ == vfs::FileType::Dir { + if inode.info()?.type_ == vfs::FileType::Dir { self.nlinks_dec(); dest.nlinks_inc(); } Ok(()) } - fn find(&self, name: &str) -> vfs::Result> { - let fs = self.fs.upgrade().unwrap(); - let info = self.info().unwrap(); + fn find(&self, name: &str) -> vfs::Result> { + let info = self.info()?; assert_eq!(info.type_, vfs::FileType::Dir); - let inode_id = self.get_file_inode_id(name); - if inode_id.is_none() { - return Err(()); - } - let inode = fs.get_inode(inode_id.unwrap()); - Ok(inode) + let inode_id = self.get_file_inode_id(name).ok_or(())?; + Ok(self.fs.get_inode(inode_id)) } fn get_entry(&self, id: usize) -> vfs::Result { - assert_eq!(self.disk_inode.type_, FileType::Dir); - assert!(id < self.disk_inode.blocks as usize); - use vfs::INode; + assert_eq!(self.disk_inode.read().type_, FileType::Dir); + assert!(id < self.disk_inode.read().blocks as usize); let mut entry: DiskEntry = unsafe { uninitialized() }; self._read_at(id as usize * BLKSIZE, entry.as_buf_mut()).unwrap(); Ok(String::from(entry.name.as_ref())) } - fn fs(&self) -> Weak { + fn fs(&self) -> Arc { self.fs.clone() } fn as_any_ref(&self) -> &Any { self } - fn as_any_mut(&mut self) -> &mut Any { - self - } } -impl Drop for INode { +impl Drop for INodeImpl { /// Auto sync when drop fn drop(&mut self) { - use vfs::INode; self.sync().expect("failed to sync"); - if self.disk_inode.nlinks <= 0 { - let fs = self.fs.upgrade().unwrap(); + if self.disk_inode.read().nlinks <= 0 { self._resize(0); - self.disk_inode.sync(); - fs.free_block(self.id); + self.disk_inode.write().sync(); + self.fs.free_block(self.id); } } } @@ -478,24 +448,24 @@ impl Drop for INode { /// /// ## 内部可变性 /// 为了方便协调外部及INode对SFS的访问，并为日后并行化做准备， -/// 将SFS设置为内部可变，即对外接口全部是&self，struct的全部field用RefCell包起来 +/// 将SFS设置为内部可变，即对外接口全部是&self，struct的全部field用RwLock包起来 /// 这样其内部各field均可独立访问 pub struct SimpleFileSystem { /// on-disk superblock - super_block: RefCell>, + super_block: RwLock>, /// blocks in use are mared 0 - free_map: RefCell>, + free_map: RwLock>, /// inode list - inodes: RefCell>>, + inodes: RwLock>>, /// device - device: RefCell>, + device: Mutex>, /// Pointer to self, used by INodes self_ptr: Weak, } impl SimpleFileSystem { /// Load SFS from device - pub fn open(mut device: Box) -> Option> { + pub fn open(mut device: Box) -> Option> { let super_block = device.load_struct::(BLKN_SUPER); if super_block.check() == false { return None; @@ -503,15 +473,15 @@ impl SimpleFileSystem { let free_map = device.load_struct::<[u8; BLKSIZE]>(BLKN_FREEMAP); Some(SimpleFileSystem { - super_block: RefCell::new(Dirty::new(super_block)), - free_map: RefCell::new(Dirty::new(BitVec::from_bytes(&free_map))), - inodes: RefCell::new(BTreeMap::>::new()), - device: RefCell::new(device), + super_block: RwLock::new(Dirty::new(super_block)), + free_map: RwLock::new(Dirty::new(BitVec::from_bytes(&free_map))), + inodes: RwLock::new(BTreeMap::new()), + device: Mutex::new(device), self_ptr: Weak::default(), }.wrap()) } /// Create a new SFS on blank disk - pub fn create(mut device: Box, space: usize) -> Rc { + pub fn create(mut device: Box, space: usize) -> Arc { let blocks = (space / BLKSIZE).min(BLKBITS); assert!(blocks >= 16, "space too small"); @@ -530,102 +500,105 @@ impl SimpleFileSystem { }; let sfs = SimpleFileSystem { - super_block: RefCell::new(Dirty::new_dirty(super_block)), - free_map: RefCell::new(Dirty::new_dirty(free_map)), - inodes: RefCell::new(BTreeMap::new()), - device: RefCell::new(device), + super_block: RwLock::new(Dirty::new_dirty(super_block)), + free_map: RwLock::new(Dirty::new_dirty(free_map)), + inodes: RwLock::new(BTreeMap::new()), + device: Mutex::new(device), self_ptr: Weak::default(), }.wrap(); // Init root INode - use vfs::INode; let root = sfs._new_inode(BLKN_ROOT, Dirty::new_dirty(DiskINode::new_dir())); - root.borrow_mut().init_dir_entry(BLKN_ROOT).unwrap(); - root.borrow_mut().nlinks_inc();//for . - root.borrow_mut().nlinks_inc();//for ..(root's parent is itself) - root.borrow_mut().sync().unwrap(); + root.init_dir_entry(BLKN_ROOT).unwrap(); + root.nlinks_inc(); //for . + root.nlinks_inc(); //for ..(root's parent is itself) + root.sync().unwrap(); sfs } - /// Wrap pure SimpleFileSystem with Rc + /// Wrap pure SimpleFileSystem with Arc /// Used in constructors - fn wrap(self) -> Rc { - // Create a Rc, make a Weak from it, then put it into the struct. + fn wrap(self) -> Arc { + // Create a Arc, make a Weak from it, then put it into the struct. // It's a little tricky. - let fs = Rc::new(self); - let weak = Rc::downgrade(&fs); - let ptr = Rc::into_raw(fs) as *mut Self; + let fs = Arc::new(self); + let weak = Arc::downgrade(&fs); + let ptr = Arc::into_raw(fs) as *mut Self; unsafe { (*ptr).self_ptr = weak; } - unsafe { Rc::from_raw(ptr) } + unsafe { Arc::from_raw(ptr) } } /// Allocate a block, return block id fn alloc_block(&self) -> Option { - let id = self.free_map.borrow_mut().alloc(); + let id = self.free_map.write().alloc(); if id.is_some() { - self.super_block.borrow_mut().unused_blocks -= 1; // will panic if underflow + self.super_block.write().unused_blocks -= 1; // will panic if underflow id } else { self.flush_unreachable_inodes(); - let id = self.free_map.borrow_mut().alloc(); + let id = self.free_map.write().alloc(); if id.is_some() { - self.super_block.borrow_mut().unused_blocks -= 1; + self.super_block.write().unused_blocks -= 1; } id } } /// Free a block fn free_block(&self, block_id: usize) { - let mut free_map = self.free_map.borrow_mut(); + let mut free_map = self.free_map.write(); assert!(!free_map[block_id]); free_map.set(block_id, true); - self.super_block.borrow_mut().unused_blocks += 1; + self.super_block.write().unused_blocks += 1; } /// Create a new INode struct, then insert it to self.inodes /// Private used for load or create INode - fn _new_inode(&self, id: INodeId, disk_inode: Dirty) -> Ptr { - let inode = Rc::new(RefCell::new(INode { - disk_inode, + fn _new_inode(&self, id: INodeId, disk_inode: Dirty) -> Arc { + let inode = Arc::new(INodeImpl { id, - fs: self.self_ptr.clone(), - })); - self.inodes.borrow_mut().insert(id, inode.clone()); + disk_inode: RwLock::new(disk_inode), + fs: self.self_ptr.upgrade().unwrap(), + }); + self.inodes.write().insert(id, Arc::downgrade(&inode)); inode } /// Get inode by id. Load if not in memory. /// ** Must ensure it's a valid INode ** - fn get_inode(&self, id: INodeId) -> Ptr { - assert!(!self.free_map.borrow()[id]); + fn get_inode(&self, id: INodeId) -> Arc { + assert!(!self.free_map.read()[id]); - // Load if not in memory. - if !self.inodes.borrow().contains_key(&id) { - let disk_inode = Dirty::new(self.device.borrow_mut().load_struct::(id)); - self._new_inode(id, disk_inode) - } else { - self.inodes.borrow_mut().get(&id).unwrap().clone() + // In the BTreeSet and not weak. + if let Some(inode) = self.inodes.read().get(&id) { + if let Some(inode) = inode.upgrade() { + return inode; + } } + // Load if not in set, or is weak ref. + let disk_inode = Dirty::new(self.device.lock().load_struct::(id)); + self._new_inode(id, disk_inode) } /// Create a new INode file - fn new_inode_file(&self) -> vfs::Result> { + fn new_inode_file(&self) -> vfs::Result> { let id = self.alloc_block().unwrap(); let disk_inode = Dirty::new_dirty(DiskINode::new_file()); Ok(self._new_inode(id, disk_inode)) } /// Create a new INode dir - fn new_inode_dir(&self, parent: INodeId) -> vfs::Result> { + fn new_inode_dir(&self, parent: INodeId) -> vfs::Result> { let id = self.alloc_block().unwrap(); let disk_inode = Dirty::new_dirty(DiskINode::new_dir()); let inode = self._new_inode(id, disk_inode); - inode.borrow_mut().init_dir_entry(parent).unwrap(); + inode.init_dir_entry(parent).unwrap(); Ok(inode) } fn flush_unreachable_inodes(&self) { - let mut inodes = self.inodes.borrow_mut(); + let mut inodes = self.inodes.write(); let remove_ids: Vec<_> = inodes.iter().filter(|(_, inode)| { - use vfs::INode; - Rc::strong_count(inode) <= 1 - && inode.borrow().info().unwrap().nlinks == 0 + if let Some(inode) = inode.upgrade() { + Arc::strong_count(&inode) <= 1 && inode.info().unwrap().nlinks == 0 + } else { + true + } }).map(|(&id, _)| id).collect(); for id in remove_ids.iter() { inodes.remove(&id); @@ -636,25 +609,26 @@ impl SimpleFileSystem { impl vfs::FileSystem for SimpleFileSystem { /// Write back super block if dirty fn sync(&self) -> vfs::Result<()> { - let mut super_block = self.super_block.borrow_mut(); + let mut super_block = self.super_block.write(); if super_block.dirty() { - self.device.borrow_mut().write_at(BLKSIZE * BLKN_SUPER, super_block.as_buf()).unwrap(); + self.device.lock().write_at(BLKSIZE * BLKN_SUPER, super_block.as_buf()).unwrap(); super_block.sync(); } - let mut free_map = self.free_map.borrow_mut(); + let mut free_map = self.free_map.write(); if free_map.dirty() { - self.device.borrow_mut().write_at(BLKSIZE * BLKN_FREEMAP, free_map.as_buf()).unwrap(); + self.device.lock().write_at(BLKSIZE * BLKN_FREEMAP, free_map.as_buf()).unwrap(); free_map.sync(); } - for inode in self.inodes.borrow().values() { - use vfs::INode; - inode.borrow_mut().sync().unwrap(); + for inode in self.inodes.read().values() { + if let Some(inode) = inode.upgrade() { + inode.sync().unwrap(); + } } self.flush_unreachable_inodes(); Ok(()) } - fn root_inode(&self) -> Ptr { + fn root_inode(&self) -> Arc { self.get_inode(BLKN_ROOT) } diff --git a/src/tests.rs b/src/tests.rs index 94c9bfb..2762126 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -1,15 +1,14 @@ -use std::fs; -use std::fs::{File, OpenOptions}; +use std::fs::{self, File, OpenOptions}; use std::io::{Read, Write, Seek, SeekFrom}; use std::boxed::Box; +use std::sync::Arc; +use std::mem::uninitialized; use super::sfs::*; use super::vfs::*; use super::vfs::INode; -use std::rc::Rc; -use std::mem::uninitialized; use super::structs::{DiskEntry, AsBuf}; -fn _open_sample_file() -> Rc { +fn _open_sample_file() -> Arc { fs::copy("sfs.img", "test.img").expect("failed to open sfs.img"); let file = OpenOptions::new() .read(true).write(true).open("test.img") @@ -18,7 +17,7 @@ fn _open_sample_file() -> Rc { .expect("failed to open SFS") } -fn _create_new_sfs() -> Rc { +fn _create_new_sfs() -> Arc { let file = OpenOptions::new() .read(true).write(true).create(true).open("test.img") .expect("failed to create file"); @@ -40,22 +39,22 @@ fn create_new_sfs() { fn print_root() { let sfs = _open_sample_file(); let root = sfs.root_inode(); - println!("{:?}", root.borrow()); + println!("{:?}", root); - let files = root.borrow().list().unwrap(); + let files = root.list().unwrap(); println!("{:?}", files); - assert_eq!(files[3], root.borrow().get_entry(3).unwrap()); + assert_eq!(files[3], root.get_entry(3).unwrap()); sfs.sync().unwrap(); } #[test] -fn create_file() { +fn create_file() -> Result<()> { let sfs = _create_new_sfs(); let root = sfs.root_inode(); - let file1 = root.borrow_mut().create("file1", FileType::File).unwrap(); + let file1 = root.create("file1", FileType::File)?; - assert_eq!(file1.borrow().info().unwrap(), FileInfo { + assert_eq!(file1.info()?, FileInfo { size: 0, type_: FileType::File, mode: 0, @@ -63,27 +62,29 @@ fn create_file() { nlinks: 1, }); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } #[test] -fn resize() { +fn resize() -> Result<()> { let sfs = _create_new_sfs(); let root = sfs.root_inode(); - let file1 = root.borrow_mut().create("file1", FileType::File).unwrap(); - assert_eq!(file1.borrow().info().unwrap().size, 0, "empty file size != 0"); + let file1 = root.create("file1", FileType::File)?; + assert_eq!(file1.info()?.size, 0, "empty file size != 0"); const SIZE1: usize = 0x1234; const SIZE2: usize = 0x1250; - file1.borrow_mut().resize(SIZE1).unwrap(); - assert_eq!(file1.borrow().info().unwrap().size, SIZE1, "wrong size after resize"); + file1.resize(SIZE1)?; + assert_eq!(file1.info()?.size, SIZE1, "wrong size after resize"); let mut data1: [u8; SIZE2] = unsafe { uninitialized() }; impl AsBuf for [u8; SIZE2] {} - let len = file1.borrow().read_at(0, data1.as_buf_mut()).unwrap(); + let len = file1.read_at(0, data1.as_buf_mut())?; assert_eq!(len, SIZE1, "wrong size returned by read_at()"); assert_eq!(&data1[..SIZE1], &[0u8; SIZE1][..], "expanded data should be 0"); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } // FIXME: `should_panic` tests will panic again on exit, due to `Dirty` drop @@ -93,7 +94,7 @@ fn resize() { //fn resize_on_dir_should_panic() { // let sfs = _create_new_sfs(); // let root = sfs.root_inode(); -// root.borrow_mut().resize(4096).unwrap(); +// root.resize(4096).unwrap(); // sfs.sync().unwrap(); //} // @@ -102,233 +103,237 @@ fn resize() { //fn resize_too_large_should_panic() { // let sfs = _create_new_sfs(); // let root = sfs.root_inode(); -// let file1 = root.borrow_mut().create("file1", FileType::File).unwrap(); -// file1.borrow_mut().resize(1 << 28).unwrap(); +// let file1 = root.create("file1", FileType::File).unwrap(); +// file1.resize(1 << 28).unwrap(); // sfs.sync().unwrap(); //} #[test] -fn create_then_lookup() { +fn create_then_lookup() -> Result<()> { let sfs = _create_new_sfs(); let root = sfs.root_inode(); - assert!(Rc::ptr_eq(&root.borrow().lookup(".").unwrap(), &root), "failed to find ."); - assert!(Rc::ptr_eq(&root.borrow().lookup("..").unwrap(), &root), "failed to find .."); + assert!(Arc::ptr_eq(&root.lookup(".")?, &root), "failed to find ."); + assert!(Arc::ptr_eq(&root.lookup("..")?, &root), "failed to find .."); - let file1 = root.borrow_mut().create("file1", FileType::File) + let file1 = root.create("file1", FileType::File) .expect("failed to create file1"); - assert!(Rc::ptr_eq(&root.borrow().lookup("file1").unwrap(), &file1), "failed to find file1"); - assert!(root.borrow().lookup("file2").is_err(), "found non-existent file"); + assert!(Arc::ptr_eq(&root.lookup("file1")?, &file1), "failed to find file1"); + assert!(root.lookup("file2").is_err(), "found non-existent file"); - let dir1 = root.borrow_mut().create("dir1", FileType::Dir) + let dir1 = root.create("dir1", FileType::Dir) .expect("failed to create dir1"); - let file2 = dir1.borrow_mut().create("file2", FileType::File) + let file2 = dir1.create("file2", FileType::File) .expect("failed to create /dir1/file2"); - assert!(Rc::ptr_eq(&root.borrow().lookup("dir1/file2").unwrap(), &file2), "failed to find dir1/file1"); - assert!(Rc::ptr_eq(&dir1.borrow().lookup("..").unwrap(), &root), "failed to find .. from dir1"); + assert!(Arc::ptr_eq(&root.lookup("dir1/file2")?, &file2), "failed to find dir1/file1"); + assert!(Arc::ptr_eq(&dir1.lookup("..")?, &root), "failed to find .. from dir1"); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } #[test] -fn rc_layout() { +fn arc_layout() { // [usize, usize, T] - // ^ start ^ Rc::into_raw - let p = Rc::new([2u8; 5]); - let ptr = Rc::into_raw(p); + // ^ start ^ Arc::into_raw + let p = Arc::new([2u8; 5]); + let ptr = Arc::into_raw(p); let start = unsafe { (ptr as *const usize).offset(-2) }; let ns = unsafe { &*(start as *const [usize; 2]) }; assert_eq!(ns, &[1usize, 1]); } // #[test] -fn kernel_image_file_create() { +fn kernel_image_file_create() -> Result<()> { let sfs = _open_sample_file(); let root = sfs.root_inode(); - let files_count_before = root.borrow().list().unwrap().len(); - root.borrow_mut().create("hello2", FileType::File).unwrap(); - let files_count_after = root.borrow().list().unwrap().len(); + let files_count_before = root.list()?.len(); + root.create("hello2", FileType::File); + let files_count_after = root.list()?.len(); assert_eq!(files_count_before + 1, files_count_after); - assert!(root.borrow().lookup("hello2").is_ok()); + assert!(root.lookup("hello2").is_ok()); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } // #[test] -fn kernel_image_file_unlink() { +fn kernel_image_file_unlink() -> Result<()> { let sfs = _open_sample_file(); let root = sfs.root_inode(); - let files_count_before = root.borrow().list().unwrap().len(); - root.borrow_mut().unlink("hello").unwrap(); - let files_count_after = root.borrow().list().unwrap().len(); + let files_count_before = root.list()?.len(); + root.unlink("hello")?; + let files_count_after = root.list()?.len(); assert_eq!(files_count_before, files_count_after + 1); - assert!(root.borrow().lookup("hello").is_err()); + assert!(root.lookup("hello").is_err()); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } // #[test] -fn kernel_image_file_rename() { +fn kernel_image_file_rename() -> Result<()> { let sfs = _open_sample_file(); let root = sfs.root_inode(); - let files_count_before = root.borrow().list().unwrap().len(); - root.borrow_mut().rename("hello", "hello2").unwrap(); - let files_count_after = root.borrow().list().unwrap().len(); + let files_count_before = root.list().unwrap().len(); + root.rename("hello", "hello2")?; + let files_count_after = root.list()?.len(); assert_eq!(files_count_before, files_count_after); - assert!(root.borrow().lookup("hello").is_err()); - assert!(root.borrow().lookup("hello2").is_ok()); + assert!(root.lookup("hello").is_err()); + assert!(root.lookup("hello2").is_ok()); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } // #[test] -fn kernel_image_file_move() { - use core::ops::DerefMut; +fn kernel_image_file_move() -> Result<()> { let sfs = _open_sample_file(); let root = sfs.root_inode(); - let files_count_before = root.borrow().list().unwrap().len(); - root.borrow_mut().unlink("divzero").unwrap(); - let rust_dir = root.borrow_mut().create("rust", FileType::Dir).unwrap(); - root.borrow_mut().move_("hello", rust_dir.borrow_mut().deref_mut(), "hello_world").unwrap(); - let files_count_after = root.borrow().list().unwrap().len(); + let files_count_before = root.list()?.len(); + root.unlink("divzero")?; + let rust_dir = root.create("rust", FileType::Dir)?; + root.move_("hello", &rust_dir, "hello_world")?; + let files_count_after = root.list()?.len(); assert_eq!(files_count_before, files_count_after + 1); - assert!(root.borrow().lookup("hello").is_err()); - assert!(root.borrow().lookup("divzero").is_err()); - assert!(root.borrow().lookup("rust").is_ok()); - assert!(rust_dir.borrow().lookup("hello_world").is_ok()); + assert!(root.lookup("hello").is_err()); + assert!(root.lookup("divzero").is_err()); + assert!(root.lookup("rust").is_ok()); + assert!(rust_dir.lookup("hello_world").is_ok()); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } #[test] -fn hard_link() { +fn hard_link() -> Result<()> { let sfs = _create_new_sfs(); let root = sfs.root_inode(); - let file1 = root.borrow_mut().create("file1", FileType::File).unwrap(); - use core::ops::DerefMut; - root.borrow_mut().link("file2", file1.borrow_mut().deref_mut()).unwrap(); - let file2 = root.borrow().lookup("file2").unwrap(); - file1.borrow_mut().resize(100); - assert_eq!(file2.borrow().info().unwrap().size, 100); - - sfs.sync().unwrap(); + let file1 = root.create("file1", FileType::File)?; + root.link("file2", &file1)?; + let file2 = root.lookup("file2")?; + file1.resize(100); + assert_eq!(file2.info()?.size, 100); + + sfs.sync()?; + Ok(()) } #[test] -fn nlinks() { - use core::ops::DerefMut; +fn nlinks() -> Result<()> { let sfs = _create_new_sfs(); let root = sfs.root_inode(); // -root - assert_eq!(root.borrow().info().unwrap().nlinks, 2); + assert_eq!(root.info()?.nlinks, 2); - let file1 = root.borrow_mut().create("file1", FileType::File).unwrap(); + let file1 = root.create("file1", FileType::File)?; // -root // `-file1 - assert_eq!(file1.borrow().info().unwrap().nlinks, 1); - assert_eq!(root.borrow().info().unwrap().nlinks, 2); + assert_eq!(file1.info()?.nlinks, 1); + assert_eq!(root.info()?.nlinks, 2); - let dir1 = root.borrow_mut().create("dir1", FileType::Dir).unwrap(); + let dir1 = root.create("dir1", FileType::Dir)?; // -root // +-dir1 // `-file1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 3); - root.borrow_mut().rename("dir1", "dir_1").unwrap(); + root.rename("dir1", "dir_1")?; // -root // +-dir_1 // `-file1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 3); - dir1.borrow_mut().link("file1_", file1.borrow_mut().deref_mut()).unwrap(); + dir1.link("file1_", &file1)?; // -root // +-dir_1 // | `-file1_ // `-file1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); - assert_eq!(file1.borrow().info().unwrap().nlinks, 2); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 3); + assert_eq!(file1.info()?.nlinks, 2); - let dir2 = root.borrow_mut().create("dir2", FileType::Dir).unwrap(); + let dir2 = root.create("dir2", FileType::Dir)?; // -root // +-dir_1 // | `-file1_ // +-dir2 // `-file1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 4); - assert_eq!(file1.borrow().info().unwrap().nlinks, 2); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 4); + assert_eq!(file1.info()?.nlinks, 2); - root.borrow_mut().rename("file1", "file_1").unwrap(); + root.rename("file1", "file_1")?; // -root // +-dir_1 // | `-file1_ // +-dir2 // `-file_1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 4); - assert_eq!(file1.borrow().info().unwrap().nlinks, 2); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 4); + assert_eq!(file1.info()?.nlinks, 2); - root.borrow_mut().move_("file_1", dir2.borrow_mut().deref_mut(), "file__1").unwrap(); + root.move_("file_1", &dir2, "file__1")?; // -root // +-dir_1 // | `-file1_ // `-dir2 // `-file__1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 2); - assert_eq!(root.borrow().info().unwrap().nlinks, 4); - assert_eq!(file1.borrow().info().unwrap().nlinks, 2); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 2); + assert_eq!(root.info()?.nlinks, 4); + assert_eq!(file1.info()?.nlinks, 2); - root.borrow_mut().move_("dir_1", dir2.borrow_mut().deref_mut(), "dir__1").unwrap(); + root.move_("dir_1", &dir2, "dir__1")?; // -root // `-dir2 // +-dir__1 // | `-file1_ // `-file__1 - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 3); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); - assert_eq!(file1.borrow().info().unwrap().nlinks, 2); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 3); + assert_eq!(root.info()?.nlinks, 3); + assert_eq!(file1.info()?.nlinks, 2); - dir2.borrow_mut().unlink("file__1").unwrap(); + dir2.unlink("file__1")?; // -root // `-dir2 // `-dir__1 // `-file1_ - assert_eq!(file1.borrow().info().unwrap().nlinks, 1); - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 3); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); + assert_eq!(file1.info()?.nlinks, 1); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 3); + assert_eq!(root.info()?.nlinks, 3); - dir1.borrow_mut().unlink("file1_").unwrap(); + dir1.unlink("file1_")?; // -root // `-dir2 // `-dir__1 - assert_eq!(file1.borrow().info().unwrap().nlinks, 0); - assert_eq!(dir1.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 3); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); + assert_eq!(file1.info()?.nlinks, 0); + assert_eq!(dir1.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 3); + assert_eq!(root.info()?.nlinks, 3); - dir2.borrow_mut().unlink("dir__1").unwrap(); + dir2.unlink("dir__1")?; // -root // `-dir2 - assert_eq!(file1.borrow().info().unwrap().nlinks, 0); - assert_eq!(dir1.borrow().info().unwrap().nlinks, 0); - assert_eq!(root.borrow().info().unwrap().nlinks, 3); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 2); + assert_eq!(file1.info()?.nlinks, 0); + assert_eq!(dir1.info()?.nlinks, 0); + assert_eq!(root.info()?.nlinks, 3); + assert_eq!(dir2.info()?.nlinks, 2); - root.borrow_mut().unlink("dir2").unwrap(); + root.unlink("dir2")?; // -root - assert_eq!(file1.borrow().info().unwrap().nlinks, 0); - assert_eq!(dir1.borrow().info().unwrap().nlinks, 0); - assert_eq!(root.borrow().info().unwrap().nlinks, 2); - assert_eq!(dir2.borrow().info().unwrap().nlinks, 0); + assert_eq!(file1.info()?.nlinks, 0); + assert_eq!(dir1.info()?.nlinks, 0); + assert_eq!(root.info()?.nlinks, 2); + assert_eq!(dir2.info()?.nlinks, 0); - sfs.sync().unwrap(); + sfs.sync()?; + Ok(()) } \ No newline at end of file diff --git a/src/vfs.rs b/src/vfs.rs index 945524b..7adadef 100644 --- a/src/vfs.rs +++ b/src/vfs.rs @@ -1,4 +1,4 @@ -use alloc::{vec::Vec, string::String, rc::{Rc, Weak}}; +use alloc::{vec::Vec, string::String, sync::{Arc, Weak}}; use core::cell::RefCell; use core::mem::size_of; use core; @@ -14,42 +14,36 @@ pub trait Device { /// Abstract operations on a inode. pub trait INode: Debug + Any { - fn open(&mut self, flags: u32) -> Result<()>; - fn close(&mut self) -> Result<()>; + fn open(&self, flags: u32) -> Result<()>; + fn close(&self) -> Result<()>; fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result; fn write_at(&self, offset: usize, buf: &[u8]) -> Result; fn info(&self) -> Result; - fn sync(&mut self) -> Result<()>; - fn resize(&mut self, len: usize) -> Result<()>; - fn create(&mut self, name: &str, type_: FileType) -> Result; - fn unlink(&mut self, name: &str) -> Result<()>; + fn sync(&self) -> Result<()>; + fn resize(&self, len: usize) -> Result<()>; + fn create(&self, name: &str, type_: FileType) -> Result>; + fn unlink(&self, name: &str) -> Result<()>; /// user of the vfs api should call borrow_mut by itself - fn link(&mut self, name: &str, other: &mut INode) -> Result<()>; - fn rename(&mut self, old_name: &str, new_name: &str) -> Result<()>; + fn link(&self, name: &str, other: &Arc) -> Result<()>; + fn rename(&self, old_name: &str, new_name: &str) -> Result<()>; // when self==target use rename instead since it's not possible to have two mut_ref at the same time. - fn move_(&mut self, old_name: &str, target: &mut INode, new_name: &str) -> Result<()>; + fn move_(&self, old_name: &str, target: &Arc, new_name: &str) -> Result<()>; /// lookup with only one layer - fn find(&self, name: &str) -> Result; + fn find(&self, name: &str) -> Result>; /// like list()[id] /// only get one item in list, often faster than list fn get_entry(&self, id: usize) -> Result; // fn io_ctrl(&mut self, op: u32, data: &[u8]) -> Result<()>; - fn fs(&self) -> Weak; + fn fs(&self) -> Arc; /// this is used to implement dynamics cast /// simply return self in the implement of the function fn as_any_ref(&self) -> &Any; - /// this is used to implement dynamics cast - /// simply return self in the implement of the function - fn as_any_mut(&mut self) -> &mut Any; } impl INode { pub fn downcast_ref(&self) -> Option<&T> { self.as_any_ref().downcast_ref::() } - pub fn downcast_mut(&mut self) -> Option<&mut T> { - self.as_any_mut().downcast_mut::() - } pub fn list(&self) -> Result> { let info = self.info().unwrap(); assert_eq!(info.type_, FileType::Dir); @@ -57,16 +51,12 @@ impl INode { self.get_entry(i).unwrap() }).collect()) } - pub fn lookup(&self, path: &str) -> Result { - if self.info().unwrap().type_ != FileType::Dir { - return Err(()); - } - let mut result = self.find(".").unwrap(); + pub fn lookup(&self, path: &str) -> Result> { + assert_eq!(self.info().unwrap().type_, FileType::Dir); + let mut result = self.find(".")?; let mut rest_path = path; while rest_path != "" { - if result.borrow().info().unwrap().type_ != FileType::Dir { - return Err(()); - } + assert_eq!(result.info()?.type_, FileType::Dir); let mut name; match rest_path.find('/') { None => { @@ -78,8 +68,7 @@ impl INode { rest_path = &rest_path[pos + 1..] } }; - let found = result.borrow().find(name); - match found { + match result.find(name) { Err(_) => return Err(()), Ok(inode) => result = inode, }; @@ -117,10 +106,8 @@ pub type Result = core::result::Result; /// Abstract filesystem pub trait FileSystem { fn sync(&self) -> Result<()>; - fn root_inode(&self) -> INodePtr; + fn root_inode(&self) -> Arc; fn info(&self) -> &'static FsInfo; // fn unmount(&self) -> Result<()>; // fn cleanup(&self); } - -pub type INodePtr = Rc>; \ No newline at end of file