ch6: enhance fs & syscalls

multi-level dir (including . and ..)
getcwd, mkdirat, chdir, openat

Author: lythesia

easy-fs-fuse/src/main.rs

@@ -1,5 +1,5 @@
 #![feature(assert_matches)]
-use easy_fs::{BlockDevice, EasyFileSystem, BLOCK_SZ};
+use easy_fs::{BlockDevice, EasyFileSystem, Inode, BLOCK_SZ};
 use structopt::StructOpt;
 
 use std::{
@@ -158,3 +158,146 @@ fn efs_test() -> std::io::Result<()> {
 
     Ok(())
 }
+
+fn read_string(file: &Arc<Inode>) -> String {
+    let mut read_buffer = [0u8; 512];
+    let mut offset = 0usize;
+    let mut read_str = String::new();
+    loop {
+        let len = file.read_at(offset, &mut read_buffer);
+        if len == 0 {
+            break;
+        }
+        offset += len;
+        read_str.push_str(core::str::from_utf8(&read_buffer[..len]).unwrap());
+    }
+    read_str
+}
+
+fn tree(inode: &Arc<Inode>, name: &str, depth: usize) {
+    if depth > 1 {
+        for _ in 0..depth - 1 {
+            print!("    ");
+        }
+    }
+    if depth == 0 {
+        println!("{}", name);
+    } else {
+        println!("+-- {}", name);
+    }
+    for f in inode.ls() {
+        // skip "." and ".."
+        if matches!(f.as_str(), "." | "..") {
+            continue;
+        }
+        let child = inode
+            .find(&f)
+            .expect(&format!("{f} in `ls {name}`(d={depth}) but cannot find"));
+        tree(&child, &f, depth + 1);
+    }
+}
+
+#[test]
+fn efs_dir_test() -> std::io::Result<()> {
+    let block_file = Arc::new(BlockFile(Mutex::new({
+        let f = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open("target/fs.img")?;
+        f.set_len(8192 * 512).unwrap();
+        f
+    })));
+    EasyFileSystem::create(block_file.clone(), 4096, 1);
+    let efs = EasyFileSystem::open(block_file.clone());
+    let root = Arc::new(EasyFileSystem::root_inode(&efs));
+    root.create("f1");
+    root.create("f2");
+
+    let d1 = root.create_dir("d1").unwrap();
+
+    let f3 = d1.create("f3").unwrap();
+    let d2 = d1.create_dir("d2").unwrap();
+
+    let f4 = d2.create("f4").unwrap();
+    tree(&root, "/", 0);
+
+    let f3_content = "3333333";
+    let f4_content = "4444444444444444444";
+    f3.write_at(0, f3_content.as_bytes());
+    f4.write_at(0, f4_content.as_bytes());
+
+    assert_eq!(read_string(&d1.find("f3").unwrap()), f3_content);
+    assert_eq!(read_string(&root.find("/d1/f3").unwrap()), f3_content);
+    assert_eq!(read_string(&d2.find("f4").unwrap()), f4_content);
+    assert_eq!(read_string(&d1.find("d2/f4").unwrap()), f4_content);
+    assert_eq!(read_string(&root.find("/d1/d2/f4").unwrap()), f4_content);
+    assert!(f3.find("whatever").is_none());
+    Ok(())
+}
+
+#[test]
+fn efs_dir_dot_test() -> std::io::Result<()> {
+    let block_file = Arc::new(BlockFile(Mutex::new({
+        let f = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open("target/fs.img")?;
+        f.set_len(8192 * 512).unwrap();
+        f
+    })));
+    EasyFileSystem::create(block_file.clone(), 4096, 1);
+    let efs = EasyFileSystem::open(block_file.clone());
+    let root = Arc::new(EasyFileSystem::root_inode(&efs));
+
+    root.create("file0");
+    root.create("file1");
+    println!("ls /\n{:?}", root.ls());
+
+    if let Some(root_dot) = root.find(".") {
+        println!("ls /.\n{:?}", root_dot.ls());
+    }
+    if let Some(root_ddot) = root.find("..") {
+        println!("ls /..\n{:?}", root_ddot.ls());
+        if let Some(ddot_of_root_ddot) = root_ddot.find("..") {
+            println!("ls /../..\n{:?}", ddot_of_root_ddot.ls());
+        }
+    }
+    if let Some(d) = root.find("./.././..") {
+        println!("ls*(at /) ./.././..\n{:?}", d.ls());
+    }
+
+    println!("\ncreate dir0");
+    let dir0 = root.create_dir("dir0").unwrap();
+    dir0.create("dir0_file0");
+    println!("ls dir0\n{:?}", dir0.ls());
+    if let Some(dot) = dir0.find(".") {
+        println!("ls dir0/.\n{:?}", dot.ls());
+    }
+    if let Some(ddot) = dir0.find("..") {
+        println!("ls dir0/..\n{:?}", ddot.ls());
+        if let Some(ddot_of_ddot) = ddot.find("..") {
+            println!("ls dir0/../..\n{:?}", ddot_of_ddot.ls());
+        }
+    }
+    if let Some(d) = dir0.find("./.././..") {
+        println!("ls*(at dir0) ./.././..\n{:?}", d.ls()); // eqv. ls /
+    }
+    Ok(())
+}
+
+#[test]
+fn check_os_image() -> std::io::Result<()> {
+    let block_file = Arc::new(BlockFile(Mutex::new({
+        let f = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open("target/os.img")?;
+        f
+    })));
+    let efs = EasyFileSystem::open(block_file);
+    let root = Arc::new(EasyFileSystem::root_inode(&efs));
+    tree(&root, "/", 0);
+    Ok(())
+}

easy-fs/src/efs.rs

@@ -88,7 +88,8 @@ impl EasyFileSystem {
         get_block_cache(root_inode_block_id as usize, Arc::clone(&block_device))
             .lock()
             .modify(root_inode_offset, |root_inode: &mut DiskInode| {
-                root_inode.initialize(DiskInodeType::Directory)
+                root_inode.initialize(DiskInodeType::Directory);
+                root_inode.initialize_dir(0, 0, || efs.alloc_data(), &block_device);
             });
 
         Arc::new(Mutex::new(efs))

easy-fs/src/layout.rs

@@ -83,7 +83,7 @@ pub struct DiskInode {
     type_: DiskInodeType,
 }
 
-#[derive(PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum DiskInodeType {
     File,
     Directory,
@@ -98,6 +98,36 @@ impl DiskInode {
         self.type_ = type_;
     }
 
+    pub fn initialize_dir<F: FnMut() -> u32>(
+        &mut self,
+        self_inode: u32,
+        parent_inode: u32,
+        mut data_alloc: F,
+        block_device: &Arc<dyn BlockDevice>,
+    ) {
+        assert_eq!(self.type_, DiskInodeType::Directory);
+
+        // increase size
+        let file_count = (self.size as usize) / DIRENT_SZ; // should be 0 when create
+        let new_size = ((file_count + 2) * DIRENT_SZ) as u32; // "." and ".."
+        let blocks_needed = self.blocks_num_needed(new_size);
+        let mut new_blocks = Vec::new();
+        for _ in 0..blocks_needed {
+            new_blocks.push(data_alloc());
+        }
+        self.increase_size(new_size, new_blocks, block_device);
+        // write both dir entry points to self
+        let buf = {
+            let mut b = [0u8; 2 * DIRENT_SZ];
+            let dir = DirEntry::new(".", self_inode);
+            b[..DIRENT_SZ].copy_from_slice(dir.as_bytes());
+            let dir = DirEntry::new("..", parent_inode);
+            b[DIRENT_SZ..].copy_from_slice(dir.as_bytes());
+            b
+        };
+        self.write_at(file_count * DIRENT_SZ, &buf[..], &block_device);
+    }
+
     pub fn is_dir(&self) -> bool {
         self.type_ == DiskInodeType::Directory
     }

easy-fs/src/vfs.rs

@@ -70,28 +70,75 @@ impl Inode {
         None
     }
 
-    /// Find inode under current inode by name (1 level only)
-    pub fn find(&self, name: &str) -> Option<Arc<Inode>> {
-        let fs = self.fs.lock();
+    /// Find direntry under a disk inode by pred
+    fn get_dirent(
+        &self,
+        disk_inode: &DiskInode,
+        pred: impl Fn(&DirEntry) -> bool,
+    ) -> Option<DirEntry> {
+        assert!(disk_inode.is_dir());
+        let file_count = (disk_inode.size as usize) / DIRENT_SZ;
+        let mut dirent = DirEntry::new_empty();
+        for i in 0..file_count {
+            assert_eq!(
+                disk_inode.read_at(i * DIRENT_SZ, dirent.as_bytes_mut(), &self.block_device),
+                DIRENT_SZ
+            );
+            if pred(&dirent) {
+                return Some(dirent);
+            }
+        }
+        None
+    }
+
+    /// Read child direnty by inode_id
+    pub fn read_dirent<V>(&self, inode_id: u32, f: impl FnOnce(DirEntry) -> V) -> Option<V> {
         self.read_disk_inode(|disk_inode| {
-            self.find_inode_id(name, disk_inode).map(|inode_id| {
-                let (block_id, block_offset) = fs.get_disk_inode_pos(inode_id);
-                Arc::new(Inode::new(
-                    inode_id,
-                    block_id,
-                    block_offset,
-                    self.fs.clone(),
-                    self.block_device.clone(),
-                ))
-            })
+            self.get_dirent(disk_inode, |d| d.inode_number() == inode_id)
         })
+        .map(f)
+    }
+
+    /// Find inode under current inode(recursively) by name
+    pub fn find(&self, path: &str) -> Option<Arc<Inode>> {
+        let fs = self.fs.lock();
+        let mut inode_id = self.inode_id;
+        let mut block_id = self.block_id as u32;
+        let mut block_offset = self.block_offset;
+
+        for name in path.split('/').filter(|s| !s.is_empty()) {
+            let opt_inode_id = get_block_cache(block_id as usize, self.block_device.clone())
+                .lock()
+                .read(block_offset, |disk_inode: &DiskInode| {
+                    if disk_inode.is_file() {
+                        return None;
+                    }
+                    self.find_inode_id(name, disk_inode)
+                });
+            match opt_inode_id {
+                Some(v) => {
+                    inode_id = v;
+                    (block_id, block_offset) = fs.get_disk_inode_pos(v);
+                }
+                _ => return None,
+            }
+        }
+        Some(Arc::new(Self::new(
+            inode_id,
+            block_id,
+            block_offset,
+            self.fs.clone(),
+            self.block_device.clone(),
+        )))
     }
 
     /// List inodes under current inode
     pub fn ls(&self) -> Vec<String> {
         let _fs = self.fs.lock();
         self.read_disk_inode(|disk_inode| {
-            assert!(disk_inode.is_dir());
+            if disk_inode.is_file() {
+                return Vec::new();
+            }
             let file_count = (disk_inode.size as usize) / DIRENT_SZ;
             let mut v = Vec::with_capacity(file_count);
             let mut dirent = DirEntry::new_empty();
@@ -126,7 +173,7 @@ impl Inode {
     }
 
     /// Create inode under current inode by name
-    pub fn create(&self, name: &str) -> Option<Arc<Inode>> {
+    fn create_inode(&self, name: &str, inode_type: DiskInodeType) -> Option<Arc<Inode>> {
         let mut fs = self.fs.lock();
         let op = |root_inode: &DiskInode| {
             assert!(root_inode.is_dir());
@@ -145,9 +192,9 @@ impl Inode {
         get_block_cache(new_inode_block_id as usize, self.block_device.clone())
             .lock()
             .modify(new_inode_block_offset, |new_inode: &mut DiskInode| {
-                new_inode.initialize(DiskInodeType::File)
+                new_inode.initialize(inode_type)
             });
-        // 3. modify current inode(root inode): add one more dirent
+        // 3. modify current inode: add one more dirent
         self.modify_disk_inode(|root_inode| {
             // append file in dirent
             let file_count = (root_inode.size as usize) / DIRENT_SZ;
@@ -162,22 +209,45 @@ impl Inode {
                 &self.block_device,
             );
         });
-        // 4. return inode
-        block_cache_sync_all();
-        Some(Arc::new(Self::new(
+        let inode = Self::new(
             new_inode_id,
             new_inode_block_id,
             new_inode_block_offset,
             self.fs.clone(),
             self.block_device.clone(),
-        )))
+        );
+        if inode_type == DiskInodeType::Directory {
+            let curr_inode_id = self.inode_id;
+            inode.modify_disk_inode(|curr_inode| {
+                curr_inode.initialize_dir(
+                    new_inode_id,
+                    curr_inode_id,
+                    || fs.alloc_data(),
+                    &self.block_device,
+                );
+            });
+        }
+        // 4. return inode
+        block_cache_sync_all();
+        Some(Arc::new(inode))
         // release efs lock
     }
 
+    /// Create regular file under current inode
+    pub fn create(&self, name: &str) -> Option<Arc<Inode>> {
+        self.create_inode(name, DiskInodeType::File)
+    }
+
+    /// Create directory under current inode
+    pub fn create_dir(&self, name: &str) -> Option<Arc<Inode>> {
+        self.create_inode(name, DiskInodeType::Directory)
+    }
+
     /// Clear the data in current inode
     pub fn clear(&self) {
         let mut fs = self.fs.lock();
         self.modify_disk_inode(|disk_inode| {
+            assert!(disk_inode.is_file());
             let size = disk_inode.size;
             let data_blocks_dealloc = disk_inode.clear_size(&self.block_device);
             assert_eq!(
@@ -200,6 +270,7 @@ impl Inode {
     pub fn write_at(&self, offset: usize, buf: &[u8]) -> usize {
         let mut fs = self.fs.lock();
         self.modify_disk_inode(|disk_inode| {
+            assert!(disk_inode.is_file());
             // extend first
             self.increase_size((offset + buf.len()) as u32, disk_inode, &mut fs);
             disk_inode.write_at(offset, buf, &self.block_device)
@@ -215,4 +286,14 @@ impl Inode {
     pub fn get_size(&self) -> usize {
         self.read_disk_inode(|disk_inode| disk_inode.size as usize)
     }
+
+    /// Is dir?
+    pub fn is_dir(&self) -> bool {
+        self.read_disk_inode(|disk_inode| disk_inode.is_dir())
+    }
+
+    /// Is file?
+    pub fn is_file(&self) -> bool {
+        self.read_disk_inode(|disk_inode| disk_inode.is_file())
+    }
 }