Rewrite the build system using a build script

Author: phil-opp

Cargo.toml

@@ -9,6 +9,7 @@ description = "An experimental pure-Rust x86 bootloader."
 repository = "https://github.com/rust-osdev/bootloader"
 publish-lockfile = true
 edition = "2018"
+build = "build.rs"
 
 [dependencies]
 xmas-elf = "0.6.2"

build.rs

@@ -0,0 +1,135 @@
+use std::{env, path::{Path, PathBuf}, process::{self, Command}};
+
+fn main() {
+    let target = env::var("TARGET").expect("TARGET not set");
+    if Path::new(&target)
+        .file_stem()
+        .expect("target has no file stem")
+        != "x86_64-bootloader"
+    {
+        return;
+    }
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
+    let kernel = PathBuf::from(match env::var("KERNEL") {
+        Ok(kernel) => kernel,
+        Err(_) => {
+            eprintln!(
+                "The KERNEL environment variable must be set for building the bootloader."
+            );
+            process::exit(1);
+        }
+    });
+    let kernel_file_name = kernel.file_name().expect("KERNEL has no valid file name").to_str().expect("kernel file name not valid utf8");
+    let kernel_out_path = out_dir.join(format!("kernel_bin-{}.o", kernel_file_name));
+    let kernel_archive_path = out_dir.join(format!("libkernel_bin-{}.a", kernel_file_name));
+
+
+    let bin_dir = BinDir::new();
+    let objcopy = bin_dir.tool(&LlvmTool::tool_name("objcopy")).expect("llvm-objcopy not found in llvm-tools");
+
+    let mut cmd = Command::new(objcopy.path());
+    cmd.arg("-I").arg("binary");
+    cmd.arg("-O").arg("elf64-x86-64");
+    cmd.arg("--binary-architecture=i386:x86-64");
+    cmd.arg("--rename-section").arg(".data=.kernel");
+    cmd.arg("--redefine-sym").arg(format!("_binary_{}_start=_kernel_start_addr", kernel_file_name));
+    cmd.arg("--redefine-sym").arg(format!("_binary_{}_end=_kernel_end_addr", kernel_file_name));
+    cmd.arg("--redefine-sym").arg(format!("_binary_{}_size=_kernel_size", kernel_file_name));
+    cmd.current_dir(kernel.parent().expect("KERNEL has no valid parent dir"));
+    cmd.arg(&kernel_file_name);
+    cmd.arg(&kernel_out_path);
+    let exit_status = cmd.status().expect("failed to run objcopy");
+    if !exit_status.success() {
+        eprintln!("Error: Running objcopy failed");
+        process::exit(1);
+    }
+
+    let ar = bin_dir.tool(&LlvmTool::tool_name("ar")).expect("llvm-ar not found in llvm-tools");
+    let mut cmd = Command::new(ar.path());
+    cmd.arg("crs");
+    cmd.arg(&kernel_archive_path);
+    cmd.arg(&kernel_out_path);
+    let exit_status = cmd.status().expect("failed to run ar");
+    if !exit_status.success() {
+        eprintln!("Error: Running ar failed");
+        process::exit(1);
+    }
+
+    println!("cargo:rerun-if-changed={}", kernel.display());
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rustc-link-search=native={}", out_dir.display());
+    println!("cargo:rustc-link-lib=static=kernel_bin-{}", kernel_file_name);
+}
+
+#[derive(Debug)]
+struct BinDir {
+    bin_dir: PathBuf,
+}
+
+impl BinDir {
+    fn new() -> Self {
+        let example_tool_name = LlvmTool::tool_name("objdump");
+        let output = Command::new("rustc")
+            .arg("--print")
+            .arg("sysroot")
+            .output()
+            .expect("failed to print sysroot");
+        if !output.status.success() {
+            eprintln!("Failed to execute `rustc --print sysroot`");
+            eprintln!("Stderr: {}", String::from_utf8(output.stderr).expect("error not valid unicode"));
+            process::exit(1);
+        }
+
+        let sysroot = PathBuf::from(String::from_utf8(output.stdout).expect("sysroot not valid unicode").trim());
+
+        let rustlib = sysroot.join("lib").join("rustlib");
+        for entry in rustlib.read_dir().expect("read_dir on sysroot dir failed") {
+            let bin_dir = entry.expect("failed to read sysroot dir entry").path().join("bin");
+            let tool_path = bin_dir.join(&example_tool_name);
+            if tool_path.exists() {
+                return Self { bin_dir };
+            }
+        }
+
+        eprintln!("Error: llvm-tools not found");
+        eprintln!("Maybe the rustup component `llvm-tools-preview` is missing?");
+        eprintln!("  Install it through: `rustup component add llvm-tools-preview`");
+        process::exit(1);
+    }
+
+    fn tool(&self, tool_name: &str) -> Option<LlvmTool> {
+        let tool_path = self.bin_dir.join(&tool_name);
+        
+        if tool_path.exists() {
+            Some(LlvmTool {
+                name: tool_name.to_owned(),
+                path: tool_path,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug)]
+struct LlvmTool {
+    name: String,
+    path: PathBuf,
+}
+
+impl LlvmTool {
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    #[cfg(target_os = "windows")]
+    fn tool_name(tool: &str) -> String {
+        format!("llvm-{}.exe", tool)
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn tool_name(tool: &str) -> String {
+        format!("llvm-{}", tool)
+    }
+}

builder/src/main.rs

@@ -152,6 +152,7 @@ fn run_xbuild(args: &[String]) -> io::Result<process::ExitStatus> {
     command.args(args);
     let exit_status = command.status()?;
 
+
     if !exit_status.success() {
         let mut help_command = process::Command::new("cargo");
         help_command.arg("xbuild").arg("--help");

linker.ld

@@ -40,13 +40,11 @@ SECTIONS {
         *(.got)
         . = ALIGN(512);
         _rest_of_bootloader_end_addr = .;
+        __bootloader_end = .;
     }
 
-    _kernel_info_block_start = .;
-    _kib_kernel_size = .;
-    . += 512; /* kernel info block */
-    _kernel_info_block_end = .;
-
-    __bootloader_end = .;
-    _kernel_start_addr = .;
+    .kernel :
+    {
+        KEEP(*(.kernel))
+    }
 }

src/main.rs

@@ -63,7 +63,9 @@ impl IdentityMappedAddr {
 extern "C" {
     static mmap_ent: usize;
     static _memory_map: usize;
-    static _kib_kernel_size: usize;
+    static _kernel_start_addr: usize;
+    static _kernel_end_addr: usize;
+    static _kernel_size: usize;
     static __page_table_start: usize;
     static __page_table_end: usize;
     static __bootloader_end: usize;
@@ -77,7 +79,7 @@ pub unsafe extern "C" fn stage_4() -> ! {
           mov ss, bx" ::: "bx" : "intel");
 
     let kernel_start = 0x400000;
-    let kernel_size = _kib_kernel_size as u64;
+    let kernel_size = &_kernel_size as *const _ as u64;
     let memory_map_addr = &_memory_map as *const _ as u64;
     let memory_map_entry_count = (mmap_ent & 0xff) as u64; // Extract lower 8 bits
     let page_table_start = &__page_table_start as *const _ as u64;

src/stage_1.s

@@ -84,7 +84,7 @@ load_rest_of_bootloader_from_disk:
     mov [dap_buffer_addr], ax
 
     # number of disk blocks to load
-    lea ebx, _kernel_info_block_end
+    lea ebx, _rest_of_bootloader_end_addr
     sub ebx, eax # end - start
     shr ebx, 9 # divide by 512 (block size)
     mov [dap_blocks], bx

src/stage_2.s

@@ -50,7 +50,7 @@ load_kernel_from_disk:
     mov edi, 0x400000
 
     # block count
-    mov ecx, _kib_kernel_size
+    lea ecx, _kernel_size
     add ecx, 511 # align up
     shr ecx, 9
 

src/stage_3.s

@@ -52,7 +52,7 @@ set_up_page_tables:
     mov [_p2], eax
     mov eax, (0x400000 | 1 | 2 | (1 << 7))
     mov ecx, 2
-    mov edx, _kib_kernel_size
+    lea edx, _kernel_size
     add edx, 0x400000 # start address
     add edx, 0x200000 - 1 # align up
     shr edx, 12 + 9 # end huge page number