Skip to content
GitLab
Select Git revision
  • game default
  • master
  • match
  • fat32_dev
  • heap_dev
  • k210_dev
  • test_oskernel
  • vfs_dev
  • driver_dev
  • proc_dev
Find file BlameHistoryPermalink
Forked from 破败王者之剑 / OSKernel2022-LOS
Source project has a limited visibility.
efs.rs 5.51 KiB
1 
use super::{
2 
    block_cache_sync_all, get_block_cache, Bitmap, BlockDevice, DiskInode, DiskInodeType, Inode,
3 
    SuperBlock,
4 
};
5 
use crate::BLOCK_SZ;
6 
use alloc::sync::Arc;
7 
use spin::Mutex;
8
9 
pub struct EasyFileSystem {
10 
    pub block_device: Arc<dyn BlockDevice>,
11 
    pub inode_bitmap: Bitmap,
12 
    pub data_bitmap: Bitmap,
13 
    inode_area_start_block: u32,
14 
    data_area_start_block: u32,
15 
}
16
17 
type DataBlock = [u8; BLOCK_SZ];
18
19 
impl EasyFileSystem {
20 
    pub fn create(
21 
        block_device: Arc<dyn BlockDevice>,
22 
        total_blocks: u32,
23 
        inode_bitmap_blocks: u32,
24 
    ) -> Arc<Mutex<Self>> {
25 
        // calculate block size of areas & create bitmaps
26 
        let inode_bitmap = Bitmap::new(1, inode_bitmap_blocks as usize);
27 
        let inode_num = inode_bitmap.maximum();
28 
        let inode_area_blocks =
29 
            ((inode_num * core::mem::size_of::<DiskInode>() + BLOCK_SZ - 1) / BLOCK_SZ) as u32;
30 
        let inode_total_blocks = inode_bitmap_blocks + inode_area_blocks;
31 
        let data_total_blocks = total_blocks - 1 - inode_total_blocks;
32 
        let data_bitmap_blocks = (data_total_blocks + 4096) / 4097;
33 
        let data_area_blocks = data_total_blocks - data_bitmap_blocks;
34 
        let data_bitmap = Bitmap::new(
35 
            (1 + inode_bitmap_blocks + inode_area_blocks) as usize,
36 
            data_bitmap_blocks as usize,
37 
        );
38 
        let mut efs = Self {
39 
            block_device: Arc::clone(&block_device),
40 
            inode_bitmap,
41 
            data_bitmap,
42 
            inode_area_start_block: 1 + inode_bitmap_blocks,
43 
            data_area_start_block: 1 + inode_total_blocks + data_bitmap_blocks,
44 
        };
45 
        // clear all blocks
46 
        for i in 0..total_blocks {
47 
            get_block_cache(i as usize, Arc::clone(&block_device))
48 
                .lock()
49 
                .modify(0, |data_block: &mut DataBlock| {
50 
                    for byte in data_block.iter_mut() {
51 
                        *byte = 0;
52 
                    }
53 
                });
54 
        }
55 
        // initialize SuperBlock
56 
        get_block_cache(0, Arc::clone(&block_device)).lock().modify(
57 
            0,
58 
            |super_block: &mut SuperBlock| {
59 
                super_block.initialize(
60 
                    total_blocks,
61 
                    inode_bitmap_blocks,
62 
                    inode_area_blocks,
63 
                    data_bitmap_blocks,
64 
                    data_area_blocks,
65 
                );
66 
            },
67 
        );
68 
        // write back immediately
69 
        // create a inode for root node "/"
70 
        assert_eq!(efs.alloc_inode(), 0);
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
let (root_inode_block_id, root_inode_offset) = efs.get_disk_inode_pos(0); get_block_cache(root_inode_block_id as usize, Arc::clone(&block_device)) .lock() .modify(root_inode_offset, |disk_inode: &mut DiskInode| { disk_inode.initialize(DiskInodeType::Directory); }); block_cache_sync_all(); Arc::new(Mutex::new(efs)) } pub fn open(block_device: Arc<dyn BlockDevice>) -> Arc<Mutex<Self>> { // read SuperBlock get_block_cache(0, Arc::clone(&block_device)) .lock() .read(0, |super_block: &SuperBlock| { assert!(super_block.is_valid(), "Error loading EFS!"); let inode_total_blocks = super_block.inode_bitmap_blocks + super_block.inode_area_blocks; let efs = Self { block_device, inode_bitmap: Bitmap::new(1, super_block.inode_bitmap_blocks as usize), data_bitmap: Bitmap::new( (1 + inode_total_blocks) as usize, super_block.data_bitmap_blocks as usize, ), inode_area_start_block: 1 + super_block.inode_bitmap_blocks, data_area_start_block: 1 + inode_total_blocks + super_block.data_bitmap_blocks, }; Arc::new(Mutex::new(efs)) }) } pub fn root_inode(efs: &Arc<Mutex<Self>>) -> Arc<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 Arc::new(Inode::new(block_id, block_offset, Arc::clone(efs), block_device)) } 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; let block_id = self.inode_area_start_block + inode_id / inodes_per_block; ( block_id, (inode_id % inodes_per_block) as usize * inode_size, ) } pub fn get_data_block_id(&self, data_block_id: u32) -> u32 { self.data_area_start_block + data_block_id } pub fn alloc_inode(&mut self) -> u32 { self.inode_bitmap.alloc(&self.block_device).unwrap() as u32 } /// 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 } pub fn dealloc_data(&mut self, block_id: u32) { get_block_cache(block_id as usize, Arc::clone(&self.block_device)) .lock() .modify(0, |data_block: &mut DataBlock| { data_block.iter_mut().for_each(|p| { *p = 0; })
141142143144145146147148
}); self.data_bitmap.dealloc( &self.block_device, (block_id - self.data_area_start_block) as usize, ) } }