Use segment-based addressing for DAP to support loading larger second stages

Author: phil-opp

bios/boot_sector/src/dap.rs

@@ -18,13 +18,18 @@ pub struct DiskAddressPacket {
 }
 
 impl DiskAddressPacket {
-    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_offset: u16,
+        target_segment: u16,
+    ) -> Self {
         Self {
             packet_size: 0x10,
             zero: 0,
             number_of_sectors,
-            offset: memory_buffer_start,
-            segment: 0,
+            offset: target_offset,
+            segment: target_segment,
             start_lba,
         }
     }

bios/boot_sector/src/main.rs

@@ -4,7 +4,7 @@
 
 use core::{arch::global_asm, slice};
 use error::NO_SECOND_STAGE_PARTITION;
-use fail::{fail, print_char, UnwrapOrFail};
+use fail::{print_char, UnwrapOrFail};
 
 global_asm!(include_str!("boot.s"));
 
@@ -14,15 +14,10 @@ mod fail;
 mod mbr;
 
 extern "C" {
-    static _mbr_start: u8;
     static _partition_table: u8;
     static _second_stage_start: u8;
 }
 
-unsafe fn mbr_start() -> *const u8 {
-    unsafe { &_mbr_start }
-}
-
 unsafe fn partition_table_raw() -> *const u8 {
     unsafe { &_partition_table }
 }
@@ -38,34 +33,46 @@ pub extern "C" fn first_stage(disk_number: u16) {
     print_char(b'1');
     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);
+        // mbr::boot_partition(partition_table).unwrap_or_fail(NO_SECOND_STAGE_PARTITION);
+        mbr::get_partition(partition_table, 0);
 
     // load second stage partition into memory
     print_char(b'2');
-    let target_addr = u16::try_from(second_stage_start() as usize).unwrap_or_fail(b'a');
-    let dap = dap::DiskAddressPacket::from_lba(
-        target_addr,
-        second_stage_partition.logical_block_address.into(),
-        second_stage_partition
-            .sector_count
-            .try_into()
-            .unwrap_or_fail(b'b'),
-    );
-    unsafe {
-        dap.perform_load(disk_number);
-    }
-    if second_stage_partition.sector_count == 0 {
-        fail(b'c');
+    let entry_point_address = second_stage_start() as u32;
+
+    let mut start_lba = second_stage_partition.logical_block_address.into();
+    let mut number_of_sectors = second_stage_partition.sector_count;
+    let mut target_addr = entry_point_address;
+
+    loop {
+        let sectors = u32::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_or_fail(b'a'),
+        );
+        unsafe {
+            dap.perform_load(disk_number);
+        }
+
+        start_lba += u64::from(sectors);
+        number_of_sectors -= u32::from(sectors);
+        target_addr = target_addr + u32::from(sectors) * 512;
+
+        if number_of_sectors == 0 {
+            break;
+        }
     }
 
     // jump to second stage
     print_char(b'3');
     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);
+    ) = unsafe { core::mem::transmute(entry_point_address as *const ()) };
+    let partition_table_start = unsafe { partition_table_raw() };
+    second_stage_entry_point(disk_number, partition_table_start);
     for _ in 0..10 {
         print_char(b'R');
     }