Struct Fat32FileSystem 

pub struct Fat32FileSystem {
    fs_id: FileSystemId,
    block_device: Arc<dyn BlockDevice>,
    boot_sector: Fat32BootSector,
    root_cluster: u32,
    sectors_per_cluster: u32,
    bytes_per_sector: u32,
    root: RwLock<Arc<Fat32Node>>,
    name: String,
    next_file_id: Mutex<u64>,
    fat_cache: Mutex<BTreeMap<u32, u32>>,
}

FAT32 Filesystem implementation

This struct implements a FAT32 filesystem that can be mounted on block devices. It maintains the block device reference and provides filesystem operations through the VFS v2 interface.

Fields

fs_id: FileSystemId

Unique filesystem identifier

block_device: Arc<dyn BlockDevice>

Reference to the underlying block device

boot_sector: Fat32BootSector

Boot sector information

root_cluster: u32

Root directory cluster

sectors_per_cluster: u32

Sectors per cluster

bytes_per_sector: u32

Bytes per sector

root: RwLock<Arc<Fat32Node>>

Root directory node

name: String

Filesystem name

next_file_id: Mutex<u64>

Next file ID generator

fat_cache: Mutex<BTreeMap<u32, u32>>

Cached FAT table entries

Implementations

impl Fat32FileSystem

pub fn new( block_device: Arc<dyn BlockDevice>, ) -> Result<Arc<Self>, FileSystemError>

Create a new FAT32 filesystem from a block device

fn read_boot_sector( block_device: &dyn BlockDevice, ) -> Result<Fat32BootSector, FileSystemError>

Read boot sector from block device

fn validate_fat32(boot_sector: &Fat32BootSector) -> Result<(), FileSystemError>

Validate that this is a FAT32 filesystem

fn lookup_file_in_directory( &self, cluster: u32, target_name: &str, ) -> Result<Fat32DirectoryEntryInternal, FileSystemError>

Lookup a specific file in a directory cluster

fn read_cluster_data(&self, cluster: u32) -> Result<Vec<u8>, FileSystemError>

Read complete cluster data

fn generate_file_id(&self) -> u64

Generate next unique file ID

fn read_cluster(&self, cluster: u32) -> Result<Vec<u8>, FileSystemError>

Read cluster data from the block device

fn read_fat_entry(&self, cluster: u32) -> Result<u32, FileSystemError>

Read FAT entry for a given cluster

fn write_fat_entry( &self, cluster: u32, value: u32, ) -> Result<(), FileSystemError>

Write FAT entry for a given cluster

pub fn read_file_content( &self, start_cluster: u32, size: usize, ) -> Result<Vec<u8>, FileSystemError>

Read file content by following cluster chain

pub fn read_page_content( &self, start_cluster: u32, page_index: u64, paddr: usize, ) -> Result<(), FileSystemError>

Read a single page (4096 bytes) of file content into physical memory.

This is used by the page cache manager for demand paging.

pub fn write_file_content( &self, current_cluster: u32, content: &[u8], ) -> Result<u32, FileSystemError>

Write file content to disk and return the starting cluster

fn read_fat_entry_direct(&self, cluster: u32) -> Result<u32, FileSystemError>

Read FAT entry directly from disk without caching

fn allocate_cluster(&self) -> Result<u32, FileSystemError>

Allocate a free cluster from the FAT and mark it as allocated

fn initialize_directory( &self, dir_cluster: u32, parent_cluster: u32, ) -> Result<(), FileSystemError>

Initialize a new directory cluster with . and .. entries

fn update_fs_info_allocated_cluster( &self, _allocated_cluster: u32, ) -> Result<(), FileSystemError>

Update FS Info sector when a cluster is allocated

fn update_fs_info_freed_cluster( &self, freed_count: u32, ) -> Result<(), FileSystemError>

Update FS Info sector to increment free cluster count

fn free_cluster_chain(&self, start_cluster: u32) -> Result<(), FileSystemError>

Free a cluster chain starting from the given cluster

