fat32: fix zero-sized root directory

kernel/driver/fs/fat32/src/data.rs

@@ -52,10 +52,6 @@ impl<'a> Bpb<'a> {
         self.bytes[0x10] as usize
     }
 
-    pub fn root_directory_entries(&self) -> usize {
-        get_le_u16(&self.bytes[0x11..]) as usize
-    }
-
     pub fn total_sectors_16(&self) -> u16 {
         get_le_u16(&self.bytes[0x13..])
     }

kernel/driver/fs/fat32/src/directory.rs

@@ -45,13 +45,13 @@ struct FatDirectoryEntry<'a> {
     short_filename: ShortFilename<'a>,
     is_directory: bool,
     first_cluster: ClusterNumber,
-    size_bytes: u64,
+    size_bytes: u32,
 }
 
 pub struct DirectoryNode {
     pub(crate) fs: Arc<Fat32Fs>,
     pub(crate) cluster: ClusterNumber,
-    pub(crate) size_bytes: u64,
+    pub(crate) size_bytes: Option<u32>,
     pub(crate) metadata: Metadata,
     // Will be used when metadata needs to be updated
     #[allow(unused)]
@@ -150,7 +150,7 @@ impl DirectoryNode {
 
                             let first_cluster_hi = get_le_u16(&entry[20..]);
                             let first_cluster_lo = get_le_u16(&entry[26..]);
-                            let size_bytes = get_le_u32(&entry[28..]) as u64;
+                            let size_bytes = get_le_u32(&entry[28..]);
                             let first_cluster =
                                 ((first_cluster_hi as u32) << 16) | (first_cluster_lo as u32);
                             let first_cluster = ClusterNumber(first_cluster);
@@ -189,12 +189,13 @@ impl DirectoryNode {
         position: u64,
         buffer: &mut [MaybeUninit<DirectoryEntry>],
     ) -> Result<(usize, u64), Error> {
-        if position >= self.size_bytes {
+        let size = self.size_bytes.unwrap_or(u32::MAX);
+        if position >= size as u64 {
             return Ok((0, position));
         }
 
         let limit = core::cmp::min(
-            ((self.size_bytes - position) / DIRENT_SIZE as u64) as usize,
+            ((size - position as u32) / DIRENT_SIZE as u32) as usize,
             buffer.len(),
         );
         let (count, position) = self
@@ -226,6 +227,7 @@ impl DirectoryNode {
 
     async fn lookup_inner(&self, name: &Filename) -> Result<NodeRef, Error> {
         let mut found = None;
+        let size = self.size_bytes.unwrap_or(u32::MAX);
 
         self.iterate(
             |_, entry| {
@@ -237,7 +239,7 @@ impl DirectoryNode {
                 }
             },
             0,
-            (self.size_bytes / DIRENT_SIZE as u64) as usize,
+            (size as u64 / DIRENT_SIZE as u64) as usize,
         )
         .await?;
 
@@ -254,7 +256,7 @@ impl DirectoryNode {
             inode: Some(cluster.0),
             ctime: 0,
             mtime: 0,
-            block_count: size.div_ceil(self.fs.layout.bytes_per_sector as u64),
+            block_count: (size.div_ceil(self.fs.layout.bytes_per_sector as u32)) as u64,
             block_size: self.fs.layout.bytes_per_sector as u64,
         };
 
@@ -262,7 +264,7 @@ impl DirectoryNode {
             let directory = DirectoryNode {
                 fs: self.fs.clone(),
                 cluster,
-                size_bytes: size,
+                size_bytes: Some(size),
                 parent: Some(self.cluster),
                 metadata,
             };
@@ -294,7 +296,7 @@ impl DirectoryNode {
 
 impl CommonImpl for DirectoryNode {
     fn size(&self, _node: &NodeRef) -> Result<u64, Error> {
-        Ok(self.size_bytes)
+        Ok(self.size_bytes.unwrap_or(0) as u64)
     }
 
     fn metadata(&self, _node: &NodeRef) -> Result<Metadata, Error> {
@@ -352,7 +354,7 @@ impl DirectoryImpl for DirectoryNode {
     }
 
     fn len(&self, _node: &NodeRef) -> Result<usize, Error> {
-        Ok(self.size_bytes as usize / DIRENT_SIZE)
+        Ok((self.size_bytes.unwrap_or(0) as u32 / DIRENT_SIZE as u32) as usize)
     }
 }
 

kernel/driver/fs/fat32/src/file.rs

@@ -14,7 +14,7 @@ use crate::{data::ClusterNumber, Fat32Fs};
 pub struct FileNode {
     pub(crate) fs: Arc<Fat32Fs>,
     pub(crate) cluster: ClusterNumber,
-    pub(crate) size_bytes: u64,
+    pub(crate) size_bytes: u32,
     pub(crate) metadata: Metadata,
     // Will be used when metadata needs to be updated
     #[allow(unused)]
@@ -56,11 +56,11 @@ impl FileNode {
         mut pos: u64,
         buffer: &mut [u8],
     ) -> Result<usize, Error> {
-        if pos >= self.size_bytes {
+        if pos >= self.size_bytes as u64 {
             return Ok(0);
         }
 
-        let len = buffer.len().min((self.size_bytes - pos) as usize);
+        let len = buffer.len().min((self.size_bytes as u64 - pos) as usize);
         let mut rem = len;
         let mut offset = 0;
 
@@ -98,7 +98,7 @@ impl CommonImpl for FileNode {
     }
 
     fn size(&self, _node: &NodeRef) -> Result<u64, Error> {
-        Ok(self.size_bytes)
+        Ok(self.size_bytes as u64)
     }
 
     fn set_metadata(&self, _node: &NodeRef, _metadata: &Metadata) -> Result<(), Error> {

kernel/driver/fs/fat32/src/lib.rs

@@ -3,7 +3,7 @@
 use alloc::sync::Arc;
 use async_trait::async_trait;
 use data::{Bpb, ClusterNumber, Fat32Ebpb, Fat32FsInfo};
-use directory::{DirectoryNode, DIRENT_SIZE};
+use directory::DirectoryNode;
 use libk::{
     device::block::{cache::DeviceMapper, BlockDevice},
     error::Error,
@@ -26,7 +26,6 @@ pub struct FsLayout {
     sectors_per_fat: usize,
     sectors_per_cluster: usize,
     root_directory_cluster: ClusterNumber,
-    root_directory_entries: usize,
     first_fat_sector: u64,
 
     // Computed
@@ -75,7 +74,7 @@ impl Fat32Fs {
             fs: fs.clone(),
             cluster: fs.layout.root_directory_cluster,
             parent: None,
-            size_bytes: (fs.layout.root_directory_entries * DIRENT_SIZE) as u64,
+            size_bytes: None,
             metadata: root_metadata,
         };
         let root_node = Node::directory(root_directory, NodeFlags::empty(), None, Some(fs.clone()));
@@ -117,7 +116,6 @@ impl Fat32Fs {
         let sectors_per_fat = ebpb.sectors_per_fat();
         let sectors_per_cluster = bpb.sectors_per_cluster();
         let root_directory_cluster = ebpb.root_directory_cluster();
-        let root_directory_entries = bpb.root_directory_entries();
 
         // + RootDirSectors, but RootDirSectors = 0 on FAT32
         let first_data_sector = bpb.reserved_sectors() + sectors_per_fat * bpb.fat_count();
@@ -136,7 +134,6 @@ impl Fat32Fs {
             sectors_per_fat,
             sectors_per_cluster,
             root_directory_cluster,
-            root_directory_entries,
 
             first_fat_sector: first_fat_sector as u64,
             first_data_sector: first_data_sector as u64,