Integrate BIOS bootsector into build system

Author: phil-opp

Cargo.lock

@@ -29,6 +29,7 @@ exclude = ["examples/basic", "examples/test_framework"]
 anyhow = "1.0.32"
 fatfs = "0.3.4"
 gpt = "3.0.0"
+mbrman = "0.4.2"
 
 [dependencies.bootloader-x86_64-bios]
 version = "0.1.0-alpha.0"
@@ -70,6 +71,9 @@ rustflags = [
     "code-model=large",
 ]
 
+[build-dependencies]
+llvm-tools = "0.1.1"
+
 [package.metadata.docs.rs]
 default-target = "x86_64-unknown-linux-gnu"
 

Cargo.toml

@@ -63,6 +63,8 @@ pub extern "C" fn first_stage(disk_number: u16) {
     print_char(b'4');
     let boot_sector = fat::BootSector::deserialize(fat_slice);
 
+    print_char(b'5');
+
     // TODO: get root dir
 
     // TODO: get offset of `second_stage` file

bios/boot_sector/src/main.rs

@@ -76,7 +76,7 @@ fn build_bios_boot_sector(out_dir: &Path) -> PathBuf {
     let status = cmd
         .status()
         .expect("failed to run cargo install for bios boot sector");
-    if status.success() {
+    let elf_path = if status.success() {
         let path = out_dir
             .join("bin")
             .join("bootloader-x86_64-bios-boot-sector");
@@ -87,5 +87,33 @@ fn build_bios_boot_sector(out_dir: &Path) -> PathBuf {
         path
     } else {
         panic!("failed to build bios boot sector");
+    };
+    convert_elf_to_bin(elf_path)
+}
+
+fn convert_elf_to_bin(elf_path: PathBuf) -> PathBuf {
+    let flat_binary_path = elf_path.with_extension("bin");
+
+    let llvm_tools = llvm_tools::LlvmTools::new().expect("failed to get llvm tools");
+    let objcopy = llvm_tools
+        .tool(&llvm_tools::exe("llvm-objcopy"))
+        .expect("LlvmObjcopyNotFound");
+
+    // convert first stage to binary
+    let mut cmd = Command::new(objcopy);
+    cmd.arg("-I").arg("elf64-x86-64");
+    cmd.arg("-O").arg("binary");
+    cmd.arg("--binary-architecture=i386:x86-64");
+    cmd.arg(&elf_path);
+    cmd.arg(&flat_binary_path);
+    let output = cmd
+        .output()
+        .expect("failed to execute llvm-objcopy command");
+    if !output.status.success() {
+        panic!(
+            "objcopy failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
     }
+    flat_binary_path
 }

build.rs

@@ -77,25 +77,41 @@ use std::{
 
 mod fat;
 mod gpt;
+mod mbr;
 
 const KERNEL_FILE_NAME: &str = "kernel-x86_64";
 
-pub fn create_uefi_disk_image(
-    kernel_binary: &Path,
-    out_fat_path: &Path,
-    out_gpt_path: &Path,
-) -> anyhow::Result<()> {
+/// Creates a bootable FAT partition at the given path.
+pub fn create_boot_partition(kernel_binary: &Path, out_path: &Path) -> anyhow::Result<()> {
     let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
 
     let mut files = BTreeMap::new();
     files.insert("efi/boot/bootx64.efi", bootloader_path);
     files.insert(KERNEL_FILE_NAME, kernel_binary);
 
-    fat::create_fat_filesystem(files, &out_fat_path)
-        .context("failed to create UEFI FAT filesystem")?;
-    gpt::create_gpt_disk(out_fat_path, out_gpt_path)
+    fat::create_fat_filesystem(files, &out_path).context("failed to create UEFI FAT filesystem")?;
+
+    Ok(())
+}
+
+pub fn create_uefi_disk_image(
+    boot_partition_path: &Path,
+    out_gpt_path: &Path,
+) -> anyhow::Result<()> {
+    gpt::create_gpt_disk(boot_partition_path, out_gpt_path)
         .context("failed to create UEFI GPT disk image")?;
 
     Ok(())
 }
 
+pub fn create_bios_disk_image(
+    boot_partition_path: &Path,
+    out_mbr_path: &Path,
+) -> anyhow::Result<()> {
+    let bootsector_path = Path::new(env!("BIOS_BOOT_SECTOR_PATH"));
+
+    mbr::create_mbr_disk(bootsector_path, boot_partition_path, out_mbr_path)
+        .context("failed to create BIOS MBR disk image")?;
+
+    Ok(())
+}

src/lib.rs

@@ -0,0 +1,64 @@
+use anyhow::Context;
+use std::{
+    fs::{self, File},
+    io,
+    path::Path,
+};
+const SECTOR_SIZE: u32 = 512;
+
+pub fn create_mbr_disk(
+    bootsector_path: &Path,
+    boot_partition_path: &Path,
+    out_mbr_path: &Path,
+) -> anyhow::Result<()> {
+    let mut boot_sector = File::open(bootsector_path).context("failed to open boot sector")?;
+    let mut mbr =
+        mbrman::MBR::read_from(&mut boot_sector, SECTOR_SIZE).context("failed to read MBR")?;
+
+    for (index, partition) in mbr.iter() {
+        if !partition.is_unused() {
+            anyhow::bail!("partition {index} should be unused");
+        }
+    }
+
+    let mut boot_partition =
+        File::open(boot_partition_path).context("failed to open FAT boot partition")?;
+    let boot_partition_size = boot_partition
+        .metadata()
+        .context("failed to read file metadata of FAT boot partition")?
+        .len();
+
+    mbr[1] = mbrman::MBRPartitionEntry {
+        boot: true,
+        starting_lba: 1,
+        sectors: (boot_partition_size / u64::from(SECTOR_SIZE))
+            .try_into()
+            .context("size of FAT partition is larger than u32::MAX")?,
+        //TODO: is this the correct type?
+        sys: 0x0c, // FAT32 with LBA
+
+        first_chs: mbrman::CHS::empty(),
+        last_chs: mbrman::CHS::empty(),
+    };
+
+    let mut disk = fs::OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .read(true)
+        .write(true)
+        .open(&out_mbr_path)
+        .with_context(|| {
+            format!(
+                "failed to create MBR disk image at `{}`",
+                out_mbr_path.display()
+            )
+        })?;
+
+    mbr.write_into(&mut disk)
+        .context("failed to write MBR header to disk image")?;
+
+    io::copy(&mut boot_partition, &mut disk)
+        .context("failed to copy FAT image to MBR disk image")?;
+
+    Ok(())
+}

src/mbr.rs

@@ -13,8 +13,13 @@ const QEMU_ARGS: &[&str] = &[
 pub fn run_test_kernel(kernel_binary_path: &str) {
     let kernel_path = Path::new(kernel_binary_path);
     let out_fat_path = kernel_path.with_extension("fat");
+    bootloader::create_boot_partition(kernel_path, &out_fat_path).unwrap();
     let out_gpt_path = kernel_path.with_extension("gpt");
-    bootloader::create_uefi_disk_image(kernel_path, &out_fat_path, &out_gpt_path).unwrap();
+    bootloader::create_uefi_disk_image(&out_fat_path, &out_gpt_path).unwrap();
+    let out_mbr_path = kernel_path.with_extension("mbr");
+    bootloader::create_bios_disk_image(&out_fat_path, &out_mbr_path).unwrap();
+
+    // TODO: run tests with BIOS bootloader too
 
     let mut run_cmd = Command::new("qemu-system-x86_64");
     run_cmd