WIP: try to start loading FAT partition in second stage

Author: phil-opp

Cargo.lock

@@ -14,11 +14,16 @@ mod fail;
 mod mbr;
 
 extern "C" {
+    static _mbr_start: u8;
     static _partition_table: u8;
     static _second_stage_start: u8;
 }
 
-unsafe fn partition_table() -> *const u8 {
+unsafe fn mbr_start() -> *const u8 {
+    unsafe { &_mbr_start }
+}
+
+unsafe fn partition_table_raw() -> *const u8 {
     unsafe { &_partition_table }
 }
 
@@ -31,7 +36,7 @@ fn second_stage_start() -> *const () {
 pub extern "C" fn first_stage(disk_number: u16) {
     // read partition table and look for second stage partition
     print_char(b'1');
-    let partition_table = &unsafe { slice::from_raw_parts(partition_table(), 16 * 4) };
+    let partition_table = &unsafe { slice::from_raw_parts(partition_table_raw(), 16 * 4) };
     let second_stage_partition =
         mbr::boot_partition(partition_table).unwrap_or_fail(NO_SECOND_STAGE_PARTITION);
 
@@ -55,9 +60,12 @@ pub extern "C" fn first_stage(disk_number: u16) {
 
     // jump to second stage
     print_char(b'3');
-    let second_stage_entry_point: extern "C" fn(disk_number: u16) =
-        unsafe { core::mem::transmute(target_addr as *const ()) };
-    second_stage_entry_point(disk_number);
+    let second_stage_entry_point: extern "C" fn(
+        disk_number: u16,
+        partition_table_start: *const u8,
+    ) = unsafe { core::mem::transmute(target_addr as *const ()) };
+    let mbr_start = unsafe { partition_table_raw() };
+    second_stage_entry_point(disk_number, mbr_start);
     for _ in 0..10 {
         print_char(b'R');
     }

bios/boot_sector/src/main.rs

@@ -7,3 +7,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+fatfs = { git = "https://github.com/rafalh/rust-fatfs.git", default-features = false }
+mbr-nostd = "0.1.0"
+byteorder = { version = "1.4.3", default-features = false }

bios/second_stage/Cargo.toml

@@ -0,0 +1,9 @@
+use std::path::Path;
+
+fn main() {
+    let local_path = Path::new(env!("CARGO_MANIFEST_DIR"));
+    println!(
+        "cargo:rustc-link-arg-bins=--script={}",
+        local_path.join("second-stage-link.ld").display()
+    )
+}

bios/second_stage/build.rs

@@ -0,0 +1,19 @@
+ENTRY(_start)
+
+SECTIONS {
+    . = 0x7c00 + 512;
+
+    .start : {
+        *(.start)
+    }
+    .rodata : {
+        *(.rodata .rodata.*)
+    }
+    .text : {
+        *(.text .text.*)
+    }
+
+    . = ALIGN(512);
+
+    _second_stage_end = .;
+}

bios/second_stage/second-stage-link.ld

@@ -1,5 +1,6 @@
 use core::arch::{asm, global_asm};
 
+#[derive(Debug, Clone, Copy)]
 #[repr(packed)]
 pub struct DiskAddressPacket {
     /// Size of the DAP structure

bios/second_stage/src/dap.rs

@@ -0,0 +1,68 @@
+use crate::{dap, screen, second_stage_end};
+use core::{fmt::Write as _, slice};
+
+pub struct DiskAccess {
+    pub disk_number: u16,
+    pub base_offset: u64,
+    pub current_offset: u64,
+}
+
+impl fatfs::IoBase for DiskAccess {
+    type Error = ();
+}
+
+impl fatfs::Read for DiskAccess {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        writeln!(screen::Writer, "read {} bytes", buf.len()).unwrap();
+
+        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 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 data = unsafe { slice::from_raw_parts(target_addr as *const u8, buf.len()) };
+        buf.copy_from_slice(data);
+
+        self.current_offset = end_addr;
+        Ok(buf.len())
+    }
+}
+
+impl fatfs::Seek for DiskAccess {
+    fn seek(&mut self, pos: fatfs::SeekFrom) -> Result<u64, Self::Error> {
+        writeln!(screen::Writer, "seek to {pos:?}").unwrap();
+        match pos {
+            fatfs::SeekFrom::Start(offset) => {
+                self.current_offset = offset;
+                Ok(self.current_offset)
+            }
+            fatfs::SeekFrom::Current(offset) => {
+                self.current_offset = (i64::try_from(self.current_offset).unwrap() + offset)
+                    .try_into()
+                    .unwrap();
+                Ok(self.current_offset)
+            }
+            fatfs::SeekFrom::End(_) => Err(()),
+        }
+    }
+}
+
+impl fatfs::Write for DiskAccess {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        unimplemented!()
+    }
+
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        unimplemented!()
+    }
+}

bios/second_stage/src/disk.rs

@@ -204,16 +204,11 @@ impl BiosParameterBlock {
 
     /// Returns a root directory object allowing for futher penetration of a filesystem structure.
     pub fn check_root_dir(&self) {
-        match self.fat_type() {
-            FatType::Fat12 | FatType::Fat16 => crate::fail(b'y'),
-            FatType::Fat32 => {
-                self.root_dir_first_cluster;
-                crate::fail(b'z');
-            }
-        }
+        panic!("check_root_dir: fat type {:?}", self.fat_type())
     }
 }
 
+#[derive(Debug)]
 pub enum FatType {
     /// 12 bits per FAT entry
     Fat12,