Build and load a second stage

Author: phil-opp

Cargo.lock

@@ -16,6 +16,7 @@ members = [
     "uefi",
     "bios",
     "bios/boot_sector",
+    "bios/second_stage",
     "tests/runner",
     "tests/test_kernels/default_settings",
     "tests/test_kernels/map_phys_mem",

Cargo.toml

@@ -0,0 +1,4 @@
+/// The boot sector did not find the second stage partition.
+///
+/// The BIOS bootloader requires a special second stage partition with partition type 0x20.
+pub const NO_SECOND_STAGE_PARTITION: u8 = b'x';

bios/boot_sector/src/error.rs

@@ -2,47 +2,44 @@
 
 use super::split_array_ref;
 
+// Size of single directory entry in bytes
+const DIR_ENTRY_SIZE: u32 = 32;
+
 pub(crate) struct BootSector {
-    bootjmp: [u8; 3],
-    oem_name: [u8; 8],
     pub(crate) bpb: BiosParameterBlock,
-    boot_code: [u8; 448],
-    boot_sig: [u8; 2],
 }
 
 impl BootSector {
     pub(crate) fn deserialize(bytes: &[u8]) -> Self {
         let mut boot = Self::default();
-        let (&bootjmp, bytes) = split_array_ref(bytes);
-        let (&oem_name, bytes) = split_array_ref(bytes);
+        // let (&bootjmp, bytes) = split_array_ref(bytes);
+        // let (&oem_name, bytes) = split_array_ref(bytes);
+
+        let bytes = &bytes[3 + 8..];
 
-        boot.bootjmp = bootjmp;
-        boot.oem_name = oem_name;
+        // boot.bootjmp = bootjmp;
+        // boot.oem_name = oem_name;
         boot.bpb = BiosParameterBlock::deserialize(bytes);
 
-        let bytes = if boot.bpb.is_fat32() {
-            let (boot_code, bytes): (&[_; 420], _) = split_array_ref(bytes);
-            boot.boot_code[0..420].copy_from_slice(&boot_code[..]);
-            bytes
-        } else {
-            let (&boot_code, bytes) = split_array_ref(bytes);
-            boot.boot_code = boot_code;
-            bytes
-        };
-        let (&boot_sig, bytes) = split_array_ref(bytes);
-        boot.boot_sig = boot_sig;
+        // let bytes = if boot.bpb.is_fat32() {
+        //     let (boot_code, bytes): (&[_; 420], _) = split_array_ref(bytes);
+        //     boot.boot_code[0..420].copy_from_slice(&boot_code[..]);
+        //     bytes
+        // } else {
+        //     let (&boot_code, bytes) = split_array_ref(bytes);
+        //     boot.boot_code = boot_code;
+        //     bytes
+        // };
+        // let (&boot_sig, bytes) = split_array_ref(bytes);
+        // boot.boot_sig = boot_sig;
         boot
     }
 }
 
 impl Default for BootSector {
     fn default() -> Self {
         Self {
-            bootjmp: Default::default(),
-            oem_name: Default::default(),
             bpb: BiosParameterBlock::default(),
-            boot_code: [0; 448],
-            boot_sig: Default::default(),
         }
     }
 }
@@ -158,4 +155,86 @@ impl BiosParameterBlock {
         // this provides a simple way to detect FAT32
         self.sectors_per_fat_16 == 0
     }
+
+    pub(crate) fn sectors_per_fat(&self) -> u32 {
+        if self.is_fat32() {
+            self.sectors_per_fat_32
+        } else {
+            u32::from(self.sectors_per_fat_16)
+        }
+    }
+
+    pub(crate) fn total_sectors(&self) -> u32 {
+        if self.total_sectors_16 == 0 {
+            self.total_sectors_32
+        } else {
+            u32::from(self.total_sectors_16)
+        }
+    }
+
+    pub(crate) fn reserved_sectors(&self) -> u32 {
+        u32::from(self.reserved_sectors)
+    }
+
+    pub(crate) fn root_dir_sectors(&self) -> u32 {
+        let root_dir_bytes = u32::from(self.root_entries) * DIR_ENTRY_SIZE;
+        (root_dir_bytes + u32::from(self.bytes_per_sector) - 1) / u32::from(self.bytes_per_sector)
+    }
+
+    pub(crate) fn sectors_per_all_fats(&self) -> u32 {
+        u32::from(self.fats) * self.sectors_per_fat()
+    }
+
+    pub(crate) fn first_data_sector(&self) -> u32 {
+        let root_dir_sectors = self.root_dir_sectors();
+        let fat_sectors = self.sectors_per_all_fats();
+        self.reserved_sectors() + fat_sectors + root_dir_sectors
+    }
+
+    pub(crate) fn total_clusters(&self) -> u32 {
+        let total_sectors = self.total_sectors();
+        let first_data_sector = self.first_data_sector();
+        let data_sectors = total_sectors - first_data_sector;
+        data_sectors / u32::from(self.sectors_per_cluster)
+    }
+
+    pub fn fat_type(&self) -> FatType {
+        FatType::from_clusters(self.total_clusters())
+    }
+
+    /// 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');
+            }
+        }
+    }
+}
+
+pub enum FatType {
+    /// 12 bits per FAT entry
+    Fat12,
+    /// 16 bits per FAT entry
+    Fat16,
+    /// 32 bits per FAT entry
+    Fat32,
+}
+
+impl FatType {
+    const FAT16_MIN_CLUSTERS: u32 = 4085;
+    const FAT32_MIN_CLUSTERS: u32 = 65525;
+    const FAT32_MAX_CLUSTERS: u32 = 0x0FFF_FFF4;
+
+    pub(crate) fn from_clusters(total_clusters: u32) -> Self {
+        if total_clusters < Self::FAT16_MIN_CLUSTERS {
+            FatType::Fat12
+        } else if total_clusters < Self::FAT32_MIN_CLUSTERS {
+            FatType::Fat16
+        } else {
+            FatType::Fat32
+        }
+    }
 }

