Refactor easy-fs

Author: wyfcyx

.gitignore

@@ -6,4 +6,8 @@ os/Cargo.lock
 user/target/*
 user/.idea/*
 user/Cargo.lock
+easy-fs/Cargo.lock
+easy-fs/target/*
+easy-fs-fuse/Cargo.lock
+easy-fs-fuse/target/*
 tools/

easy-fs-fuse/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "easy-fs-fuse"
+version = "0.1.0"
+authors = ["Yifan Wu <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = "2.33.3"
+easy-fs = { path = "../easy-fs" }
+rand = "0.8.0"

easy-fs/src/bin/main.rs renamed to easy-fs-fuse/src/main.rs

@@ -1,14 +1,12 @@
-extern crate easy_fs;
-extern crate alloc;
-
 use easy_fs::{
     BlockDevice,
     EasyFileSystem,
 };
 use std::fs::{File, OpenOptions, read_dir};
 use std::io::{Read, Write, Seek, SeekFrom};
 use std::sync::Mutex;
-use alloc::sync::Arc;
+use std::sync::Arc;
+use clap::{Arg, App};
 
 const BLOCK_SZ: usize = 512;
 
@@ -34,15 +32,30 @@ fn main() {
     easy_fs_pack().expect("Error when packing easy-fs!");
 }
 
-static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";
-
 fn easy_fs_pack() -> std::io::Result<()> {
+    let matches = App::new("EasyFileSystem packer")
+        .arg(Arg::with_name("source")
+            .short("s")
+            .long("source")
+            .takes_value(true)
+            .help("Executable source dir(with backslash)")
+        )
+        .arg(Arg::with_name("target")
+            .short("t")
+            .long("target")
+            .takes_value(true)
+            .help("Executable target dir(with backslash)")    
+        )
+        .get_matches();
+    let src_path = matches.value_of("source").unwrap();
+    let target_path = matches.value_of("target").unwrap();
+    println!("src_path = {}\ntarget_path = {}", src_path, target_path);
     let block_file = Arc::new(BlockFile(Mutex::new({
         let f = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
-            .open(format!("{}{}", TARGET_PATH, "fs.img"))?;
+            .open(format!("{}{}", target_path, "fs.img"))?;
         f.set_len(8192 * 512).unwrap();
         f
     })));
@@ -53,7 +66,7 @@ fn easy_fs_pack() -> std::io::Result<()> {
         1,
     );
     let root_inode = Arc::new(EasyFileSystem::root_inode(&efs));
-    let apps: Vec<_> = read_dir("../user/src/bin")
+    let apps: Vec<_> = read_dir(src_path)
         .unwrap()
         .into_iter()
         .map(|dir_entry| {
@@ -64,7 +77,7 @@ fn easy_fs_pack() -> std::io::Result<()> {
         .collect();
     for app in apps {
         // load app data from host file system
-        let mut host_file = File::open(format!("{}{}", TARGET_PATH, app)).unwrap();
+        let mut host_file = File::open(format!("{}{}", target_path, app)).unwrap();
         let mut all_data: Vec<u8> = Vec::new();
         host_file.read_to_end(&mut all_data).unwrap();
         // create a file in easy-fs
@@ -79,22 +92,24 @@ fn easy_fs_pack() -> std::io::Result<()> {
     Ok(())
 }
 
-/*
 #[test]
 fn efs_test() -> std::io::Result<()> {
-    let block_file = Arc::new(BlockFile(Mutex::new(
-        OpenOptions::new()
+    let block_file = Arc::new(BlockFile(Mutex::new({
+        let f = OpenOptions::new()
             .read(true)
             .write(true)
-            .open("target/fs.img")?
-    )));
+            .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 mut root_inode = EasyFileSystem::root_inode(&efs);
+    let root_inode = EasyFileSystem::root_inode(&efs);
     root_inode.create("filea");
     root_inode.create("fileb");
     for name in root_inode.ls() {
@@ -146,5 +161,4 @@ fn efs_test() -> std::io::Result<()> {
     random_str_test((12 + 128) * BLOCK_SZ);
 
     Ok(())
-}
- */
+}

easy-fs/Cargo.toml

@@ -8,5 +8,4 @@ edition = "2018"
 
 [dependencies]
 spin = "0.7.0"
-lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
-#rand = "0.8.0"
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }

easy-fs/build.rs

@@ -1,7 +1,9 @@
 use alloc::sync::Arc;
