Create BIOS disk image from first stage with single FAT partition

Author: phil-opp

src/bin/builder.rs

@@ -156,12 +156,9 @@ fn main() -> anyhow::Result<()> {
 
     if args.firmware.bios() {
         let mut cmd = Command::new(env!("CARGO"));
-        cmd.arg("build").arg("--bin").arg("bios");
-        cmd.arg("--profile").arg("release");
-        cmd.arg("-Z").arg("unstable-options");
-        cmd.arg("--target").arg("x86_64-bootloader.json");
-        cmd.arg("--features")
-            .arg(args.features.join(" ") + " bios_bin");
+        cmd.arg("build").arg("-p").arg("bootloader_first_stage");
+        cmd.arg("--profile").arg("first-stage");
+        cmd.arg("--target").arg("bios/first_stage/x86-16bit.json");
         cmd.arg("-Zbuild-std=core");
         cmd.arg("-Zbuild-std-features=compiler-builtins-mem");
         if let Some(target_dir) = &args.target_dir {
@@ -170,7 +167,6 @@ fn main() -> anyhow::Result<()> {
         if args.quiet {
             cmd.arg("--quiet");
         }
-        cmd.env("RUSTFLAGS", "-C opt-level=s");
         assert!(cmd.status()?.success());
 
         // Retrieve binary paths
@@ -201,7 +197,7 @@ fn main() -> anyhow::Result<()> {
             .unwrap()
             .join(format!("boot-{}-{}.img", executable_name, kernel_name));
 
-        create_disk_image(&executable_path, &output_bin_path)
+        create_disk_image(&executable_path, &output_bin_path, &args.kernel_binary)
             .context("Failed to create bootable disk image")?;
 
         if let Some(out_dir) = &args.out_dir {

src/disk_image.rs

@@ -1,17 +1,25 @@
-use std::{io, path::Path, process::Command};
+use anyhow::Context;
+use std::{
+    fs,
+    io::{self, Seek, Write},
+    path::Path,
+    process::Command,
+};
 use thiserror::Error;
 
 /// Creates a bootable disk image from the given bootloader executable.
 pub fn create_disk_image(
     bootloader_elf_path: &Path,
     output_bin_path: &Path,
-) -> Result<(), DiskImageError> {
-    let llvm_tools = llvm_tools::LlvmTools::new()?;
+    kernel_binary: &Path,
+) -> anyhow::Result<()> {
+    let llvm_tools =
+        llvm_tools::LlvmTools::new().map_err(|err| anyhow::anyhow!("failed to get llvm tools"))?;
     let objcopy = llvm_tools
         .tool(&llvm_tools::exe("llvm-objcopy"))
         .ok_or(DiskImageError::LlvmObjcopyNotFound)?;
 
-    // convert bootloader to binary
+    // convert first stage to binary
     let mut cmd = Command::new(objcopy);
     cmd.arg("-I").arg("elf64-x86-64");
     cmd.arg("-O").arg("binary");
@@ -25,9 +33,77 @@ pub fn create_disk_image(
     if !output.status.success() {
         return Err(DiskImageError::ObjcopyFailed {
             stderr: output.stderr,
-        });
+        })
+        .context("objcopy failed");
     }
 
+    use std::fs::OpenOptions;
+    let mut disk_image = OpenOptions::new()
+        .write(true)
+        .open(&output_bin_path)
+        .map_err(|err| DiskImageError::Io {
+            message: "failed to open boot image",
+            error: err,
+        })?;
+    let file_size = disk_image
+        .metadata()
+        .map_err(|err| DiskImageError::Io {
+            message: "failed to get size of boot image",
+            error: err,
+        })?
+        .len();
+    const BLOCK_SIZE: u64 = 512;
+    assert_eq!(file_size, BLOCK_SIZE);
+
+    let kernel_size = fs::metadata(&kernel_binary)
+        .context("failed to read metadata of kernel binary")?
+        .len();
+
+    // create fat partition
+    const MB: u64 = 1024 * 1024;
+    let fat_size = kernel_size; // TODO plus second stage size
+    let fat_size_padded_and_rounded = ((fat_size + 1024 * 64 - 1) / MB + 1) * MB;
+    let fat_file_path = {
+        let fat_path = output_bin_path.with_extension("fat");
+        let fat_file = fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(&fat_path)
+            .context("Failed to create UEFI FAT file")?;
+        fat_file
+            .set_len(fat_size_padded_and_rounded)
+            .context("failed to set UEFI FAT file length")?;
+
+        // create new FAT partition
+        let format_options = fatfs::FormatVolumeOptions::new().volume_label(*b"BOOT       ");
+        fatfs::format_volume(&fat_file, format_options)
+            .context("Failed to format UEFI FAT file")?;
+
+        // copy kernel to FAT filesystem
+        let partition = fatfs::FileSystem::new(&fat_file, fatfs::FsOptions::new())
+            .context("Failed to open FAT file system of UEFI FAT file")?;
+        let root_dir = partition.root_dir();
+        let mut kernel_file = root_dir.create_file("kernel-x86_64")?;
+        kernel_file.truncate()?;
+        io::copy(&mut fs::File::open(&kernel_binary)?, &mut kernel_file)?;
+
+        fat_path
+    };
+
+    disk_image.seek(io::SeekFrom::Start(446))?;
+    disk_image.write_all(&[0x80, 0, 0, 0, 0x04, 0, 0, 0])?;
+    let start_sector = 1u32.to_le_bytes();
+    let size_sectors = u32::try_from(&fat_size_padded_and_rounded / 512)
+        .unwrap()
+        .to_le_bytes();
+    disk_image.write_all(&start_sector)?;
+    disk_image.write_all(&size_sectors)?;
+
+    disk_image.seek(io::SeekFrom::Start(512))?;
+    io::copy(&mut fs::File::open(&kernel_binary)?, &mut disk_image)?;
+
     pad_to_nearest_block_size(output_bin_path)?;
     Ok(())
 }