vapfs/vapfs_ufs
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

single block flush impl

Browse source
This commit is contained in:
husky 2023-08-11 15:04:54 -07:00
parent 9ddefddf66
commit 776657aa6d
No known key found for this signature in database
GPG key ID: 6B3D8CB511646891
2 changed files with 201 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

202
src/lib.rs
View file

@ -5,7 +5,7 @@ extern crate alloc;
use alloc::vec;
use alloc::vec::Vec;
use vapfs::{BlockDevice, Index};
use crate::structs::{Inode, JBRFlags, JMWFlags, JournalBlockWrite, JournalEntry, JournalEntryContents, JournalMultiblockWrite, JournalOperation, ListBlock, Superblock};
use crate::structs::{Inode, InodeFlags, JBRFlags, JMWFlags, JournalBlockWrite, JournalEntry, JournalEntryContents, JournalMultiblockWrite, JournalOperation, ListBlock, Superblock};
pub mod btree;
pub mod structs;
@ -306,6 +306,7 @@ pub fn schedule_single_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, co
target_is_inode: write_to_inode,
target_inode: containing_inode_index,
target_block: otherwise_datablock_index.unwrap_or(0),
real_target_block: 0, // filled in once flushed
source_block: 0, // filled in once allocated
source_block_crc32: 0, // filled in once allocated
};
@ -404,6 +405,14 @@ pub fn schedule_multi_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, con
// note: cLion incorrectly says that this is unsafe, writing to a union is safe
entry.content.multiblock_write.list_block = list_block_index;
entry.content.multiblock_write.flags = JMWFlags::ChosenList as u32;
// calculate the crc32
let mut content_cloned = entry.content.clone();
content_cloned.multiblock_write.flags = 0;
let mut buf: [u8; core::mem::size_of::<JournalEntryContents>()] = [0; core::mem::size_of::<JournalEntryContents>()];
unsafe { core::ptr::write(buf.as_mut_ptr() as *mut JournalEntryContents, content_cloned); }
entry.zeroed_content_crc32 = crc32::crc32(&buf);
if !unsafe { write_journal_entry(entry_index, sb, bd, entry) } {
return None;
}
@ -434,9 +443,7 @@ pub fn schedule_multi_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, con
// if using indirect blocks, only fill out the first (12 - 3) = 9 entries
// otherwise, fill out all 12 entries
if list_block.using_indirect_blocks {
for i in 0..9 {
list_block.direct_block_addresses[i] = allocated_blocks[i];
}
list_block.direct_block_addresses[..9].copy_from_slice(&allocated_blocks[..9]);
// if using indirect blocks, fit the remaining entries into the indirect blocks
// layout is u64 count followed by u64 addresses
@ -536,4 +543,191 @@ pub fn schedule_multi_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, con
// return the journal entry index
Some(entry_index)
}
/// Checks the integrity of a single block write journal entry
/// Returns true if the journal entry is valid, false otherwise
pub fn verify_single_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, journal_entry: &JournalEntry) -> bool {
if journal_entry.operation != JournalOperation::SingleBlockWrite as u32 {
return false;
}
let content = unsafe { journal_entry.content.block_write };
if content.flags > 4 {
return false;
}
let mut content_clone = journal_entry.content.clone();
content_clone.block_write.flags = 0;
let mut buf = [0; core::mem::size_of::<JournalEntryContents>()];
unsafe { core::ptr::write(buf.as_mut_ptr() as *mut JournalEntryContents, content_clone); }
let hash = crc32::crc32(&buf);
if hash != journal_entry.zeroed_content_crc32 {
return false;
}
// check the source data block
let buf = read_datablock(content.source_block, sb, bd);
let crc32 = crc32::crc32(&buf);
if crc32 != content.source_block_crc32 {
return false;
}
// should be all good! (:
true
}
/// Flushes a single block write journal entry
/// Should be safe to call at anytime, and shouldn't corrupt anything if the system crashes
/// or if the journal entry is corrupt
/// Returns false if the journal entry is corrupt, the block device is full, or if the block device is read only
/// Otherwise, returns true
pub fn flush_single_block_write(sb: &Superblock, bd: &mut dyn BlockDevice, entry_index: Index) -> bool {
// read the journal entry
let journal_entry = unsafe { read_journal_entry(entry_index, sb, bd) };
if journal_entry.is_none() {
return false;
}
let mut journal_entry = journal_entry.unwrap();
// verify the journal entry
if !verify_single_block_write(sb, bd, &journal_entry) {
return false;
}
// because everything is verified, we should be able to execute steps 6 through 9 and
// not have to worry about crashes; since the journal entry is good, we can repeat these steps
// until they succeed
let content = unsafe { journal_entry.content.block_write };
if content.flags < 3 && content.flags > 0 {
// source block wasn't written, this entry is corrupt
return false;
}
// if flag is 3, either update inode metadata or copy the data to the destination block
if content.flags == 3 {
if content.target_is_inode {
// copy the data directly to the target inode's block
let buf = read_datablock(content.source_block, sb, bd);
let mut inode_buf: [u8; core::mem::size_of::<Inode>()] = [0; core::mem::size_of::<Inode>()];
inode_buf[0..core::mem::size_of::<Inode>()].clone_from_slice(&buf[0..core::mem::size_of::<Inode>()]);
let inode = unsafe { core::ptr::read(inode_buf.as_ptr() as *const Inode) };
if !unsafe { write_inode(content.target_inode, sb, bd, inode) } {
return false;
}
} else {
// update inode metadata
let inode = read_inode(content.target_inode, sb, bd);
if inode.is_none() {
return false;
}
let mut inode = inode.unwrap();
// target block is either an index into the direct blocks or an indirect block (if greater than 11)
if content.target_block < 12 {
let previous_block = inode.direct_block_addresses[content.target_block as usize];
// update the journal entry
journal_entry.content.block_write.real_target_block = previous_block;
if !unsafe { write_journal_entry(entry_index, sb, bd, journal_entry) } {
return false;
}
inode.direct_block_addresses[content.target_block as usize] = content.source_block;
// update the inode
if !unsafe { write_inode(content.target_inode, sb, bd, inode) } {
return false;
}
} else {
if inode.flags | InodeFlags::INDIRECT as u32 == 0 {
// inode doesn't have indirect blocks, this entry is corrupt
return false;
}
// figure out which indirect block we need to write to (either 1, 2, or 3)
// range 12..(12*2) is indirect block 1
// range (12*2)..(12*3) is indirect block 2
// range (12*3)..(12*4) is indirect block 3
let indirect_block_index = (content.target_block - 12) / 12;
let indirect_block_offset = (content.target_block - 12) % 12;
let indirect_block = inode.direct_block_addresses[indirect_block_index as usize];
let mut indirect_block_buf = read_datablock(indirect_block, sb, bd);
// get the count
let mut count = u64::from_be_bytes(indirect_block_buf.as_slice()[0..8].try_into().unwrap());
// place the source block at index (indirect_block_offset * 8) + 8
let target_index = (indirect_block_offset * 8) + 8;
// if there's already a block at the target index, we need to update the journal entry
if indirect_block_offset < count {
// update the journal entry
journal_entry.content.block_write.real_target_block = u64::from_be_bytes(indirect_block_buf.as_slice()[target_index as usize..(target_index + 8) as usize].try_into().unwrap());
if !unsafe { write_journal_entry(entry_index, sb, bd, journal_entry) } {
return false;
}
}
indirect_block_buf.as_mut_slice()[target_index as usize..(target_index + 8) as usize].clone_from_slice(&content.source_block.to_be_bytes());
// update the count
if count < indirect_block_offset + 1 {
count = indirect_block_offset + 1;
}
indirect_block_buf.as_mut_slice()[0..8].clone_from_slice(&count.to_be_bytes());
// write the indirect block back to the block device
if !unsafe { write_datablock(indirect_block, sb, bd, &indirect_block_buf) } {
return false;
}
}
}
// update journal entry
// note: cLion incorrectly says that this is unsafe, writing to a union is safe
journal_entry.content.block_write.flags = JMWFlags::Written as u32;
if !unsafe { write_journal_entry(entry_index, sb, bd, journal_entry) } {
return false;
}
}
let content = unsafe { journal_entry.content.block_write };
// if flag is 4, deallocate the source block
if content.flags == 4 {
if content.target_is_inode {
let block_to_deallocate = content.source_block; // data was copied
if !unsafe { set_datablock_allocation_status(block_to_deallocate, sb, bd, false) } {
return false;
}
} else {
let block_to_deallocate = content.real_target_block; // data was moved, this should contain the old block
if !unsafe { set_datablock_allocation_status(block_to_deallocate, sb, bd, false) } {
return false;
}
}
// update journal entry
// note: cLion incorrectly says that this is unsafe, writing to a union is safe
journal_entry.content.block_write.flags = JMWFlags::CompleteAndDeallocated as u32;
if !unsafe { write_journal_entry(entry_index, sb, bd, journal_entry) } {
return false;
}
}
let content = unsafe { journal_entry.content.block_write };
// if flag is 0, move the journal head to the next entry
if content.flags == 0 {
let head = sb.journal_position;
let mut next = head + 1;
let max_index = ((sb.journal_block_count * sb.block_size as u64) / core::mem::size_of::<JournalEntry>() as u64) as u32;
if next >= max_index {
next = 0;
}
// write superblock
let mut sb = *sb;
sb.journal_position = next;
if !unsafe { write_superblock(sb, bd) } {
return false;
}
}
true
}

3
src/structs.rs
View file

@ -13,6 +13,7 @@ pub const MAGIC: u64 = 0x766170554653;
/// Free data blocks bitmap is data_block_count / 8 bytes long (rounded up).
/// Free inodes bitmap is inode_count / 8 bytes long (rounded up).
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Superblock {
/// magic number that identifies the Superblock as a valid VapUFS filesystem
pub magic: u64,
@ -378,6 +379,8 @@ pub struct JournalBlockWrite {
/// if greater than 12, the indirect block this points to (i / 12) will be used, and the index in that block will be i % 12)
/// (if target is an inode, this field will be ignored)
pub target_block: Index,
/// actual data block number, unused if target is an inode
pub real_target_block: Index,
/// block number of source data block
pub source_block: Index,
/// crc32 hash of the source data block