fn write_cluster_data( &self, cluster: u32, data: &[u8], ) -> Result<(), FileSystemError>

Read data to a cluster

fn cluster_to_sector(&self, cluster: u32) -> u32

Convert cluster number to first sector number

fn read_directory_entries( &self, cluster: u32, entries: &mut Vec<Fat32DirectoryEntryInternal>, ) -> Result<(), FileSystemError>

Read directory entries from a cluster

fn write_directory_entry_with_name( &self, dir_cluster: u32, filename: &str, cluster: u32, size: u32, is_directory: bool, ) -> Result<(), FileSystemError>

Write a new directory entry with LFN support to the specified directory cluster

pub fn update_directory_entry( &self, dir_cluster: u32, filename: &str, entry: &Fat32DirectoryEntry, ) -> Result<(), FileSystemError>

Update an existing directory entry in the specified directory cluster Supports both LFN and SFN matching

fn requires_lfn(filename: &str) -> bool

Check if a filename requires LFN (Long File Name) entries

fn generate_lfn_entries(filename: &str, sfn_checksum: u8) -> Vec<Fat32LFNEntry>

Generate LFN entries for a given filename

fn calculate_sfn_checksum(sfn: &[u8; 11]) -> u8

Calculate checksum for SFN (used in LFN entries)

fn remove_directory_entry( &self, dir_cluster: u32, filename: &str, ) -> Result<(), FileSystemError>

Remove a directory entry from the specified directory cluster

fn generate_sfn(filename: &str, numeric_tail: Option<u32>) -> [u8; 11]

Generate a FAT32-compliant SFN (Short File Name) from a long filename This implementation follows the Microsoft FAT32 specification

fn is_valid_sfn_char(ch: char) -> bool

Check if a character is valid for SFN according to FAT32 specification

fn filename_needs_numeric_tail(&self, filename: &str) -> bool

Check if filename needs numeric tail (Linux-style behavior) Returns true ONLY for filenames that cannot fit in 8.3 format or contain invalid characters

fn generate_unique_sfn( &self, dir_cluster: u32, desired_filename: &str, ) -> Result<[u8; 11], FileSystemError>

Generate a unique SFN by checking for duplicates in the directory

fn sfn_exists_in_directory( &self, dir_cluster: u32, sfn: &[u8; 11], ) -> Result<bool, FileSystemError>

Check if an SFN already exists in the specified directory

Trait Implementations

impl Debug for Fat32FileSystem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FileSystemOperations for Fat32FileSystem

fn fs_id(&self) -> FileSystemId

Get the unique filesystem identifier.

fn lookup( &self, parent: &Arc<dyn VfsNode>, name: &String, ) -> Result<Arc<dyn VfsNode>, FileSystemError>

Look up a child node by name within a parent directory

fn open( &self, node: &Arc<dyn VfsNode>, _flags: u32, ) -> Result<Arc<dyn FileObject>, FileSystemError>

Open a file represented by a VfsNode

fn create( &self, parent: &Arc<dyn VfsNode>, name: &String, file_type: FileType, _mode: u32, ) -> Result<Arc<dyn VfsNode>, FileSystemError>

Create a new file in the specified directory

fn remove( &self, parent: &Arc<dyn VfsNode>, name: &String, ) -> Result<(), FileSystemError>

Remove a file from the specified directory

fn readdir( &self, node: &Arc<dyn VfsNode>, ) -> Result<Vec<DirectoryEntryInternal>, FileSystemError>

Read directory entries from a directory node

fn root_node(&self) -> Arc<dyn VfsNode>

Get the root VfsNode for this filesystem

fn name(&self) -> &str

Get filesystem name

fn as_any(&self) -> &dyn Any

Access to Any trait for downcasting

fn is_read_only(&self) -> bool

Check if filesystem is read-only

fn create_hardlink( &self, link_parent: &Arc<dyn VfsNode>, link_name: &String, target_node: &Arc<dyn VfsNode>, ) -> Result<Arc<dyn VfsNode>, FileSystemError>

Create a hard link to an existing file