Init the ch7

Author: Azure-stars

.github/workflows/build.yml

@@ -7,23 +7,6 @@ env:
   rust_toolchain: nightly
 
 jobs:
-  build-doc:
-    if: github.repository == 'LearningOS/rCore-Tutorial-Code'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build doc
-        run: |
-          git clone https://github.com/LearningOS/rCore-Tutorial-Test.git user
-          cd os
-          make
-          cargo doc --no-deps --verbose
-      - name: Push to gh-pages
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./os/target/riscv64gc-unknown-none-elf/doc
-          destination_dir: ${{ github.ref_name }}
   basic-test:
     runs-on: ubuntu-latest
     outputs:
@@ -40,13 +23,13 @@ jobs:
           git clone https://github.com/LearningOS/rCore-Tutorial-Checker.git ci-user
           git clone https://github.com/LearningOS/rCore-Tutorial-Test.git ci-user/user
           ID=`git rev-parse --abbrev-ref HEAD | grep -oP 'ch\K[0-9]'`
-          cd ci-user && make test CHAPTER=$ID passwd=${{ secrets.BASE_TEST_TOKEN }} > ../output.txt
+          cd ci-user && make test CHAPTER=$ID passwd=${{ secrets.BASE_TEST_TOKEN }} OFFLINE=1 > ../output.txt
           cat ../output.txt
       - name: end
         id: end
         run: |
-          cat output.txt | grep -a "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}"
-          cat output.txt | grep -a "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" >> $GITHUB_OUTPUT
+          cat output.txt | grep "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}"
+          cat output.txt | grep "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" >> $GITHUB_OUTPUT
   deploy:
     if: github.repository != 'LearningOS/rCore-Tutorial-Code'
     name: Deploy to pages

easy-fs/src/bitmap.rs

@@ -1,31 +1,30 @@
 use super::{get_block_cache, BlockDevice, BLOCK_SZ};
 use alloc::sync::Arc;
-/// A bitmap block
+
 type BitmapBlock = [u64; 64];
-/// Number of bits in a block
+
 const BLOCK_BITS: usize = BLOCK_SZ * 8;
-/// A bitmap
+
 pub struct Bitmap {
     start_block_id: usize,
     blocks: usize,
 }
 