-use super::BlockDevice;
-use super::Dirty;
-use super::BLOCK_SZ;
+use super::{
+    BlockDevice,
+    BLOCK_SZ,
+    get_block_cache,
+};
 
 type BitmapBlock = [u64; 64];
 
@@ -26,41 +28,45 @@ impl Bitmap {
             blocks,
         }
     }
+
     pub fn alloc(&self, block_device: &Arc<dyn BlockDevice>) -> Option<usize> {
         for block_id in 0..self.blocks {
-            let mut dirty_bitmap_block: Dirty<BitmapBlock> = Dirty::new(
+            let pos = get_block_cache(
                 block_id + self.start_block_id as usize,
-                0,
-                block_device.clone()
-            );
-            let bitmap_block = dirty_bitmap_block.get_mut();
-            if let Some((bits64_pos, inner_pos)) = bitmap_block
-                .iter()
-                .enumerate()
-                .find(|(_, bits64)| **bits64 != u64::MAX)
-                .map(|(bits64_pos, bits64)| {
-                    (bits64_pos, bits64.trailing_ones() as usize)
-                }) {
-                // modify cache
-                bitmap_block[bits64_pos] |= 1u64 << inner_pos;
-                return Some(block_id * BLOCK_BITS + bits64_pos * 64 + inner_pos as usize);
-                // after dirty is dropped, data will be written back automatically
+                Arc::clone(block_device),
+            ).lock().modify(0, |bitmap_block: &mut BitmapBlock| {
+                if let Some((bits64_pos, inner_pos)) = bitmap_block
+                    .iter()
+                    .enumerate()
+                    .find(|(_, bits64)| **bits64 != u64::MAX)
+                    .map(|(bits64_pos, bits64)| {
+                        (bits64_pos, bits64.trailing_ones() as usize)
+                    }) {
+                    // modify cache
+                    bitmap_block[bits64_pos] |= 1u64 << inner_pos;
+                    Some(block_id * BLOCK_BITS + bits64_pos * 64 + inner_pos as usize)
+                } else {
+                    None
+                }
+            });
+            if pos.is_some() {
+                return pos;
             }
         }
         None
     }
+
     pub fn dealloc(&self, block_device: &Arc<dyn BlockDevice>, bit: usize) {
         let (block_pos, bits64_pos, inner_pos) = decomposition(bit);
-        let mut dirty_bitmap_block: Dirty<BitmapBlock> = Dirty::new(
+        get_block_cache(
             block_pos + self.start_block_id,
-            0,
-            block_device.clone(),
-        );
-        dirty_bitmap_block.modify(|bitmap_block| {
+            Arc::clone(block_device)
+        ).lock().modify(0, |bitmap_block: &mut BitmapBlock| {
             assert!(bitmap_block[bits64_pos] & (1u64 << inner_pos) > 0);
             bitmap_block[bits64_pos] -= 1u64 << inner_pos;
         });
     }
+
     pub fn maximum(&self) -> usize {
         self.blocks * BLOCK_BITS
     }

easy-fs/src/bitmap.rs

@@ -1,86 +1,128 @@
 use super::{
-    BlockDevice,
     BLOCK_SZ,
+    BlockDevice,
 };
-use alloc::sync::{Arc, Weak};
-use alloc::collections::BTreeMap;
+use alloc::collections::VecDeque;
+use alloc::sync::Arc;
 use lazy_static::*;
 use spin::Mutex;
 
 pub struct BlockCache {
     cache: [u8; BLOCK_SZ],
     block_id: usize,
     block_device: Arc<dyn BlockDevice>,
+    modified: bool,
 }
 
 impl BlockCache {
-    pub fn new(block_id: usize, block_device: Arc<dyn BlockDevice>) -> Self {
+    /// Load a new BlockCache from disk.
+    pub fn new(
+        block_id: usize, 
+        block_device: Arc<dyn BlockDevice>
+    ) -> Self {
         let mut cache = [0u8; BLOCK_SZ];
         block_device.read_block(block_id, &mut cache);
         Self {
             cache,
             block_id,
             block_device,
+            modified: false,
         }
     }
-    pub fn start_addr(&self, offset: usize) -> usize {
+
+    fn addr_of_offset(&self, offset: usize) -> usize {
         &self.cache[offset] as *const _ as usize
     }
+
+    pub fn get_ref<T>(&self, offset: usize) -> &T where T: Sized {
+        let type_size = core::mem::size_of::<T>();
+        assert!(offset + type_size <= BLOCK_SZ);
+        let addr = self.addr_of_offset(offset);
+        unsafe { &*(addr as *const T) } 
+    }
+
+    pub fn get_mut<T>(&mut self, offset: usize) -> &mut T where T: Sized {
+        let type_size = core::mem::size_of::<T>();
+        assert!(offset + type_size <= BLOCK_SZ);
+        self.modified = true;
+        let addr = self.addr_of_offset(offset);
+        unsafe { &mut *(addr as *mut T) }
+    }
+
+    pub fn read<T, V>(&self, offset: usize, f: impl FnOnce(&T) -> V) -> V {
+        f(self.get_ref(offset))
+    }
+
+    pub fn modify<T, V>(&mut self, offset:usize, f: impl FnOnce(&mut T) -> V) -> V {
+        f(self.get_mut(offset))
+    }
+
+    pub fn sync(&mut self) {
+        if self.modified {
+            self.modified = false;
+            self.block_device.write_block(self.block_id, &self.cache);
+        }
+    }
 }
 
 impl Drop for BlockCache {
     fn drop(&mut self) {
-        // write back
-        self.block_device.write_block(self.block_id, &self.cache);
-        // invalid in block cache manager
-        BLOCK_CACHE_MANAGER.lock().invalid(self.block_id);
+        self.sync()
     }
 }
 
-pub struct BlockCacheManager {
-    map: BTreeMap<usize, Weak<BlockCache>>,
-}
+const BLOCK_CACHE_SIZE: usize = 16;
 
-lazy_static! {
-    static ref BLOCK_CACHE_MANAGER: Mutex<BlockCacheManager> = Mutex::new(
-        BlockCacheManager::new()
-    );
+pub struct BlockCacheManager {
+    queue: VecDeque<(usize, Arc<Mutex<BlockCache>>)>,
 }
 
 impl BlockCacheManager {
     pub fn new() -> Self {
-        Self { map: BTreeMap::new() }
+        Self { queue: VecDeque::new() }
     }
-    pub fn get(
+
+    pub fn get_block_cache(
         &mut self,
         block_id: usize,
-        block_device: Arc<dyn BlockDevice>
-    ) -> Arc<BlockCache> {
-        if let Some(block_cache) = self.map.get(&block_id) {
-            // return cloned
-            block_cache.upgrade().unwrap().clone()
+        block_device: Arc<dyn BlockDevice>,
+    ) -> Arc<Mutex<BlockCache>> {
+        if let Some(pair) = self.queue
+            .iter()
+            .find(|pair| pair.0 == block_id) {
+                Arc::clone(&pair.1)
         } else {
-            // fetch from disk
-            let block_cache = Arc::new(BlockCache::new(
-                block_id,
-                block_device.clone()
+            // substitute
+            if self.queue.len() == BLOCK_CACHE_SIZE {
+                // from front to tail
+                if let Some((idx, _)) = self.queue
+                    .iter()
+                    .enumerate()
+                    .find(|(_, pair)| Arc::strong_count(&pair.1) == 1) {
+                    self.queue.drain(idx..=idx);
+                } else {
+                    panic!("Run out of BlockCache!");
+                }
+            }
+            // load block into mem and push back
+            let block_cache = Arc::new(Mutex::new(
+                BlockCache::new(block_id, Arc::clone(&block_device))
             ));
-            self.map.insert(
-                block_id,
-                Arc::downgrade(&block_cache),
-            );
-            // return
+            self.queue.push_back((block_id, Arc::clone(&block_cache)));
             block_cache
         }
     }
-    pub fn invalid(&mut self, block_id: usize) {
-        assert!(self.map.remove(&block_id).is_some());
-    }
+}
+
+lazy_static! {
+    pub static ref BLOCK_CACHE_MANAGER: Mutex<BlockCacheManager> = Mutex::new(
+        BlockCacheManager::new()
+    );
 }
 
 pub fn get_block_cache(
     block_id: usize,
     block_device: Arc<dyn BlockDevice>
-) -> Arc<BlockCache> {
-    BLOCK_CACHE_MANAGER.lock().get(block_id, block_device)
+) -> Arc<Mutex<BlockCache>> {
+    BLOCK_CACHE_MANAGER.lock().get_block_cache(block_id, block_device)
 }