bios/boot_sector/src/fat.rs

@@ -5,18 +5,21 @@ use core::{
     arch::{asm, global_asm},
     slice,
 };
+use error::NO_SECOND_STAGE_PARTITION;
 use fail::{fail, print_char, UnwrapOrFail};
 
 global_asm!(include_str!("boot.s"));
 
 mod dap;
+mod error;
 mod fail;
 mod fat;
 mod mbr;
 
 extern "C" {
     static _mbr_start: u8;
     static _partition_table: u8;
+    static _second_stage_start: u8;
 }
 
 fn mbr_start() -> *const u8 {
@@ -27,41 +30,65 @@ unsafe fn partition_table() -> *const u8 {
     unsafe { &_partition_table }
 }
 
+fn second_stage_start() -> *const () {
+    let ptr: *const u8 = unsafe { &_second_stage_start };
+    ptr as *const ()
+}
+
 #[no_mangle]
 pub extern "C" fn first_stage(disk_number: u16) {
     print_char(b'1');
     let partition_table = &unsafe { slice::from_raw_parts(partition_table(), 16 * 4) };
-    let boot_partition = mbr::boot_partition(partition_table).unwrap_or_fail(b'x');
+    let second_stage_partition =
+        mbr::boot_partition(partition_table).unwrap_or_fail(NO_SECOND_STAGE_PARTITION);
 
     print_char(b'2');
-    let partition_buf = u16::try_from(mbr_start() as usize).unwrap_or_fail(b'a') + 512;
+    let target_addr = u16::try_from(second_stage_start() as usize).unwrap_or_fail(b'a');
 
     // load boot partition into buffer
     // TODO: only load headers
     let dap = dap::DiskAddressPacket::from_lba(
-        partition_buf,
-        boot_partition.logical_block_address.into(),
-        1, // partition.sector_count.try_into().unwrap_or_fail(b'b'),
+        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 boot_partition.sector_count == 0 {
+    if second_stage_partition.sector_count == 0 {
         fail(b'c');
     }
 
     print_char(b'3');
 
+    // jump to second stage
+    let second_stage_entry_point: extern "C" fn(disk_number: u16) =
+        unsafe { core::mem::transmute(target_addr as *const ()) };
+    unsafe { second_stage_entry_point(disk_number) }
+
+    print_char(b'R');
+    print_char(b'R');
+    print_char(b'R');
+    print_char(b'R');
+    print_char(b'R');
+    loop {}
+
     // try to parse FAT file system
     let fat_slice = unsafe {
         slice::from_raw_parts(
-            partition_buf as *const u8,
-            usize::try_from(boot_partition.sector_count).unwrap_or_else(|_| fail(b'a')) * 512,
+            target_addr 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');
 

bios/boot_sector/src/main.rs

@@ -2,11 +2,14 @@
 
 use super::fail::{fail, UnwrapOrFail};
 
+/// We use this partition type to store the second bootloader stage;
+const BOOTLOADER_SECOND_STAGE_PARTITION_TYPE: u8 = 0x20;
+
 /// Returns the first bootable partition in the partition table.
 pub fn boot_partition(partitions_raw: &[u8]) -> Option<PartitionTableEntry> {
     for index in 0..4 {
         let entry = get_partition(partitions_raw, index);
-        if entry.bootable {
+        if entry.partition_type == BOOTLOADER_SECOND_STAGE_PARTITION_TYPE {
             return Some(entry);
         }
     }
@@ -49,6 +52,7 @@ const ENTRY_SIZE: usize = 16;
 /// The type of a particular partition.
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum PartitionType {
+    BootloaderSecondStage,
     Unused,
     Unknown(u8),
     Fat12(u8),
@@ -64,6 +68,8 @@ impl PartitionType {
     /// Parses a partition type from the type byte in the MBR's table.
     pub fn from_mbr_tag_byte(tag: u8) -> PartitionType {
         match tag {
+            // we use partition type 0x20 to store the second bootloader stage
+            0x20 => PartitionType::BootloaderSecondStage,
             0x0 => PartitionType::Unused,
             0x01 => PartitionType::Fat12(tag),
             0x04 | 0x06 | 0x0e => PartitionType::Fat16(tag),

bios/boot_sector/src/mbr.rs

@@ -0,0 +1 @@
+/target

bios/second_stage/.gitignore

@@ -0,0 +1,9 @@
+[package]
+name = "bootloader-x86_64-bios-second-stage"
+version = "0.1.0"
+authors = ["Philipp Oppermann <[email protected]>"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

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;
+    .text :
+    {
+        *(.text .text.*)
+    }
+    .rodata :
+    {
+        *(.rodata .rodata.*)
+    }
+    .data :
+    {
+        *(.rodata .rodata.*)
+        *(.data .data.*)
+        *(.got .got.*)
+    }
+}