Implement looking up kernel-x86_64 file on FAT partition

Author: phil-opp

bios/second_stage/src/dap.rs

@@ -18,24 +18,18 @@ pub struct DiskAddressPacket {
 }
 
 impl DiskAddressPacket {
-    pub fn new(memory_buffer_start: u16, file_offset: u64, bytes: u32) -> Self {
-        Self {
-            packet_size: 0x10,
-            zero: 0,
-            number_of_sectors: (bytes / 512) as u16,
-            offset: memory_buffer_start,
-            segment: 0,
-            start_lba: file_offset / 512,
-        }
-    }
-
-    pub fn from_lba(memory_buffer_start: u16, start_lba: u64, number_of_sectors: u16) -> Self {
+    pub fn from_lba(
+        start_lba: u64,
+        number_of_sectors: u16,
+        target_addr: u16,
+        target_addr_segment: u16,
+    ) -> Self {
         Self {
             packet_size: 0x10,
             zero: 0,
             number_of_sectors,
-            offset: memory_buffer_start,
-            segment: 0,
+            offset: target_addr,
+            segment: target_addr_segment,
             start_lba,
         }
     }

bios/second_stage/src/disk.rs

@@ -1,5 +1,5 @@
-use crate::{dap, screen, second_stage_end};
-use core::{fmt::Write as _, slice};
+use crate::{dap, screen};
+use core::fmt::Write as _;
 
 #[derive(Clone)]
 pub struct DiskAccess {
@@ -11,24 +11,36 @@ pub struct DiskAccess {
 impl Read for DiskAccess {
     fn read_exact(&mut self, buf: &mut [u8]) {
         writeln!(screen::Writer, "read {} bytes", buf.len()).unwrap();
+        assert_eq!(buf.len() % 512, 0);
 
         let end_addr = self.base_offset + self.current_offset + u64::try_from(buf.len()).unwrap();
-        let start_lba = (self.base_offset + self.current_offset) / 512;
+        let mut start_lba = (self.base_offset + self.current_offset) / 512;
         let end_lba = (end_addr - 1) / 512;
 
-        let target_addr = u16::try_from(second_stage_end() as usize).unwrap();
-        let dap = dap::DiskAddressPacket::from_lba(
-            target_addr,
-            start_lba,
-            u16::try_from(end_lba + 1 - start_lba).unwrap(),
-        );
-        writeln!(screen::Writer, "dap: {dap:?}").unwrap();
-        unsafe {
-            dap.perform_load(self.disk_number);
-        }
+        let mut number_of_sectors = end_lba + 1 - start_lba;
+        let mut target_addr = buf.as_ptr_range().start as u32;
+
+        loop {
+            let sectors = u64::min(number_of_sectors, 32) as u16;
+            let dap = dap::DiskAddressPacket::from_lba(
+                start_lba,
+                sectors,
+                (target_addr & 0b1111) as u16,
+                (target_addr >> 4).try_into().unwrap(),
+            );
+            writeln!(screen::Writer, "dap: {dap:?}").unwrap();
+            unsafe {
+                dap.perform_load(self.disk_number);
+            }
 
-        let data = unsafe { slice::from_raw_parts(target_addr as *const u8, buf.len()) };
-        buf.copy_from_slice(data);
+            start_lba += u64::from(sectors);
+            number_of_sectors -= u64::from(sectors);
+            target_addr = target_addr + u32::from(sectors) * 512;
+
+            if number_of_sectors == 0 {
+                break;
+            }
+        }
 
         self.current_offset = end_addr;
     }

bios/second_stage/src/fat.rs

@@ -38,7 +38,10 @@ struct Bpb {
 
 impl Bpb {
     fn parse<D: Read + Seek>(disk: &mut D) -> Self {
-        let mut raw = [0u8; 512];
+        let mut raw = {
+            let buffer = unsafe { &mut BUFFER[..] };
+            &mut buffer[..512]
+        };
         disk.read_exact(&mut raw);
 
         let bytes_per_sector = u16::from_le_bytes(raw[11..13].try_into().unwrap());
@@ -142,27 +145,50 @@ impl<D: Read + Seek> FileSystem<D> {
         }
     }
 
-    pub fn lookup_file(&mut self, path: &str) -> Option<File> {
-        let root = self.read_root_dir();
-        for entry in root {
-            write!(screen::Writer, "entry: ").unwrap();
-            match entry {
-                Ok(RawDirectoryEntry::Normal(entry)) => {
-                    writeln!(screen::Writer, "{}", entry.short_filename_main).unwrap();
-                }
-                Ok(RawDirectoryEntry::LongName(entry)) => {
-                    for c in entry.name() {
-                        match c {
-                            Ok(c) => write!(screen::Writer, "{c}").unwrap(),
-                            Err(_) => write!(screen::Writer, "X").unwrap(),
-                        }
-                    }
-                    writeln!(screen::Writer).unwrap();
+    pub fn find_file_in_root_dir(&mut self, name: &str) -> Option<File> {
+        let mut root_entries = self.read_root_dir().filter_map(|e| e.ok());
+        let raw_entry = root_entries.find(|e| e.eq_name(name))?;
+
+        let entry = match raw_entry {
+            RawDirectoryEntry::Normal(entry) => DirectoryEntry {
+                short_name: entry.short_filename_main,
+                short_name_extension: entry.short_filename_extension,
+                long_name_1: &[],
+                long_name_2: &[],
+                long_name_3: &[],
+                file_size: entry.file_size,
+                first_cluster: entry.first_cluster,
+                attributes: entry.attributes,
+            },
+            RawDirectoryEntry::LongName(long_name) => match root_entries.next() {
+                Some(RawDirectoryEntry::LongName(_)) => unimplemented!(),
+                Some(RawDirectoryEntry::Normal(entry)) => DirectoryEntry {
+                    short_name: entry.short_filename_main,
+                    short_name_extension: entry.short_filename_extension,
+                    long_name_1: long_name.name_1,
+                    long_name_2: long_name.name_2,
+                    long_name_3: long_name.name_3,
+                    file_size: entry.file_size,
+                    first_cluster: entry.first_cluster,
+                    attributes: entry.attributes,
+                },
+                None => {
+                    panic!("next none");
+                    return None;
                 }
-                Err(()) => writeln!(screen::Writer, "<failed to read>").unwrap(),
-            }
+            },
+        };
+
+        writeln!(screen::Writer, "entry: {entry:?}").unwrap();
+
+        if entry.is_directory() {
+            None
+        } else {
+            Some(File {
+                first_cluster: entry.first_cluster,
+                file_size: entry.file_size,
+            })
         }
-        todo!();
     }
 
     fn read_root_dir<'a>(&'a mut self) -> impl Iterator<Item = Result<RawDirectoryEntry, ()>> + 'a {
@@ -197,6 +223,76 @@ enum FatType {
     Fat32,
 }
 
+#[derive(Clone)]
+pub struct DirectoryEntry<'a> {
+    short_name: &'a str,
+    short_name_extension: &'a str,
+    long_name_1: &'a [u8],
+    long_name_2: &'a [u8],
+    long_name_3: &'a [u8],
+    file_size: u32,
+    first_cluster: u32,
+    attributes: u8,
+}
+
+impl<'a> DirectoryEntry<'a> {
+    pub fn name(&self) -> impl Iterator<Item = Result<char, DecodeUtf16Error>> + 'a {
+        let mut long_name = {
+            let iter = self
+                .long_name_1
+                .chunks(2)
+                .chain(self.long_name_2.chunks(2))
+                .chain(self.long_name_3.chunks(2))
+                .map(|c| u16::from_le_bytes(c.try_into().unwrap()))
+                .take_while(|&c| c != 0);
+            char::decode_utf16(iter).peekable()
+        };
+        let short_name = {
+            let iter = self.short_name.chars();
+            let extension_iter = {
+                let raw = ".".chars().chain(self.short_name_extension.chars());
+                raw.take(if self.short_name_extension.is_empty() {
+                    0
+                } else {
+                    self.short_name_extension.len() + 1
+                })
+            };
+            iter.chain(extension_iter).map(Ok)
+        };
+
+        if long_name.peek().is_some() {
+            long_name.chain(short_name.take(0))
+        } else {
+            long_name.chain(short_name.take(usize::MAX))
+        }
+    }
+
+    pub fn is_directory(&self) -> bool {
+        self.attributes & directory_attributes::DIRECTORY != 0
+    }
+}
+
+impl core::fmt::Debug for DirectoryEntry<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        struct NamePrinter<'a>(&'a DirectoryEntry<'a>);
+        impl core::fmt::Debug for NamePrinter<'_> {
+            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                for char in self.0.name().filter_map(|e| e.ok()) {
+                    write!(f, "{char}")?;
+                }
+                Ok(())
+            }
+        }
+
+        f.debug_struct("DirectoryEntry")
+            .field("name", &NamePrinter(self))
+            .field("file_size", &self.file_size)
+            .field("first_cluster", &self.first_cluster)
+            .field("attributes", &self.attributes)
+            .finish()
+    }
+}
+
 #[derive(Debug)]
 struct RawDirectoryEntryNormal<'a> {
     short_filename_main: &'a str,
@@ -257,10 +353,14 @@ impl<'a> RawDirectoryEntry<'a> {
             fn slice_to_string(slice: &[u8]) -> Result<&str, ()> {
                 const SKIP_SPACE: u8 = 0x20;
                 let mut iter = slice.into_iter().copied();
-                let start_idx = iter.position(|c| c != SKIP_SPACE).ok_or(())?;
-                let end_idx = start_idx + iter.position(|c| c == SKIP_SPACE).unwrap_or(slice.len());
-
-                core::str::from_utf8(&slice[start_idx..end_idx]).map_err(|_| ())
+                match iter.position(|c| c != SKIP_SPACE) {
+                    Some(start_idx) => {
+                        let end_idx =
+                            start_idx + iter.position(|c| c == SKIP_SPACE).unwrap_or(slice.len());
+                        core::str::from_utf8(&slice[start_idx..end_idx]).map_err(|_| ())
+                    }
+                    None => Ok(""),
+                }
             }
             let short_filename_main = slice_to_string(&raw[0..8])?;
             let short_filename_extension = slice_to_string(&raw[8..11])?;
@@ -277,6 +377,17 @@ impl<'a> RawDirectoryEntry<'a> {
             }))
         }
     }
