ch6 lab; fix efs increase_size

Author: lythesia

easy-fs/src/layout.rs

@@ -5,7 +5,7 @@ use crate::{block_cache::get_block_cache, block_dev::BlockDevice, BLOCK_SZ};
 /// Magic number for sanity check
 const EFS_MAGIC: u32 = 0x3b800001;
 /// The max number of direct inodes
-const INODE_DIRECT_COUNT: usize = 28;
+const INODE_DIRECT_COUNT: usize = 26;
 /// The max length of inode name
 const NAME_LENGTH_LIMIT: usize = 27;
 /// The max number of indirect1 inodes
@@ -73,7 +73,9 @@ type DataBlock = [u8; BLOCK_SZ];
 #[repr(C)] // size == 32*u32 = 128B == 1/4 block
 pub struct DiskInode {
     pub size: u32,
-    // when file is small, `direct` refs 28 data blocks == 28*512 = 14KB
+    pub nlink: u32, // nlink taks 4B
+    _rsv: u32,      // reserve make `direct` is even
+    // when file is small, `direct` refs 28-2 data blocks == (28-2)*512 = 14-1KB
     pub direct: [u32; INODE_DIRECT_COUNT],
     // when file is large, `indirect1` refs to L1 index block, every u32 in it refs to
     // data block, so total 512/4*512 = 64KB
@@ -92,6 +94,7 @@ pub enum DiskInodeType {
 impl DiskInode {
     pub fn initialize(&mut self, type_: DiskInodeType) {
         self.size = 0;
+        self.nlink = 1;
         self.direct.fill(0);
         self.indirect1 = 0;
         self.indirect2 = 0;
@@ -231,10 +234,11 @@ impl DiskInode {
         // new_total > `INODE_DIRECT_COUNT`
         // alloc `indrect1`
         if new_total > INODE_DIRECT_COUNT {
-            assert_eq!(curr_total, INODE_DIRECT_COUNT);
-            self.indirect1 = iter_new.next().unwrap();
+            if curr_total == INODE_DIRECT_COUNT {
+                self.indirect1 = iter_new.next().unwrap();
+            }
             // re-pos
-            curr_total -= INODE_DIRECT_COUNT; // 0
+            curr_total -= INODE_DIRECT_COUNT;
             new_total -= INODE_DIRECT_COUNT;
         } else {
             return;
@@ -253,10 +257,11 @@ impl DiskInode {
         // new_total > `INODE_DIRECT1_COUNT`
         // alloc `indrect2`
         if new_total > INODE_INDIRECT1_COUNT {
-            assert_eq!(curr_total, INODE_INDIRECT1_COUNT);
-            self.indirect2 = iter_new.next().unwrap();
+            if curr_total == INODE_INDIRECT1_COUNT {
+                self.indirect2 = iter_new.next().unwrap();
+            }
             // re-pos
-            curr_total -= INODE_INDIRECT1_COUNT; // 0
+            curr_total -= INODE_INDIRECT1_COUNT;
             new_total -= INODE_INDIRECT1_COUNT;
         } else {
             return;
@@ -280,13 +285,13 @@ impl DiskInode {
                         .lock()
                         .modify(0, |indirect1: &mut IndirectBlock| {
                             let end = if a0 < a1 { INODE_INDIRECT1_COUNT } else { b1 };
-                            for i in 0..end {
+                            for i in b0..end {
                                 indirect1[i] = iter_new.next().unwrap();
                             }
-                            curr_total += end;
+                            curr_total += (b0..end).count();
                         });
                 }
-            })
+            });
     }
 
     /// Clear size to zero and return blocks that should be deallocated.

easy-fs/src/vfs.rs

@@ -9,6 +9,7 @@ use crate::{
 };
 
 /// Virtual filesystem layer over easy-fs
+#[derive(Clone)]
 pub struct Inode {
     inode_id: u32,
 
@@ -55,7 +56,7 @@ impl Inode {
     /// Find inode under a disk inode by name
     fn find_inode_id(&self, name: &str, disk_inode: &DiskInode) -> Option<u32> {
         assert!(disk_inode.is_dir());
-        // data of `disk_node` should be array of `Dirent`s
+        // data of `disk_inode` should be array of `Dirent`s
         let file_count = (disk_inode.size as usize) / DIRENT_SZ;
         let mut dirent = DirEntry::new_empty();
         for i in 0..file_count {
@@ -243,9 +244,7 @@ impl Inode {
         self.create_inode(name, DiskInodeType::Directory)
     }
 
-    /// Clear the data in current inode
-    pub fn clear(&self) {
-        let mut fs = self.fs.lock();
+    fn clear_locked(&self, fs: &mut EasyFileSystem) {
         self.modify_disk_inode(|disk_inode| {
             assert!(disk_inode.is_file());
             let size = disk_inode.size;
@@ -261,6 +260,12 @@ impl Inode {
         block_cache_sync_all();
     }
 
+    /// Clear the data in current inode
+    pub fn clear(&self) {
+        let mut fs = self.fs.lock();
+        self.clear_locked(&mut fs);
+    }
+
     /// Read data from current inode
     pub fn read_at(&self, offset: usize, buf: &mut [u8]) -> usize {
         self.read_disk_inode(|disk_inode| disk_inode.read_at(offset, buf, &self.block_device))
@@ -296,4 +301,98 @@ impl Inode {
     pub fn is_file(&self) -> bool {
         self.read_disk_inode(|disk_inode| disk_inode.is_file())
     }
+
+    /// Get link number
+    pub fn nlink(&self) -> u32 {
+        self.read_disk_inode(|disk_inode| disk_inode.nlink)
+    }
+
+    /// Create hard link `name` from `src`
+    pub fn link(&self, name: &str, src: &Inode) -> Option<Arc<Inode>> {
+        let mut fs = self.fs.lock();
+
+        let op = |root_inode: &DiskInode| {
+            assert!(root_inode.is_dir());
+            self.find_inode_id(name, root_inode)
+        };
+        // exist already
+        if self.read_disk_inode(op).is_some() {
+            return None;
+        }
+
+        // add dirent under self
+        self.modify_disk_inode(|disk_inode| {
+            let file_count = (disk_inode.size as usize) / DIRENT_SZ;
+            let new_size = (file_count + 1) * DIRENT_SZ;
+            self.increase_size(new_size as u32, disk_inode, &mut fs);
+            let dirent = DirEntry::new(name, src.inode_id);
+            disk_inode.write_at(
+                file_count * DIRENT_SZ,
+                dirent.as_bytes(),
+                &self.block_device,
+            );
+        });
+        // inc src nlink
+        src.modify_disk_inode(|disk_inode| disk_inode.nlink += 1);
+        Some(Arc::new(Self::clone(src)))
+    }
+
+    /// Remove hard link (return if removed successfully)
+    pub fn unlink(&self, name: &str) -> bool {
+        let mut fs = self.fs.lock();
+        // self is dir && "name" exists
+        let target = self.modify_disk_inode(|disk_inode| {
+            if !disk_inode.is_dir() {
+                return None;
+            }
+            let file_count = (disk_inode.size as usize) / DIRENT_SZ;
+            let mut dirent = DirEntry::new_empty();
+            let mut swap = DirEntry::new_empty();
+            match (0..file_count).position(|i| {
+                assert_eq!(
+                    disk_inode.read_at(i * DIRENT_SZ, dirent.as_bytes_mut(), &self.block_device),
+                    DIRENT_SZ
+                );
+                dirent.name() == name
+            }) {
+                Some(i) => {
+                    // target
+                    let target_inode_id = dirent.inode_number();
+                    let (target_block_id, target_block_offset) =
+                        fs.get_disk_inode_pos(target_inode_id);
+                    let target = Self::new(
+                        target_inode_id,
+                        target_block_id,
+                        target_block_offset,
+                        self.fs.clone(),
+                        self.block_device.clone(),
+                    );
+                    // we don't actually delete i-th, but swap last to i-th, and decrease disk_inode.size only
+                    // in real world we should decrease data of this dir's actual space (at proper time?)
+                    disk_inode.read_at(
+                        (file_count - 1) * DIRENT_SZ,
+                        swap.as_bytes_mut(),
+                        &self.block_device,
+                    );
+                    disk_inode.write_at(i * DIRENT_SZ, swap.as_bytes(), &self.block_device);
+                    disk_inode.size -= DIRENT_SZ as u32;
+                    Some(target)
+                }
+                _ => None, // no such file
+            }
+        });
+        // clear target's data if link decrease to 0
+        if let Some(target) = target {
+            if target.modify_disk_inode(|disk_inode| {
+                disk_inode.nlink -= 1;
+                disk_inode.nlink
+            }) == 0
+            {
+                target.clear_locked(&mut fs);
+            }
+            true
+        } else {
+            false
+        }
+    }
 }

os/src/fs/inode.rs

@@ -149,6 +149,19 @@ pub fn open_file_at(base: &Inode, name: &str, flags: OpenFlags) -> Option<Arc<OS
     }
 }
 
+/// Unlink file relative to base TODO move to fs.rs?
+pub fn unlink_file_at(base: &Inode, name: &str) -> bool {
+    let (path, fname) = match name.rsplit_once('/') {
+        Some(v) => v,
+        _ => (".", name),
+    };
+
+    match base.find(path) {
+        Some(parent) => parent.unlink(fname),
+        _ => false,
+    }
+}
+
 pub fn find_file(path: &str) -> Option<Arc<OSInode>> {
     assert!(path.starts_with('/'));
     ROOT_INODE

os/src/fs/mod.rs

@@ -4,9 +4,7 @@ use crate::{cast::DowncastArc, mm::UserBuffer};
 
 mod inode;
 mod stdio;
-pub use inode::{
-    find_file, ls_root, name_for_inode, open_file, open_file_at, OSInode, OpenFlags, ROOT_INODE,
-};
+pub use inode::*;
 pub use stdio::{Stdin, Stdout};
 
 pub trait File: Any + Send + Sync {