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.
layout.rs 14.24 KiB
1 
use super::{get_block_cache, BlockDevice, BLOCK_SZ};
2 
use alloc::sync::Arc;
3 
use alloc::vec::Vec;
4 
use core::fmt::{Debug, Formatter, Result};
5
6 
const EFS_MAGIC: u32 = 0x3b800001;
7 
const INODE_DIRECT_COUNT: usize = 28;
8 
const NAME_LENGTH_LIMIT: usize = 27;
9 
const INODE_INDIRECT1_COUNT: usize = BLOCK_SZ / 4;
10 
const INODE_INDIRECT2_COUNT: usize = INODE_INDIRECT1_COUNT * INODE_INDIRECT1_COUNT;
11 
const DIRECT_BOUND: usize = INODE_DIRECT_COUNT;
12 
const INDIRECT1_BOUND: usize = DIRECT_BOUND + INODE_INDIRECT1_COUNT;
13 
#[allow(unused)]
14 
const INDIRECT2_BOUND: usize = INDIRECT1_BOUND + INODE_INDIRECT2_COUNT;
15
16 
#[repr(C)]
17 
pub struct SuperBlock {
18 
    magic: u32,
19 
    pub total_blocks: u32,
20 
    pub inode_bitmap_blocks: u32,
21 
    pub inode_area_blocks: u32,
22 
    pub data_bitmap_blocks: u32,
23 
    pub data_area_blocks: u32,
24 
}
25
26 
impl Debug for SuperBlock {
27 
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
28 
        f.debug_struct("SuperBlock")
29 
            .field("total_blocks", &self.total_blocks)
30 
            .field("inode_bitmap_blocks", &self.inode_bitmap_blocks)
31 
            .field("inode_area_blocks", &self.inode_area_blocks)
32 
            .field("data_bitmap_blocks", &self.data_bitmap_blocks)
33 
            .field("data_area_blocks", &self.data_area_blocks)
34 
            .finish()
35 
    }
36 
}
37
38 
impl SuperBlock {
39 
    pub fn initialize(
40 
        &mut self,
41 
        total_blocks: u32,
42 
        inode_bitmap_blocks: u32,
43 
        inode_area_blocks: u32,
44 
        data_bitmap_blocks: u32,
45 
        data_area_blocks: u32,
46 
    ) {
47 
        *self = Self {
48 
            magic: EFS_MAGIC,
49 
            total_blocks,
50 
            inode_bitmap_blocks,
51 
            inode_area_blocks,
52 
            data_bitmap_blocks,
53 
            data_area_blocks,
54 
        }
55 
    }
56 
    pub fn is_valid(&self) -> bool {
57 
        self.magic == EFS_MAGIC
58 
    }
59 
}
60
61 
#[derive(PartialEq, Copy, Clone)]
62 
pub enum DiskInodeType {
63 
    File,
64 
    Directory,
65 
}
66
67 
type IndirectBlock = [u32; BLOCK_SZ / 4];
68 
type DataBlock = [u8; BLOCK_SZ];
69
70 
#[repr(C)]
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
pub struct DiskInode { pub size: u32, pub direct: [u32; INODE_DIRECT_COUNT], pub indirect1: u32, pub indirect2: u32, pub type_: DiskInodeType, } impl DiskInode { /// indirect1 and indirect2 block are allocated only when they are needed. pub fn initialize(&mut self, type_: DiskInodeType) { self.size = 0; self.direct.iter_mut().for_each(|v| *v = 0); self.indirect1 = 0; self.indirect2 = 0; self.type_ = type_; } pub fn is_dir(&self) -> bool { self.type_ == DiskInodeType::Directory } #[allow(unused)] pub fn is_file(&self) -> bool { self.type_ == DiskInodeType::File } /// Return block number correspond to size. pub fn data_blocks(&self) -> u32 { Self::_data_blocks(self.size) } fn _data_blocks(size: u32) -> u32 { (size + BLOCK_SZ as u32 - 1) / BLOCK_SZ as u32 } /// Return number of blocks needed include indirect1/2. pub fn total_blocks(size: u32) -> u32 { let data_blocks = Self::_data_blocks(size) as usize; let mut total = data_blocks as usize; // indirect1 if data_blocks > INODE_DIRECT_COUNT { total += 1; } // indirect2 if data_blocks > INDIRECT1_BOUND { total += 1; // sub indirect1 total += (data_blocks - INDIRECT1_BOUND + INODE_INDIRECT1_COUNT - 1) / INODE_INDIRECT1_COUNT; } total as u32 } pub fn blocks_num_needed(&self, new_size: u32) -> u32 { assert!(new_size >= self.size); Self::total_blocks(new_size) - Self::total_blocks(self.size) } pub fn get_block_id(&self, inner_id: u32, block_device: &Arc<dyn BlockDevice>) -> u32 { let inner_id = inner_id as usize; if inner_id < INODE_DIRECT_COUNT { self.direct[inner_id] } else if inner_id < INDIRECT1_BOUND { get_block_cache(self.indirect1 as usize, Arc::clone(block_device)) .lock() .read(0, |indirect_block: &IndirectBlock| { indirect_block[inner_id - INODE_DIRECT_COUNT] }) } else { let last = inner_id - INDIRECT1_BOUND; let indirect1 = get_block_cache(self.indirect2 as usize, Arc::clone(block_device)) .lock() .read(0, |indirect2: &IndirectBlock| { indirect2[last / INODE_INDIRECT1_COUNT] }); get_block_cache(indirect1 as usize, Arc::clone(block_device))