Read FAT clusters of kernel file

phil-opp · phil-opp · commit 06d3b9521cc8 · 2022-06-25T13:45:08.000+02:00
diff --git a/bios/second_stage/src/disk.rs b/bios/second_stage/src/disk.rs
@@ -9,8 +9,15 @@ pub struct DiskAccess {
 }
 
 impl Read for DiskAccess {
-    fn read_exact(&mut self, buf: &mut [u8]) {
-        writeln!(screen::Writer, "read {} bytes", buf.len()).unwrap();
+    fn read_exact(&mut self, input_buf: &mut [u8]) {
+        writeln!(screen::Writer, "read {} bytes", input_buf.len()).unwrap();
+        static mut TMP_BUF: [u8; 512] = [0; 512];
+        let tmp_buf = unsafe { &mut TMP_BUF[..] };
+        let (buf, copy_needed) = if input_buf.len() >= tmp_buf.len() {
+            (&mut input_buf[..], false)
+        } else {
+            (&mut tmp_buf[..], true)
+        };
         assert_eq!(buf.len() % 512, 0);
 
         let end_addr = self.base_offset + self.current_offset + u64::try_from(buf.len()).unwrap();
@@ -43,6 +50,15 @@ impl Read for DiskAccess {
         }
 
         self.current_offset = end_addr;
+
+        if copy_needed {
+            let len = input_buf.len();
+            for i in 0..len {
+                input_buf[i] = tmp_buf[i];
+            }
+        }
+
+        writeln!(screen::Writer, "read {} bytes done", input_buf.len()).unwrap();
     }
 }
 
diff --git a/bios/second_stage/src/fat.rs b/bios/second_stage/src/fat.rs
@@ -1,4 +1,4 @@
-// based on https://crates.io/crates/mini_fat
+// based on https://crates.io/crates/mini_fat by https://github.com/gridbugs
 
 use crate::{
     disk::{Read, Seek, SeekFrom},
@@ -10,8 +10,6 @@ const DIRECTORY_ENTRY_BYTES: usize = 32;
 const UNUSED_ENTRY_PREFIX: u8 = 0xE5;
 const END_OF_DIRECTORY_PREFIX: u8 = 0;
 
-static mut BUFFER: [u8; 0x4000] = [0; 0x4000];
-
 pub struct File {
     first_cluster: u32,
     file_size: u32,
@@ -38,8 +36,9 @@ struct Bpb {
 
 impl Bpb {
     fn parse<D: Read + Seek>(disk: &mut D) -> Self {
+        static mut BPB_BUFFER: [u8; 512] = [0; 512];
         let mut raw = {
-            let buffer = unsafe { &mut BUFFER[..] };
+            let buffer = unsafe { &mut BPB_BUFFER[..] };
             &mut buffer[..512]
         };
         disk.read_exact(&mut raw);
@@ -130,6 +129,25 @@ impl Bpb {
         (self.reserved_sector_count as u64 + (self.num_fats as u64 * self.fat_size_16 as u64))
             * self.bytes_per_sector as u64
     }
+
+    fn maximum_valid_cluster(&self) -> u32 {
+        self.count_of_clusters() + 1
+    }
+
+    fn fat_offset(&self) -> u64 {
+        self.reserved_sector_count as u64 * self.bytes_per_sector as u64
+    }
+
+    fn data_offset(&self) -> u64 {
+        self.root_directory_size() as u64
+            + ((self.reserved_sector_count as u64
+                + self.fat_size_in_sectors() as u64 * self.num_fats as u64)
+                * self.bytes_per_sector as u64)
+    }
+
+    pub fn bytes_per_cluster(&self) -> u32 {
+        self.bytes_per_sector as u32 * self.sectors_per_cluster as u32
+    }
 }
 
 pub struct FileSystem<D> {
@@ -199,7 +217,8 @@ impl<D: Read + Seek> FileSystem<D> {
             }
             FatType::Fat12 | FatType::Fat16 => {
                 let root_directory_size = self.bpb.root_directory_size();
-                let buffer = unsafe { &mut BUFFER[..] };
+                static mut ROOT_DIR_BUFFER: [u8; 0x4000] = [0; 0x4000];
+                let buffer = unsafe { &mut ROOT_DIR_BUFFER[..] };
                 assert!(root_directory_size <= buffer.len());
                 let raw = &mut buffer[..root_directory_size];
 
@@ -214,6 +233,68 @@ impl<D: Read + Seek> FileSystem<D> {
             }
         }
     }
+
+    pub fn file_clusters<'a>(
+        &'a mut self,
+        file: &File,
+    ) -> impl Iterator<Item = Result<u32, ()>> + 'a {
+        Traverser {
+            current_entry: file.first_cluster,
+            bpb: &self.bpb,
+            disk: &mut self.disk,
+        }
+    }
+}
+
+struct Traverser<'a, D> {
+    disk: &'a mut D,
+    current_entry: u32,
+    bpb: &'a Bpb,
+}
+
+impl<D> Traverser<'_, D>
+where
+    D: Read + Seek,
+{
+    fn next_cluster(&mut self) -> Result<Option<u32>, ()> {
+        let entry = classify_fat_entry(
+            self.bpb.fat_type(),
+            self.current_entry,
+            self.bpb.maximum_valid_cluster(),
+        )
+        .map_err(|_| ())?;
+        let entry = match entry {
+            FileFatEntry::AllocatedCluster(cluster) => cluster,
+            FileFatEntry::EndOfFile => return Ok(None),
+        };
+        let cluster_start =
+            self.bpb.data_offset() + (u64::from(entry) - 2) * self.bpb.bytes_per_cluster() as u64;
+        // handle_read(
+        //     self.traverser.handle,
+        //     cluster_start,
+        //     self.traverser.bpb.bytes_per_cluster() as usize,
+        //     &mut self.traverser.buf,
+        // )?;
+        // if let Some(t) = f(&self.traverser.buf) {
+        //     break Ok(Some(t));
+        // }
+        let next_entry =
+            fat_entry_of_nth_cluster(self.disk, self.bpb.fat_type(), self.bpb.fat_offset(), entry);
+        self.current_entry = next_entry;
+
+        Ok(Some(entry))
+    }
+}
+
+impl<D> Iterator for Traverser<'_, D>
+where
+    D: Read + Seek,
+{
+    type Item = Result<u32, ()>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next_cluster().transpose()
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -223,6 +304,16 @@ enum FatType {
     Fat32,
 }
 
+impl FatType {
+    fn fat_entry_defective(self) -> u32 {
+        match self {
+            Self::Fat12 => 0xFF7,
+            Self::Fat16 => 0xFFF7,
+            Self::Fat32 => 0x0FFFFFF7,
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct DirectoryEntry<'a> {
     short_name: &'a str,
@@ -399,3 +490,73 @@ mod directory_attributes {
 
     pub const LONG_NAME: u8 = READ_ONLY | HIDDEN | SYSTEM | VOLUME_ID;
 }
+
+fn classify_fat_entry(
+    fat_type: FatType,
+    entry: u32,
+    maximum_valid_cluster: u32,
+) -> Result<FileFatEntry, FatLookupError> {
+    match entry {
+        0 => Err(FatLookupError::FreeCluster),
+        1 => Err(FatLookupError::UnspecifiedEntryOne),
+        entry => {
+            if entry <= maximum_valid_cluster {
+                Ok(FileFatEntry::AllocatedCluster(entry))
+            } else if entry < fat_type.fat_entry_defective() {
+                Err(FatLookupError::ReservedEntry)
+            } else if entry == fat_type.fat_entry_defective() {
+                Err(FatLookupError::DefectiveCluster)
+            } else {
+                Ok(FileFatEntry::EndOfFile)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum FatLookupError {
+    FreeCluster,
+    DefectiveCluster,
+    UnspecifiedEntryOne,
+    ReservedEntry,
+}
+
+enum FileFatEntry {
+    AllocatedCluster(u32),
+    EndOfFile,
+}
+
+fn fat_entry_of_nth_cluster<D>(disk: &mut D, fat_type: FatType, fat_start: u64, n: u32) -> u32
+where
+    D: Seek + Read,
+{
+    debug_assert!(n >= 2);
+    match fat_type {
+        FatType::Fat32 => {
+            let base = n as u64 * 4;
+            disk.seek(SeekFrom::Start(fat_start + base));
+            let mut buf = [0; 4];
+            disk.read_exact(&mut buf);
+            u32::from_le_bytes(buf) & 0x0FFFFFFF
+        }
+        FatType::Fat16 => {
+            let base = n as u64 * 2;
+            disk.seek(SeekFrom::Start(fat_start + base));
+            let mut buf = [0; 2];
+            disk.read_exact(&mut buf);
+            u16::from_le_bytes(buf) as u32
+        }
+        FatType::Fat12 => {
+            let base = n as u64 + (n as u64 / 2);
+            disk.seek(SeekFrom::Start(fat_start + base));
+            let mut buf = [0; 2];
+            disk.read_exact(&mut buf);
+            let entry16 = u16::from_le_bytes(buf);
+            if n & 1 == 0 {
+                (entry16 & 0xFFF) as u32
+            } else {
+                (entry16 >> 4) as u32
+            }
+        }
+    }
+}
diff --git a/bios/second_stage/src/main.rs b/bios/second_stage/src/main.rs
@@ -59,23 +59,27 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
         fat_partition.partition_type,
         PartitionType::Fat12(_) | PartitionType::Fat16(_) | PartitionType::Fat32(_)
     ));
-    screen::print_char(b'1');
+    writeln!(screen::Writer, "1").unwrap();
 
     // load fat partition
     let mut disk = disk::DiskAccess {
         disk_number,
         base_offset: u64::from(fat_partition.logical_block_address) * 512,
         current_offset: 0,
     };
-    screen::print_char(b'2');
+    writeln!(screen::Writer, "2").unwrap();
 
     let mut fs = fat::FileSystem::parse(disk.clone());
-    screen::print_char(b'3');
+    writeln!(screen::Writer, "3").unwrap();
 
     let kernel = fs
         .find_file_in_root_dir("kernel-x86_64")
         .expect("no `kernel-x86_64` file found");
-    screen::print_char(b'4');
+    writeln!(screen::Writer, "4").unwrap();
+
+    for cluster in fs.file_clusters(&kernel) {
+        writeln!(screen::Writer, "kernel cluster: {cluster:?}").unwrap();
+    }
 
     // TODO: Retrieve memory map
 
