Simplify MBR code and choose bootable partition

(instead of always using the first one)

Author: phil-opp

bios/boot_sector/16-bit-linker.ld

@@ -28,6 +28,7 @@ SECTIONS {
     _mbr_end = .;
 
     . = 0x7c00 + 446;
+    _partition_table = .;
     .partition_table :
     {
         /* partition table entry 0 */

bios/boot_sector/src/main.rs

@@ -6,7 +6,6 @@ use core::{
     slice,
 };
 use fail::{fail, print_char, UnwrapOrFail};
-use mbr::MasterBootRecord;
 
 global_asm!(include_str!("boot.s"));
 
@@ -17,32 +16,37 @@ mod mbr;
 
 extern "C" {
     static _mbr_start: u8;
+    static _partition_table: u8;
 }
 
 fn mbr_start() -> *const u8 {
     unsafe { &_mbr_start }
 }
 
+unsafe fn partition_table() -> *const u8 {
+    unsafe { &_partition_table }
+}
+
 #[no_mangle]
 pub extern "C" fn first_stage(disk_number: u16) {
     print_char(b'1');
-    let bytes = &unsafe { slice::from_raw_parts(mbr_start(), 512) };
-    let partition = mbr::get_partition(bytes, 0);
+    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');
 
     print_char(b'2');
     let partition_buf = u16::try_from(mbr_start() as usize).unwrap_or_fail(b'a') + 512;
 
-    // load first partition into buffer
+    // load boot partition into buffer
     // TODO: only load headers
     let dap = dap::DiskAddressPacket::from_lba(
         partition_buf,
-        partition.logical_block_address.into(),
+        boot_partition.logical_block_address.into(),
         1, // partition.sector_count.try_into().unwrap_or_fail(b'b'),
     );
     unsafe {
         dap.perform_load(disk_number);
     }
-    if partition.sector_count == 0 {
+    if boot_partition.sector_count == 0 {
         fail(b'c');
     }
 
@@ -52,7 +56,7 @@ pub extern "C" fn first_stage(disk_number: u16) {
     let fat_slice = unsafe {
         slice::from_raw_parts(
             partition_buf as *const u8,
-            usize::try_from(partition.sector_count).unwrap_or_else(|_| fail(b'a')) * 512,
+            usize::try_from(boot_partition.sector_count).unwrap_or_else(|_| fail(b'a')) * 512,
         )
     };
 

bios/boot_sector/src/mbr.rs

@@ -2,17 +2,29 @@
 
 use super::fail::{fail, UnwrapOrFail};
 
-pub fn get_partition(buffer: &[u8], index: usize) -> PartitionTableEntry {
-    if buffer.len() < BUFFER_SIZE {
+/// 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 {
+            return Some(entry);
+        }
+    }
+    None
+}
+
+pub fn get_partition(partitions_raw: &[u8], index: usize) -> PartitionTableEntry {
+    if partitions_raw.len() < PARTITIONS_AREA_SIZE {
         fail(b'a');
-    } else if buffer.get(BUFFER_SIZE - SUFFIX_BYTES.len()..BUFFER_SIZE) != Some(&SUFFIX_BYTES[..]) {
-        fail(b'b');
     }
 
-    let offset = TABLE_OFFSET + index * ENTRY_SIZE;
-    let buffer = buffer.get(offset..).unwrap_or_fail(b'c');
+    let offset = index * ENTRY_SIZE;
+    let buffer = partitions_raw.get(offset..).unwrap_or_fail(b'c');
+
+    let bootable_raw = *buffer.get(0).unwrap_or_fail(b'd');
+    let bootable = bootable_raw == 0x80;
 
-    let partition_type = *buffer.get(4).unwrap_or_fail(b'd');
+    let partition_type = *buffer.get(4).unwrap_or_fail(b'e');
 
     let lba = u32::from_le_bytes(
         buffer
@@ -28,64 +40,11 @@ pub fn get_partition(buffer: &[u8], index: usize) -> PartitionTableEntry {
             .and_then(|s| s.try_into().ok())
             .unwrap_or_fail(b'f'),
     );
-    PartitionTableEntry::new(partition_type, lba, len)
+    PartitionTableEntry::new(bootable, partition_type, lba, len)
 }
 
-/// A struct representing an MBR partition table.
-pub struct MasterBootRecord {
-    entries: [PartitionTableEntry; MAX_ENTRIES],
-}
-
-const BUFFER_SIZE: usize = 512;
-const TABLE_OFFSET: usize = 446;
+const PARTITIONS_AREA_SIZE: usize = 16 * 4;
 const ENTRY_SIZE: usize = 16;
-const SUFFIX_BYTES: [u8; 2] = [0x55, 0xaa];
-const MAX_ENTRIES: usize = (BUFFER_SIZE - TABLE_OFFSET - 2) / ENTRY_SIZE;
-
-impl MasterBootRecord {
-    /// Parses the MBR table from a raw byte buffer.
-
-    pub fn from_bytes(buffer: &[u8]) -> MasterBootRecord {
-        if buffer.len() < BUFFER_SIZE {
-            fail(b'1');
-        } else if buffer.get(BUFFER_SIZE - SUFFIX_BYTES.len()..BUFFER_SIZE)
-            != Some(&SUFFIX_BYTES[..])
-        {
-            fail(b'2');
-        }
-        let mut entries = [PartitionTableEntry::empty(); MAX_ENTRIES];
-
-        for idx in 0..MAX_ENTRIES {
-            let offset = TABLE_OFFSET + idx * ENTRY_SIZE;
-            let buffer = buffer.get(offset..).unwrap_or_fail(b'8');
-
-            let partition_type = *buffer.get(4).unwrap_or_fail(b'4');
-
-            let lba = u32::from_le_bytes(
-                buffer
-                    .get(8..)
-                    .and_then(|s| s.get(..4))
-                    .and_then(|s| s.try_into().ok())
-                    .unwrap_or_fail(b'5'),
-            );
-            let len = u32::from_le_bytes(
-                buffer
-                    .get(12..)
-                    .and_then(|s| s.get(..4))
-                    .and_then(|s| s.try_into().ok())
-                    .unwrap_or_fail(b'6'),
-            );
-            *entries.get_mut(idx).unwrap_or_fail(b'7') =
-                PartitionTableEntry::new(partition_type, lba, len);
-        }
-
-        MasterBootRecord { entries }
-    }
-
-    pub fn partition_table_entries(&self) -> &[PartitionTableEntry] {
-        &self.entries[..]
-    }
-}
 
 /// The type of a particular partition.
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -129,6 +88,9 @@ impl PartitionType {
 /// An entry in a partition table.
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct PartitionTableEntry {
+    /// Whether this partition is a boot partition.
+    pub bootable: bool,
+
     /// The type of partition in this entry.
     pub partition_type: u8,
 
@@ -141,18 +103,16 @@ pub struct PartitionTableEntry {
 
 impl PartitionTableEntry {
     pub fn new(
+        bootable: bool,
         partition_type: u8,
         logical_block_address: u32,
         sector_count: u32,
     ) -> PartitionTableEntry {
         PartitionTableEntry {
+            bootable,
             partition_type,
             logical_block_address,
             sector_count,
         }
     }
-
-    pub fn empty() -> PartitionTableEntry {
-        PartitionTableEntry::new(0, 0, 0)
-    }
 }