+
+    pub fn eq_name(&self, name: &str) -> bool {
+        match self {
+            RawDirectoryEntry::Normal(entry) => entry
+                .short_filename_main
+                .chars()
+                .chain(entry.short_filename_extension.chars())
+                .eq(name.chars()),
+            RawDirectoryEntry::LongName(entry) => entry.name().eq(name.chars().map(Ok)),
+        }
+    }
 }
 
 mod directory_attributes {

bios/second_stage/src/main.rs

@@ -3,7 +3,6 @@
 
 use byteorder::{ByteOrder, LittleEndian};
 use core::{fmt::Write as _, slice};
-use disk::Read;
 use mbr_nostd::{PartitionTableEntry, PartitionType};
 
 mod dap;
@@ -68,45 +67,15 @@ pub extern "C" fn _start(disk_number: u16, partition_table_start: *const u8) {
         base_offset: u64::from(fat_partition.logical_block_address) * 512,
         current_offset: 0,
     };
-
-    let mut fs = fat::FileSystem::parse(disk.clone());
-    let kernel = fs
-        .lookup_file("kernel-x86_64")
-        .expect("no `kernel-x86_64` file found");
     screen::print_char(b'2');
 
-    let mut buffer = [0u8; 512];
-    disk.read_exact(&mut buffer);
+    let mut fs = fat::FileSystem::parse(disk.clone());
     screen::print_char(b'3');
 
-    let kernel_first_cluster = todo!();
-    loop {}
-
-    // try to parse FAT file system
-    // let fat_slice = unsafe {
-    //     slice::from_raw_parts(
-    //         partition_buf as *const u8,
-    //         usize::try_from(second_stage_partition.sector_count).unwrap_or_else(|_| fail(b'a'))
-    //             * 512,
-    //     )
-    // };
-
-    // print_char(b'4');
-    // let boot_sector = fat::BootSector::deserialize(fat_slice);
-    // let root_dir = boot_sector.bpb.root_dir_first_cluster;
-    // boot_sector.bpb.check_root_dir();
-
-    // print_char(b'5');
-
-    // TODO: get root dir
-
-    // TODO: get offset of `second_stage` file
-
-    // TODO: get offset of `kernel-x86_64` file
-
-    // TODO: load `second_stage` file into memory
-
-    // TODO: jump to `second_stage`, pass offset of `kernel-x86_64` and disk number as arguments
+    let kernel = fs
+        .find_file_in_root_dir("kernel-x86_64")
+        .expect("no `kernel-x86_64` file found");
+    screen::print_char(b'4');
 
     loop {}
 }