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

use crate::{
    boot_sector::{BootSector, VolumeFlags},
    disk::ReadOffset,
    error::FatLoadError,
};
use alloc::vec;
use alloc::vec::Vec;
use bytemuck::{AnyBitPattern, NoUninit, checked::cast_slice};
use checked_num::CheckedU64;
use endify::Endify;

#[repr(transparent)]
#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, AnyBitPattern, NoUninit, Endify)]
pub(crate) struct FatEntry(pub(crate) u32);

impl FatEntry {
    /// The media type FAT entry. `F8h` as the first byte and `FFh` for the remeaining three bytes.
    pub(crate) fn media_type() -> FatEntry {
        Self(0xfffffff8u32)
    }

    /// Marks the end of a cluster chain.
    pub(crate) fn eof() -> FatEntry {
        Self(0xffffffff)
    }

    /// Marks the cluster as `bad`
    pub(crate) fn bad() -> FatEntry {
        Self(0xfffffff7)
    }
}

#[repr(C)]
#[derive(Clone, Debug)]
pub(crate) struct Fat {
    entries: Vec<FatEntry>,
}

impl Fat {
    pub(crate) fn load<R: ReadOffset>(
        device: &R,
        boot: &BootSector,
    ) -> Result<Fat, FatLoadError<R>> {
        assert!([1, 2].contains(&boot.number_of_fats));
        let volume_flags = VolumeFlags::from_bits_truncate(boot.volume_flags);
        let index = if volume_flags.contains(VolumeFlags::ACTIVE_FAT) {
            1
        } else {
            0
        };
        assert_eq!(index + 1, boot.number_of_fats);

        let sector_offset =
            CheckedU64::new(boot.fat_length as u64) * index as u64 + boot.fat_offset as u64;
        let byte_offset =
            (sector_offset * boot.bytes_per_sector() as u64).ok_or(FatLoadError::InvalidOffset)?;

        // load FAT entries from disk
        let mut entries = vec![0u8; boot.cluster_count as usize * 4];

        device
            .read_exact(byte_offset, &mut entries)
            .map_err(|e| FatLoadError::ReadFailed(byte_offset, e))?;

        let entries = entries
            .chunks_exact_mut(4)
            .map(|c| FatEntry(u32::from_le_bytes(c.try_into().unwrap())))
            .collect::<Vec<FatEntry>>();

        Ok(Self { entries })
    }
}

pub(crate) struct ClusterChain<'fat> {
    entries: &'fat [u32],
    next: u32,
}

impl<'fat> ClusterChain<'fat> {
    pub(crate) fn new(table: &'fat Fat, first: u32) -> ClusterChain<'fat> {
        Self {
            entries: cast_slice(&table.entries),
            next: first,
        }
    }
}

impl Iterator for ClusterChain<'_> {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        // Check next entry.
        let entries = self.entries;
        let next = self.next as usize;

        if next < 2 || next >= entries.len() || entries[next] == FatEntry::bad().0 {
            return None;
        }

        // Move to next entry.
        self.next = entries[next];

        Some(next as u32)
    }
}