exfat-fs 0.1.3

A comprehensive implementation of the exFAT filesystem
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

use crate::{
    FIRST_USABLE_CLUSTER_INDEX,
    disk::{SeekFrom, WriteSeek},
    fat::FatEntry,
};

use super::Exfat;

impl Exfat {
    pub(super) fn write_fat<T: WriteSeek>(&mut self, device: &mut T) -> Result<(), T::Err> {
        // write entry 0 (media type)
        self.write_fat_entry(device, FatEntry::media_type(), 0)?;

        // write entry 1 (reserved)
        self.write_fat_entry(device, FatEntry::eof(), 1)?;

        // write bitmap entries
        let mut index =
            self.write_fat_entries(device, FIRST_USABLE_CLUSTER_INDEX, self.bitmap_length_bytes)?;

        // write upcase table entries
        index = self.write_fat_entries(device, index, self.uptable_length_bytes)?;

        // write root directory entries
        index = self.write_fat_entries(device, index, self.root_length_bytes)?;

        self.cluster_count_used = index - FIRST_USABLE_CLUSTER_INDEX;

        Ok(())
    }

    fn write_fat_entry<T: WriteSeek>(
        &self,
        device: &mut T,
        entry: FatEntry,
        index: u64,
    ) -> Result<(), T::Err> {
        let offset_bytes = self.fat_offset as u64 * self.format_options.bytes_per_sector as u64
            + index * size_of::<FatEntry>() as u64;
        device.seek(SeekFrom::Start(offset_bytes))?;
        device.write_all(&entry.0.to_le_bytes())
    }

    /// Writes a cluster chain onto the device and returns the next free FAT entry.
    fn write_fat_entries<T: WriteSeek>(
        &self,
        device: &mut T,
        cluster: u32,
        length: u32,
    ) -> Result<u32, T::Err> {
        let count =
            cluster + length.next_multiple_of(self.bytes_per_cluster) / self.bytes_per_cluster;

        // write fat entry for each cluster in chain
        for current_cluster in cluster..count - 1 {
            self.write_fat_entry(
                device,
                FatEntry(current_cluster + 1),
                current_cluster as u64,
            )?;
        }

        // write cluster chain EOF
        self.write_fat_entry(device, FatEntry::eof(), count as u64 - 1)?;

        Ok(count)
    }
}

#[cfg(test)]
#[test]
fn small_fat_creation() {
    use super::Exfat;
    use super::FormatVolumeOptionsBuilder;

    let size: u64 = 32 * crate::MB as u64;
    let mut f = std::io::Cursor::new(vec![0u8; size as usize]);

    let format_options = FormatVolumeOptionsBuilder::default()
        .pack_bitmap(false)
        .full_format(false)
        .partition_offset(0)
        .boundary_align(crate::DEFAULT_BOUNDARY_ALIGNEMENT)
        .dev_size(size)
        .bytes_per_sector(512)
        .build()
        .unwrap();

    let mut formatter = Exfat::try_from::<std::time::SystemTime>(format_options).unwrap();

    formatter
        .write::<std::time::SystemTime, std::io::Cursor<Vec<u8>>>(&mut f)
        .unwrap();

    assert_eq!(formatter.cluster_count_used, 4);
}

#[cfg(test)]
#[test]
fn medium_fat_creation() {
    use super::Exfat;
    use super::FormatVolumeOptionsBuilder;

    let size: u64 = 512 * crate::MB as u64;
    let mut f = std::io::Cursor::new(vec![0u8; size as usize]);

    let format_options = FormatVolumeOptionsBuilder::default()
        .pack_bitmap(false)
        .full_format(false)
        .partition_offset(0)
        .boundary_align(crate::DEFAULT_BOUNDARY_ALIGNEMENT)
        .dev_size(size)
        .bytes_per_sector(512)
        .build()
        .unwrap();

    let mut formatter = Exfat::try_from::<std::time::SystemTime>(format_options).unwrap();

    formatter
        .write::<std::time::SystemTime, std::io::Cursor<Vec<u8>>>(&mut f)
        .unwrap();

    assert_eq!(formatter.cluster_count_used, 3);
}