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

Multi-thread support.

Browse Source 
- Use Arc & Mutex to replace Rc & RefCell
- Use panic! instead of return Err(())
master
WangRunji 6 years ago
parent b0b1e0b307
commit 3f456a2dc6
5 changed files with 366 additions and 398 deletions
Show Stats Download Patch File Download Diff File

1
Cargo.toml
Unescape View File

@ -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 = []

1
src/lib.rs
Unescape View File

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

438
src/sfs.rs
Unescape View File

@ -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<T> = Rc<RefCell<T>>;
/// inode for sfs
pub struct INode {
/// on-disk inode
disk_inode: Dirty<DiskINode>,
pub struct INodeImpl {
/// inode number
id: INodeId,
/// on-disk inode
disk_inode: RwLock<Dirty<DiskINode>>,
/// Weak reference to SFS, used by almost all operations
fs: Weak<SimpleFileSystem>,
fs: Arc<SimpleFileSystem>,
}
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<BlockId> {
fn get_disk_block_id(&self, file_block_id: BlockId) -> vfs::Result<BlockId> {
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<F>(&self, begin: usize, end: usize, mut f: F) -> vfs::Result<usize>
where F: FnMut(RefMut<Box<Device>>, &BlockRange, usize)
where F: FnMut(&mut Box<Device>, &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<usize> {
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<usize> {
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<usize> {
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<usize> {
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<vfs::FileInfo> {
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<Ptr<vfs::INode>> {
let fs = self.fs.upgrade().unwrap();
let info = self.info().unwrap();
fn create(&self, name: &str, type_: vfs::FileType) -> vfs::Result<Arc<vfs::INode>> {
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<INode>) -> 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::<INode>().unwrap();
assert!(Rc::ptr_eq(&fs, &child.fs.upgrade().unwrap()));
assert!(child.info().unwrap().type_ != vfs::FileType::Dir);
let child = other.downcast_ref::<INodeImpl>().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<INode>, 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::<INode>().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::<INodeImpl>().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<Ptr<vfs::INode>> {
let fs = self.fs.upgrade().unwrap();
let info = self.info().unwrap();
fn find(&self, name: &str) -> vfs::Result<Arc<vfs::INode>> {
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<String> {
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<vfs::FileSystem> {
fn fs(&self) -> Arc<vfs::FileSystem> {
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<Dirty<SuperBlock>>,
super_block: RwLock<Dirty<SuperBlock>>,
/// blocks in use are mared 0
free_map: RefCell<Dirty<BitVec>>,
free_map: RwLock<Dirty<BitVec>>,
/// inode list
inodes: RefCell<BTreeMap<INodeId, Ptr<INode>>>,
inodes: RwLock<BTreeMap<INodeId, Weak<INodeImpl>>>,
/// device
device: RefCell<Box<Device>>,
device: Mutex<Box<Device>>,
/// Pointer to self, used by INodes
self_ptr: Weak<SimpleFileSystem>,
}
impl SimpleFileSystem {
/// Load SFS from device
pub fn open(mut device: Box<Device>) -> Option<Rc<Self>> {
pub fn open(mut device: Box<Device>) -> Option<Arc<Self>> {
let super_block = device.load_struct::<SuperBlock>(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::<INodeId, Ptr<INode>>::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<Device>, space: usize) -> Rc<Self> {
pub fn create(mut device: Box<Device>, space: usize) -> Arc<Self> {
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<Self> {
// Create a Rc, make a Weak from it, then put it into the struct.
fn wrap(self) -> Arc<Self> {
// 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<usize> {
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<DiskINode>) -> Ptr<INode> {
let inode = Rc::new(RefCell::new(INode {
disk_inode,
fn _new_inode(&self, id: INodeId, disk_inode: Dirty<DiskINode>) -> Arc<INodeImpl> {
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<INode> {
assert!(!self.free_map.borrow()[id]);
fn get_inode(&self, id: INodeId) -> Arc<INodeImpl> {
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::<DiskINode>(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::<DiskINode>(id));
self._new_inode(id, disk_inode)
}
/// Create a new INode file
fn new_inode_file(&self) -> vfs::Result<Ptr<INode>> {
fn new_inode_file(&self) -> vfs::Result<Arc<INodeImpl>> {
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<Ptr<INode>> {
fn new_inode_dir(&self, parent: INodeId) -> vfs::Result<Arc<INodeImpl>> {
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<vfs::INode> {
fn root_inode(&self) -> Arc<vfs::INode> {
self.get_inode(BLKN_ROOT)
}

275
src/tests.rs
Unescape View File

@ -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<SimpleFileSystem> {
fn _open_sample_file() -> Arc<SimpleFileSystem> {
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<SimpleFileSystem> {
.expect("failed to open SFS")
}
fn _create_new_sfs() -> Rc<SimpleFileSystem> {
fn _create_new_sfs() -> Arc<SimpleFileSystem> {
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 <f1>
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 <f1>
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 <f1>
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_ <f1>
// `-file1 <f1>
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_ <f1>
// +-dir2
// `-file1 <f1>
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_ <f1>
// +-dir2
// `-file_1 <f1>
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_ <f1>
// `-dir2
// `-file__1 <f1>
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_ <f1>
// `-file__1 <f1>
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_ <f1>
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(())
}

49
src/vfs.rs
Unescape View File

@ -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<usize>;
fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize>;
fn info(&self) -> Result<FileInfo>;
fn sync(&mut self) -> Result<()>;
fn resize(&mut self, len: usize) -> Result<()>;
fn create(&mut self, name: &str, type_: FileType) -> Result<INodePtr>;
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<Arc<INode>>;
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<INode>) -> 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<INode>, new_name: &str) -> Result<()>;
/// lookup with only one layer
fn find(&self, name: &str) -> Result<INodePtr>;
fn find(&self, name: &str) -> Result<Arc<INode>>;
/// like list()[id]
/// only get one item in list, often faster than list
fn get_entry(&self, id: usize) -> Result<String>;
// fn io_ctrl(&mut self, op: u32, data: &[u8]) -> Result<()>;
fn fs(&self) -> Weak<FileSystem>;
fn fs(&self) -> Arc<FileSystem>;
/// 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<T: INode>(&self) -> Option<&T> {
self.as_any_ref().downcast_ref::<T>()
}
pub fn downcast_mut<T: INode>(&mut self) -> Option<&mut T> {
self.as_any_mut().downcast_mut::<T>()
}
pub fn list(&self) -> Result<Vec<String>> {
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<INodePtr> {
if self.info().unwrap().type_ != FileType::Dir {
return Err(());
}
let mut result = self.find(".").unwrap();
pub fn lookup(&self, path: &str) -> Result<Arc<INode>> {
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<T> = core::result::Result<T, ()>;
/// Abstract filesystem
pub trait FileSystem {
fn sync(&self) -> Result<()>;
fn root_inode(&self) -> INodePtr;
fn root_inode(&self) -> Arc<INode>;
fn info(&self) -> &'static FsInfo;
// fn unmount(&self) -> Result<()>;
// fn cleanup(&self);
}
pub type INodePtr = Rc<RefCell<INode>>;
Write Preview
Loading…
Cancel
Save