-/// Decompose bits into (block_pos, bits64_pos, inner_pos)
+/// Return (block_pos, bits64_pos, inner_pos)
 fn decomposition(mut bit: usize) -> (usize, usize, usize) {
     let block_pos = bit / BLOCK_BITS;
     bit %= BLOCK_BITS;
     (block_pos, bit / 64, bit % 64)
 }
 
 impl Bitmap {
-    /// A new bitmap from start block id and number of blocks
     pub fn new(start_block_id: usize, blocks: usize) -> Self {
         Self {
             start_block_id,
             blocks,
         }
     }
-    /// Allocate a new block from a block device
+
     pub fn alloc(&self, block_device: &Arc<dyn BlockDevice>) -> Option<usize> {
         for block_id in 0..self.blocks {
             let pos = get_block_cache(
@@ -53,7 +52,7 @@ impl Bitmap {
         }
         None
     }
-    /// Deallocate a block
+
     pub fn dealloc(&self, block_device: &Arc<dyn BlockDevice>, bit: usize) {
         let (block_pos, bits64_pos, inner_pos) = decomposition(bit);
         get_block_cache(block_pos + self.start_block_id, Arc::clone(block_device))
@@ -63,7 +62,7 @@ impl Bitmap {
                 bitmap_block[bits64_pos] -= 1u64 << inner_pos;
             });
     }
-    /// Get the max number of allocatable blocks
+
     pub fn maximum(&self) -> usize {
         self.blocks * BLOCK_BITS
     }

easy-fs/src/block_cache.rs

@@ -1,24 +1,23 @@
 use super::{BlockDevice, BLOCK_SZ};
 use alloc::collections::VecDeque;
 use alloc::sync::Arc;
+use alloc::vec;
+use alloc::vec::Vec;
 use lazy_static::*;
 use spin::Mutex;
-/// Cached block inside memory
+
 pub struct BlockCache {
-    /// cached block data
-    cache: [u8; BLOCK_SZ],
-    /// underlying block id
+    cache: Vec<u8>,
     block_id: usize,
-    /// underlying block device
     block_device: Arc<dyn BlockDevice>,
-    /// whether the block is dirty
     modified: bool,
 }
 
 impl BlockCache {
     /// Load a new BlockCache from disk.
     pub fn new(block_id: usize, block_device: Arc<dyn BlockDevice>) -> Self {
-        let mut cache = [0u8; BLOCK_SZ];
+        // for alignment and move effciency
+        let mut cache = vec![0u8; BLOCK_SZ];
         block_device.read_block(block_id, &mut cache);
         Self {
             cache,
@@ -27,7 +26,7 @@ impl BlockCache {
             modified: false,
         }
     }
-    /// Get the address of an offset inside the cached block data
+
     fn addr_of_offset(&self, offset: usize) -> usize {
         &self.cache[offset] as *const _ as usize
     }
@@ -74,7 +73,7 @@ impl Drop for BlockCache {
         self.sync()
     }
 }
-/// Use a block cache of 16 blocks
+
 const BLOCK_CACHE_SIZE: usize = 16;
 
 pub struct BlockCacheManager {
@@ -122,11 +121,10 @@ impl BlockCacheManager {
 }
 
 lazy_static! {
-    /// The global block cache manager
     pub static ref BLOCK_CACHE_MANAGER: Mutex<BlockCacheManager> =
         Mutex::new(BlockCacheManager::new());
 }
-/// Get the block cache corresponding to the given block id and block device
+
 pub fn get_block_cache(
     block_id: usize,
     block_device: Arc<dyn BlockDevice>,
@@ -135,7 +133,7 @@ pub fn get_block_cache(
         .lock()
         .get_block_cache(block_id, block_device)
 }
-/// Sync all block cache to block device
+
 pub fn block_cache_sync_all() {
     let manager = BLOCK_CACHE_MANAGER.lock();
     for (_, cache) in manager.queue.iter() {

easy-fs/src/block_dev.rs

@@ -1,9 +1,6 @@
 use core::any::Any;
-/// Trait for block devices
-/// which reads and writes data in the unit of blocks
+
 pub trait BlockDevice: Send + Sync + Any {
-    ///Read data form block to buffer
     fn read_block(&self, block_id: usize, buf: &mut [u8]);
-    ///Write data from buffer to block
     fn write_block(&self, block_id: usize, buf: &[u8]);
 }

easy-fs/src/efs.rs

@@ -5,22 +5,18 @@ use super::{
 use crate::BLOCK_SZ;
 use alloc::sync::Arc;
 use spin::Mutex;
-///An easy file system on block
+
 pub struct EasyFileSystem {
-    ///Real device
     pub block_device: Arc<dyn BlockDevice>,
-    ///Inode bitmap
     pub inode_bitmap: Bitmap,
-    ///Data bitmap
     pub data_bitmap: Bitmap,
     inode_area_start_block: u32,
     data_area_start_block: u32,
 }
 
 type DataBlock = [u8; BLOCK_SZ];
-/// An easy fs over a block device
+
 impl EasyFileSystem {
-    /// A data block of block size
     pub fn create(
         block_device: Arc<dyn BlockDevice>,
         total_blocks: u32,
@@ -81,7 +77,7 @@ impl EasyFileSystem {
         block_cache_sync_all();
         Arc::new(Mutex::new(efs))
     }
-    /// Open a block device as a filesystem
+
     pub fn open(block_device: Arc<dyn BlockDevice>) -> Arc<Mutex<Self>> {
         // read SuperBlock
         get_block_cache(0, Arc::clone(&block_device))
@@ -103,15 +99,15 @@ impl EasyFileSystem {
                 Arc::new(Mutex::new(efs))
             })
     }
-    /// Get the root inode of the filesystem
+
     pub fn root_inode(efs: &Arc<Mutex<Self>>) -> Inode {
         let block_device = Arc::clone(&efs.lock().block_device);
         // acquire efs lock temporarily
         let (block_id, block_offset) = efs.lock().get_disk_inode_pos(0);
         // release efs lock
         Inode::new(block_id, block_offset, Arc::clone(efs), block_device)
     }
-    /// Get inode by id
+
     pub fn get_disk_inode_pos(&self, inode_id: u32) -> (u32, usize) {
         let inode_size = core::mem::size_of::<DiskInode>();
         let inodes_per_block = (BLOCK_SZ / inode_size) as u32;
@@ -121,20 +117,20 @@ impl EasyFileSystem {
             (inode_id % inodes_per_block) as usize * inode_size,
         )
     }
-    /// Get data block by id
+
     pub fn get_data_block_id(&self, data_block_id: u32) -> u32 {
         self.data_area_start_block + data_block_id
     }
-    /// Allocate a new inode
+
     pub fn alloc_inode(&mut self) -> u32 {
         self.inode_bitmap.alloc(&self.block_device).unwrap() as u32
     }
 
-    /// Allocate a data block
+    /// Return a block ID not ID in the data area.
     pub fn alloc_data(&mut self) -> u32 {
         self.data_bitmap.alloc(&self.block_device).unwrap() as u32 + self.data_area_start_block
     }
-    /// Deallocate a data block
+
     pub fn dealloc_data(&mut self, block_id: u32) {
         get_block_cache(block_id as usize, Arc::clone(&self.block_device))
             .lock()