From 9d1368b0ea380a9446b4697af668d1685464b6c7 Mon Sep 17 00:00:00 2001 From: Chuyan Zhang Date: Sun, 26 Nov 2023 02:33:01 -0800 Subject: more code idk what they are im so tired ohno --- src/disk/allocation.rs | 164 +++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 140 insertions(+), 24 deletions(-) (limited to 'src/disk/allocation.rs') diff --git a/src/disk/allocation.rs b/src/disk/allocation.rs index 57cca0e..b88e7d5 100644 --- a/src/disk/allocation.rs +++ b/src/disk/allocation.rs @@ -1,7 +1,10 @@ -use crate::disk::block::{Block, DataBlock, DoubleIndirectBlock, IndirectBlock, TripleIndirectBlock}; -use crate::disk::inode::{DIRECT_NUMBER, Inode}; -use crate::memory::cached_block::{CachedBlock, convert}; +use crate::disk::block::{ + Block, DataBlock, DoubleIndirectBlock, IndirectBlock, TripleIndirectBlock, +}; +use crate::disk::inode::{Inode, DIRECT_NUMBER}; +use crate::memory::cached_block::{convert, CachedBlock}; use crate::{AyaFS, INODE_PER_BLOCK}; +use libc::c_int; impl AyaFS { /// 为 Inode 分配新 block, 返回 block 的编号和它在 inode 内的编号 @@ -13,6 +16,8 @@ impl AyaFS { // println!("allocating {} for direct", block_index); *index = block_index; inode.n_blocks += 1; + // 初始化这个 block + self.init_block(block_index as usize); // 当调用 get_inode_mut 拿出 &mut Inode 的时候对应的 block 在 cache 里已经脏了 return Some((block_index, index_within_direct)); } @@ -24,12 +29,16 @@ impl AyaFS { .data_bitmap .allocate() .expect("No free space for new block") as u32; + self.init_block(inode.single_indirect as usize); // println!("allocating {} for indirect", inode.single_indirect); } // 在 indirect block 里尝试分配 - if let Some((block_index, index_within_indirect)) = self.allocate_in_indirect(inode.single_indirect) { + if let Some((block_index, index_within_indirect)) = + self.allocate_in_indirect(inode.single_indirect) + { // println!("allocating {} in indirect", block_index); inode.n_blocks += 1; + let index_within_block = DIRECT_NUMBER + index_within_indirect; return Some((block_index, index_within_block)); } @@ -40,10 +49,13 @@ impl AyaFS { .data_bitmap .allocate() .expect("No free space for new block") as u32; + self.init_block(inode.double_indirect as usize); // println!("allocating {} for double indirect", inode.double_indirect); } // 在 double indirect block 里尝试分配 - if let Some((block_index, index_within_double)) = self.alloc_in_double_indirect(inode.double_indirect) { + if let Some((block_index, index_within_double)) = + self.alloc_in_double_indirect(inode.double_indirect) + { // println!("allocating {} in double indirect", block_index); inode.n_blocks += 1; let index_within_block = DIRECT_NUMBER + INODE_PER_BLOCK + index_within_double; @@ -56,13 +68,19 @@ impl AyaFS { .data_bitmap .allocate() .expect("No free space for new block") as u32; + self.init_block(inode.triple_indirect as usize); // println!("allocating {} for triple indirect", inode.triple_indirect); } // 在 double indirect block 里尝试分配 - if let Some((block_index, index_within_triple)) = self.alloc_in_triple_indirect(inode.triple_indirect) { + if let Some((block_index, index_within_triple)) = + self.alloc_in_triple_indirect(inode.triple_indirect) + { // println!("allocating {} in triple indirect", block_index); inode.n_blocks += 1; - let index_within_block = DIRECT_NUMBER + INODE_PER_BLOCK + INODE_PER_BLOCK * INODE_PER_BLOCK + index_within_triple; + let index_within_block = DIRECT_NUMBER + + INODE_PER_BLOCK + + INODE_PER_BLOCK * INODE_PER_BLOCK + + index_within_triple; return Some((block_index, index_within_block)); } None @@ -79,10 +97,13 @@ impl AyaFS { { // println!("found indirect block with number {}", indirect_entry); let mut indirect_block = block.clone(); - for (index_within_indirect, entry) in indirect_block.block.entries.iter_mut().enumerate() { + for (index_within_indirect, entry) in + indirect_block.block.entries.iter_mut().enumerate() + { if self.data_bitmap.query(*entry as usize) == false { indirect_block.dirty = true; // 把这个块标记为 dirty let block_index = self.data_bitmap.allocate().expect("No free space") as u32; + self.init_block(block_index as usize); *entry = block_index; self.update_block(indirect_block); return Some((block_index, index_within_indirect)); @@ -101,18 +122,26 @@ impl AyaFS { { let mut double_indirect_block = block.clone(); let mut double_indirect_modified = false; - for (index_within_double_indirect, indirect_entry) in double_indirect_block.block.indirect.iter_mut().enumerate() { + for (index_within_double_indirect, indirect_entry) in + double_indirect_block.block.indirect.iter_mut().enumerate() + { if self.data_bitmap.query(*indirect_entry as usize) == false { double_indirect_block.dirty = true; double_indirect_modified = true; - *indirect_entry = self.data_bitmap.allocate().expect("No free space") as u32; + + let indirect_index = self.data_bitmap.allocate().expect("No free space"); + *indirect_entry = indirect_index as u32; + self.init_block(indirect_index); } - if let Some((block_index, index_within_indirect)) = self.allocate_in_indirect(*indirect_entry) { + if let Some((block_index, index_within_indirect)) = + self.allocate_in_indirect(*indirect_entry) + { if double_indirect_modified { self.update_block(double_indirect_block); } - let index_within_double = index_within_double_indirect * INODE_PER_BLOCK + index_within_indirect; + let index_within_double = + index_within_double_indirect * INODE_PER_BLOCK + index_within_indirect; return Some((block_index, index_within_double)); } } @@ -129,18 +158,29 @@ impl AyaFS { { let mut triple_indirect_block = block.clone(); let mut triple_indirect_modified = false; - for (index_within_triple_indirect, double_indirect_entry) in triple_indirect_block.block.double_indirect.iter_mut().enumerate() { + for (index_within_triple_indirect, double_indirect_entry) in triple_indirect_block + .block + .double_indirect + .iter_mut() + .enumerate() + { if self.data_bitmap.query(*double_indirect_entry as usize) == false { triple_indirect_block.dirty = true; triple_indirect_modified = true; - *double_indirect_entry = - self.data_bitmap.allocate().expect("No free space") as u32; + + let double_indirect_index = self.data_bitmap.allocate().expect("No free space"); + *double_indirect_entry = double_indirect_index as u32; + self.init_block(double_indirect_index) } - if let Some((block_index, index_within_double_indirect)) = self.alloc_in_double_indirect(*double_indirect_entry) { + if let Some((block_index, index_within_double_indirect)) = + self.alloc_in_double_indirect(*double_indirect_entry) + { if triple_indirect_modified { self.update_block(triple_indirect_block); } - let index_within_triple = index_within_triple_indirect * INODE_PER_BLOCK * INODE_PER_BLOCK + index_within_double_indirect; + let index_within_triple = + index_within_triple_indirect * INODE_PER_BLOCK * INODE_PER_BLOCK + + index_within_double_indirect; return Some((block_index, index_within_triple)); } } @@ -150,6 +190,70 @@ impl AyaFS { } impl AyaFS { + pub(crate) fn deallocate_all_blocks_for(&mut self, inode: &Inode) -> Result<(), c_int> { + // 遍历 direct block 并删除 + for block_index in inode.direct { + self.data_bitmap.deallocate(block_index as usize); + } + + // 遍历 indirect block 并删除 + if self.data_bitmap.query(inode.single_indirect as usize) { + let indirect = self + .get_block::(inode.single_indirect as usize) + .unwrap(); + for block_index in indirect.block.entries { + self.data_bitmap.deallocate(block_index as usize); + } + self.data_bitmap.deallocate(inode.single_indirect as usize); + } + + // 遍历 double indirect block 并删除 + if self.data_bitmap.query(inode.double_indirect as usize) { + let double_indirect = self + .get_block::(inode.double_indirect as usize) + .unwrap(); + for indirect_block_index in double_indirect.block.indirect { + if let Some(indirect) = + self.get_block::(indirect_block_index as usize) + { + for block_index in indirect.block.entries { + self.data_bitmap.deallocate(block_index as usize); + } + self.data_bitmap.deallocate(indirect_block_index as usize); + } + } + self.data_bitmap.deallocate(inode.double_indirect as usize); + } + + // 遍历 triple indirect block 并删除 + if self.data_bitmap.query(inode.triple_indirect as usize) { + let triple_indirect = self + .get_block::(inode.triple_indirect as usize) + .unwrap(); + for double_indirect_block_index in triple_indirect.block.double_indirect { + if let Some(double_indirect) = + self.get_block::(double_indirect_block_index as usize) + { + for indirect_block_index in double_indirect.block.indirect { + if let Some(indirect) = + self.get_block::(indirect_block_index as usize) + { + for block_index in indirect.block.entries { + self.data_bitmap.deallocate(block_index as usize); + } + self.data_bitmap.deallocate(indirect_block_index as usize); + } + } + self.data_bitmap + .deallocate(double_indirect_block_index as usize); + } + } + self.data_bitmap.deallocate(inode.triple_indirect as usize); + } + + Ok(()) + } + /// 从 inode 中删去最后一个 block pub(crate) fn deallocate_block_for(&mut self, inode: &mut Inode) -> Option { // 如果 triple indirect 块存在, 则尝试从中销毁一个块 @@ -294,7 +398,11 @@ impl AyaFS { } impl AyaFS { - fn get_block_index(&mut self, inode: &Inode, mut block_index_within_inode: usize) -> Option { + fn get_block_index( + &mut self, + inode: &Inode, + mut block_index_within_inode: usize, + ) -> Option { // direct block if block_index_within_inode < DIRECT_NUMBER { let block_index = inode.direct[block_index_within_inode] as usize; @@ -335,7 +443,7 @@ impl AyaFS { [block_index_within_inode % INODE_PER_BLOCK] as usize; // 拿到 DirectoryBlock 的 index - return Some(block_index) + return Some(block_index); } } return None; @@ -358,7 +466,7 @@ impl AyaFS { // 取出 double indirect block let indirect_block_index = double_indirect_block.block.indirect [block_index_within_inode % (INODE_PER_BLOCK * INODE_PER_BLOCK) - / INODE_PER_BLOCK] as usize; + / INODE_PER_BLOCK] as usize; // 要找的 entry 在 double indirect block 中的第几个 indirect block if let Some(indirect_block) = self.get_block::(indirect_block_index) { @@ -366,7 +474,7 @@ impl AyaFS { [block_index_within_inode % INODE_PER_BLOCK] as usize; // DirectoryBlock 的 index - return Some(block_index) + return Some(block_index); } } } @@ -374,17 +482,25 @@ impl AyaFS { None } - pub(crate) fn access_block(&mut self, inode: &Inode, block_index_within_inode: usize) -> Option<&CachedBlock> { + pub(crate) fn access_block( + &mut self, + inode: &Inode, + block_index_within_inode: usize, + ) -> Option<&CachedBlock> { self.get_block_index(inode, block_index_within_inode) .map(|block_index| { self.get_block::(block_index).unwrap() // 可以 unwrap 吧这里 ?? }) } - pub(crate) fn access_block_mut(&mut self, inode: &Inode, block_index_within_inode: usize) -> Option<&mut CachedBlock> { + pub(crate) fn access_block_mut( + &mut self, + inode: &Inode, + block_index_within_inode: usize, + ) -> Option<&mut CachedBlock> { self.get_block_index(inode, block_index_within_inode) .map(|block_index| { self.get_block_mut::(block_index).unwrap() // 可以 unwrap 吧这里 ?? }) } -} \ No newline at end of file +} -- cgit v1.2.3-70-g09d2