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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Inode bitmap wrappers.

use log::warn;

use crate::bitmap::BitmapError;

/// Inode bitmap view with allocation helpers.
#[derive(Debug)]
pub struct InodeBitmap<'a> {
    data: &'a mut [u8],
    inodes_per_group: u32,
}

impl<'a> InodeBitmap<'a> {
    /// Creates a new inode bitmap view.
    pub fn new(data: &'a mut [u8], inodes_per_group: u32) -> Self {
        Self {
            data,
            inodes_per_group,
        }
    }

    /// Returns whether the inode is allocated.
    pub fn is_allocated(&self, inode_idx: u32) -> Option<bool> {
        if inode_idx >= self.inodes_per_group {
            return None;
        }

        let byte_idx = (inode_idx / 8) as usize;
        let bit_idx = (inode_idx % 8) as u8;

        if byte_idx >= self.data.len() {
            return None;
        }

        Some((self.data[byte_idx] & (1 << bit_idx)) != 0)
    }

    /// Returns whether the inode is free.
    pub fn is_free(&self, inode_idx: u32) -> Option<bool> {
        self.is_allocated(inode_idx).map(|allocated| !allocated)
    }

    /// Returns the first free inode index.
    pub fn find_first_free(&self) -> Option<u32> {
        for (byte_idx, &byte) in self.data.iter().enumerate() {
            if byte != 0xFF {
                for bit_idx in 0..8 {
                    if (byte & (1 << bit_idx)) == 0 {
                        let inode_idx = (byte_idx * 8 + bit_idx) as u32;
                        if inode_idx < self.inodes_per_group {
                            return Some(inode_idx);
                        }
                    }
                }
            }
        }
        None
    }

    /// Counts free inodes in the group.
    pub fn count_free(&self) -> u32 {
        let mut count = 0u32;

        for inode_idx in 0..self.inodes_per_group {
            if self.is_free(inode_idx) == Some(true) {
                count += 1;
            }
        }

        count
    }

    /// Counts allocated inodes in the group.
    pub fn count_allocated(&self) -> u32 {
        self.inodes_per_group - self.count_free()
    }

    /// Marks an inode as allocated.
    pub fn allocate(&mut self, inode_idx: u32) -> Result<(), BitmapError> {
        if inode_idx >= self.inodes_per_group {
            return Err(BitmapError::IndexOutOfRange);
        }

        let byte_idx = (inode_idx / 8) as usize;
        let bit_idx = (inode_idx % 8) as u8;

        if byte_idx >= self.data.len() {
            return Err(BitmapError::IndexOutOfRange);
        }

        if (self.data[byte_idx] & (1 << bit_idx)) != 0 {
            return Err(BitmapError::AlreadyAllocated);
        }

        self.data[byte_idx] |= 1 << bit_idx;
        Ok(())
    }

    /// Marks an inode as free.
    pub fn free(&mut self, inode_idx: u32) -> Result<(), BitmapError> {
        if inode_idx >= self.inodes_per_group {
            return Err(BitmapError::IndexOutOfRange);
        }

        let byte_idx = (inode_idx / 8) as usize;
        let bit_idx = (inode_idx % 8) as u8;

        if byte_idx >= self.data.len() {
            return Err(BitmapError::IndexOutOfRange);
        }

        if (self.data[byte_idx] & (1 << bit_idx)) == 0 {
            warn!("Inode num:{inode_idx} already free!");
            return Err(BitmapError::AlreadyFree);
        }

        self.data[byte_idx] &= !(1 << bit_idx);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use alloc::vec;

    use super::*;

    #[test]
    fn test_inode_bitmap_basic() {
        let mut data = vec![0u8; 32];
        data[0] = 0xFF;

        let bitmap = InodeBitmap::new(&mut data, 256);

        assert_eq!(bitmap.find_first_free(), Some(8));
        assert_eq!(bitmap.count_allocated(), 8);
    }
}