Load a second stage from disk in Rust

Author: phil-opp

real_mode/linker.ld

@@ -27,5 +27,12 @@ SECTIONS {
     {
         SHORT(0xaa55)       /* magic number for bootable disk */
     }
-    _bootloader_end = .;
+
+    _second_stage_start = .;
+    .second_stage :
+    {
+        *(.second_stage)
+    }
+    . = ALIGN(512);
+    _second_stage_end = .;
 }

real_mode/src/dap.rs

@@ -0,0 +1,36 @@
+#[repr(packed)]
+pub struct DiskAddressPacket {
+    /// Size of the DAP structure
+    packet_size: u8,
+    /// always zero
+    zero: u8,
+    /// Number of sectors to transfer
+    number_of_sectors: u16,
+    /// Offset to memory buffer
+    offset: u16,
+    /// Segment of memory buffer
+    segment: u16,
+    /// Start logical block address
+    start_lba: u64,
+}
+
+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 unsafe fn perform_load(&self, disk_number: u16) {
+        let self_addr = self as *const Self as u16;
+        asm!("
+            int 0x13
+            jc dap_load_failed
+        " :: "{si}"(self_addr), "{ax}"(0x4200), "{dx}"(disk_number) :: "intel");
+    }
+}

real_mode/src/main.rs

@@ -4,13 +4,57 @@
 
 use core::panic::PanicInfo;
 
+mod dap;
+
 global_asm!(include_str!("boot.s"));
+global_asm!(include_str!("second_stage.s"));
+
+extern "C" {
+    fn second_stage() -> u32;
+}
+
+#[allow(improper_ctypes)]
+extern "C" {
+    static _bootloader_start: ();
+    static _second_stage_start: ();
+    static _second_stage_end: ();
+}
 
 #[no_mangle]
-pub extern "C" fn rust_main() {
-    println(b"Hello from Rust!");
+pub extern "C" fn rust_main(disk_number: u16) {
+    load_second_stage(disk_number);
+
+    let val = unsafe { second_stage() };
+    if val == 12345 {
+        println(b"match");
+    } else {
+        println(b"no match");
+    }
 }
 
+fn bootloader_start() -> usize {
+    unsafe { &_bootloader_start as *const _ as usize }
+}
+
+fn second_stage_start() -> usize {
+    unsafe { &_second_stage_start as *const _ as usize }
+}
+
+fn second_stage_end() -> usize {
+    unsafe { &_second_stage_end as *const _ as usize }
+}
+
+fn load_second_stage(disk_number: u16) {
+    use dap::DiskAddressPacket;
+
+    let file_offset = (second_stage_start() - bootloader_start()) as u64;
+    let size = (second_stage_end() - second_stage_start()) as u32;
+
+    let dap = DiskAddressPacket::new(second_stage_start() as u16, file_offset, size);
+    unsafe { dap.perform_load(disk_number) }
+}
+
+#[inline(never)]
 fn println(s: &[u8]) {
     print(s);
     print_char(b'\n');
@@ -29,9 +73,32 @@ fn print_char(c: u8) {
     }
 }
 
+#[no_mangle]
+pub extern "C" fn dap_load_failed() -> ! {
+    println(b"ERROR: DAP load failed");
+    loop {
+        hlt()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn no_int13h_extensions() -> ! {
+    println(b"ERROR: No int13h extensions");
+    loop {
+        hlt()
+    }
+}
+
 #[panic_handler]
 pub fn panic(_info: &PanicInfo) -> ! {
     println(b"PANIC!");
-    loop {}
+    loop {
+        hlt()
+    }
 }
 
+fn hlt() {
+    unsafe {
+        asm!("hlt":::: "intel","volatile");
+    }
+}

real_mode/src/second_stage.s

@@ -0,0 +1,8 @@
+.section .second_stage, "awx"
+.global second_stage
+.intel_syntax noprefix
+.code16
+
+second_stage:
+    mov eax, 12345
+    ret