rsext4 0.4.0

A lightweight ext4 file system.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use super::*;

/// Builds block mappings and enables checksums for external extent nodes.
pub fn build_file_block_mapping_with_inode_num<B: BlockDevice>(
    fs: &mut Ext4FileSystem,
    inode: &mut Ext4Inode,
    inode_num: InodeNumber,
    data_blocks: &[AbsoluteBN],
    block_dev: &mut Jbd2Dev<B>,
) {
    if data_blocks.is_empty() {
        inode.i_blocks_lo = 0;
        inode.l_i_blocks_high = 0;
        inode.i_block = [0; 15];
        return;
    }

    if fs.superblock.has_extents() {
        // Prefer extents and merge contiguous physical blocks into the same run.
        inode.i_flags |= Ext4Inode::EXT4_EXTENTS_FL;
        inode.i_block = [0; 15];

        // Make sure the embedded root header exists before inserting extents.
        if !inode.have_extend_header_and_use_extend() {
            inode.i_flags |= Ext4Inode::EXT4_EXTENTS_FL;
            inode.write_extend_header();
        }

        let mut exts_vec: Vec<Ext4Extent> = Vec::new();

        let mut run_start_lbn: u32 = 0;
        let mut run_start_pblk = data_blocks[0].raw();
        let mut run_len: u32 = 1;

        for (idx, &pblk) in data_blocks.iter().enumerate().skip(1) {
            let lbn = idx as u32;
            let prev_lbn = lbn - 1;
            let prev_pblk = data_blocks[prev_lbn as usize].raw();
            let pblk = pblk.raw();

            let is_contiguous = pblk == prev_pblk.saturating_add(1);

            if is_contiguous {
                run_len = run_len.saturating_add(1);
            } else {
                // Finish the current physical run and emit one extent.
                let ext = Ext4Extent::new(run_start_lbn, run_start_pblk, run_len as u16);
                exts_vec.push(ext);

                run_start_lbn = lbn;
                run_start_pblk = pblk;
                run_len = 1;
            }
        }

        let ext = Ext4Extent::new(run_start_lbn, run_start_pblk, run_len as u16);
        exts_vec.push(ext);

        // Insert the computed extents through `ExtentTree` so the inode root
        // receives the same serialized structure as runtime writes.
        let mut tree = ExtentTree::with_checksum(inode, &fs.superblock, inode_num);
        for extend in exts_vec {
            tree.insert_extent(fs, extend, block_dev)
                .expect("Extend insert Failed!");
        }
    } else {
        error!("not support tranditional block pointer");
    }
}