norfs 0.0.0

Wear-leveling filesystem for embedded systems
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

use crate::{drivers::aligned::AlignedStorage, StorageError};

use super::WriteGranularity;

pub struct AlignedNorRamStorage<const STORAGE_SIZE: usize, const BLOCK_SIZE: usize> {
    pub(crate) data: [u32; STORAGE_SIZE],
}

impl<const STORAGE_SIZE: usize, const BLOCK_SIZE: usize> Default
    for AlignedNorRamStorage<STORAGE_SIZE, BLOCK_SIZE>
{
    fn default() -> Self {
        Self::new()
    }
}

impl<const STORAGE_SIZE: usize, const BLOCK_SIZE: usize>
    AlignedNorRamStorage<STORAGE_SIZE, BLOCK_SIZE>
{
    pub const fn new() -> Self {
        Self {
            data: [u32::MAX; STORAGE_SIZE],
        }
    }

    fn offset(block: usize, offset: usize) -> usize {
        block * Self::BLOCK_SIZE + offset
    }

    #[cfg(test)]
    pub fn debug_print(&self) {
        for blk in 0..Self::BLOCK_COUNT {
            print!("{blk:02X}:");

            for word in 0..Self::BLOCK_SIZE {
                for byte in self.data[Self::offset(blk, word)].to_le_bytes() {
                    print!(" {byte:02X}");
                }
            }

            println!();
        }
    }
}

impl<const STORAGE_SIZE: usize, const BLOCK_SIZE: usize> AlignedStorage
    for AlignedNorRamStorage<STORAGE_SIZE, BLOCK_SIZE>
{
    const BLOCK_SIZE: usize = BLOCK_SIZE;
    const BLOCK_COUNT: usize = STORAGE_SIZE / BLOCK_SIZE;
    const WRITE_GRANULARITY: WriteGranularity = WriteGranularity::Bit;
    const PAGE_SIZE: usize = BLOCK_SIZE;

    async fn erase(&mut self, block: usize) -> Result<(), StorageError> {
        let offset = Self::offset(block, 0);

        self.data[offset..offset + Self::BLOCK_SIZE].fill(u32::MAX);

        Ok(())
    }

    async fn read_aligned(
        &mut self,
        block: usize,
        offset: usize,
        data: &mut [u8],
    ) -> Result<(), StorageError> {
        assert!(
            offset + data.len() <= Self::BLOCK_SIZE * 4,
            "{offset} + {} <= {}",
            data.len(),
            Self::BLOCK_SIZE
        );
        assert!(offset % 4 == 0, "offset must be aligned to 4 bytes");
        assert!(
            data.len() % 4 == 0,
            "data length must be aligned to 4 bytes"
        );
        assert!(
            data.as_ptr() as usize % 4 == 0,
            "data must be aligned to 4 bytes"
        );

        let word_offset = offset / 4;
        let index = block * Self::BLOCK_SIZE + word_offset;

        for idx in 0..data.len() / 4 {
            let word = self.data[index + idx];
            let bytes = word.to_le_bytes();
            data[idx * 4..idx * 4 + 4].copy_from_slice(&bytes);
        }

        Ok(())
    }

    async fn write_aligned(
        &mut self,
        block: usize,
        offset: usize,
        data: &[u8],
    ) -> Result<(), StorageError> {
        assert!(
            offset + data.len() <= Self::BLOCK_SIZE * 4,
            "{offset} + {} <= {}",
            data.len(),
            Self::BLOCK_SIZE
        );
        assert!(offset % 4 == 0, "offset must be aligned to 4 bytes");
        assert!(
            data.len() % 4 == 0,
            "data length must be aligned to 4 bytes"
        );
        assert!(
            data.as_ptr() as usize % 4 == 0,
            "data must be aligned to 4 bytes"
        );

        let word_offset = offset / 4;
        let index = block * Self::BLOCK_SIZE + word_offset;

        for idx in 0..data.len() / 4 {
            let bytes = data[idx * 4..idx * 4 + 4].try_into().unwrap();
            let word = u32::from_le_bytes(bytes);
            self.data[index + idx] &= word;
        }

        Ok(())
    }
}