Merge branch '16-bit-wip' into next

Author: phil-opp

real_mode/.cargo/config

@@ -0,0 +1,5 @@
+[build]
+target = "x86-32bit.json"
+
+[alias]
+xbuild = "build -Zbuild-std=core"

real_mode/.gitignore

@@ -0,0 +1,4 @@
+/target/
+**/*.rs.bk
+/test.bin
+

real_mode/Cargo.lock

@@ -0,0 +1,18 @@
+[package]
+name = "bootloader"
+version = "0.1.0"
+authors = ["Philipp Oppermann <dev@phil-opp.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[build-dependencies]
+llvm-tools = "0.1.1"
+
+[profile.release]
+opt-level = "s"
+lto = true
+debug = true
+codegen-units = 1

real_mode/Cargo.toml

@@ -0,0 +1,35 @@
+# 16-bit Rust (Experiment)
+
+This is an experiment to translate the 16-bit code of the bootloader from assembly to Rust.
+
+## Building
+
+To build the project, use cargo-xbuild:
+
+```
+cargo xbuild --release
+```
+
+The BIOS only loads the first 512 bytes of our executable into memory, so the amount of code that this binary can contain is very limited. This is also the reason why this can only be built in release mode.
+
+If the code does not fit into 512 bytes, the linker will throw the following error:
+
+> rust-lld: error: linker.ld:16: unable to move location counter backward for: .bootloader
+
+## Creating a Disk Image
+
+The output of `cargo xbuild` is an ELF binary, which can't be loaded directly by the BIOS. To boot our project, we must therefore convert it into a flat binary first. This works with the following `objcopy` command:
+
+```
+objcopy -I elf32-i386 -O binary target/x86-32bit/release/bootloader image.bin
+```
+
+This creates a file named `image.bin` in the root folder of the project, which is a bootable disk image.
+
+## Running it in QEMU
+
+To run the disk image in QEMU, execute the following command:
+
+```
+qemu-system-x86_64 -drive format=raw,file=image.bin
+```

real_mode/README.md

@@ -0,0 +1,57 @@
+use std::process::Command;
+use std::env;
+use std::path::Path;
+use llvm_tools::{LlvmTools, exe};
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let llvm_tools = LlvmTools::new().expect("LLVM tools not found");
+    let objcopy = llvm_tools.tool(&exe("llvm-objcopy")).expect("llvm-objcopy not found");
+
+    build_subproject(Path::new("first_stage"), &["_start", "print_char"], "x86-16bit.json", &out_dir, &objcopy);
+    build_subproject(Path::new("real_mode"), &["second_stage"], "x86-16bit.json", &out_dir, &objcopy);
+}
+
+fn build_subproject(dir: &Path, global_symbols: &[&str], target: &str, out_dir: &str, objcopy: &Path) {
+    let dir_name = dir.file_name().unwrap().to_str().unwrap();
+    let manifest_path = dir.join("Cargo.toml");
+    let out_path = Path::new(&out_dir);
+    assert!(global_symbols.len() > 0, "must have at least one global symbol");
+
+    // build
+    let mut cmd = Command::new("cargo");
+    cmd.arg("xbuild").arg("--release");
+    cmd.arg("--verbose");
+    cmd.arg(format!("--manifest-path={}", manifest_path.display()));
+    cmd.arg(format!("--target={}", dir.join(target).display()));
+    cmd.arg("-Z").arg("unstable-options");
+    cmd.arg("--out-dir").arg(&out_dir);
+    cmd.arg("--target-dir").arg(out_path.join("target").join(dir_name));
+    cmd.env_remove("RUSTFLAGS");
+    cmd.env("XBUILD_SYSROOT_PATH", out_path.join("target").join(dir_name).join("sysroot"));
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+
+    // localize symbols
+    let mut cmd = Command::new(objcopy);
+    for symbol in global_symbols {
+        cmd.arg("-G").arg(symbol);
+    }
+    cmd.arg(out_path.join(format!("lib{}.a", dir_name)));
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+    
+    /*
+    // FIXME: it seems like this messes up relocations
+    // convert to ELF64
+    let mut cmd = Command::new(objcopy);
+    cmd.arg("-I").arg("elf32-i386").arg("-O").arg("elf64-x86-64");
+    cmd.arg(out_path.join(format!("lib{}.a", dir_name)));    
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+    */
+
+    // emit linker flags
+    println!("cargo:rustc-link-search=native={}", out_dir);
+    println!("cargo:rustc-link-lib=static={}", dir_name);
+}

real_mode/build.rs

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

real_mode/first_stage/.gitignore

@@ -0,0 +1,45 @@
+ENTRY(_start)
+
+SECTIONS {
+    . = 0x500;
+    _stack_start = .;
+    . = 0x7c00;
+    _stack_end = .;
+
+    _mbr_start = .;
+    .boot :
+    {
+        *(.boot .boot.*)
+    }
+    .text :
+    {
+        *(.text .text.*)
+    }
+    .rodata :
+    {
+        *(.rodata .rodata.*)
+    }
+    .data :
+    {
+        *(.rodata .rodata.*)
+        *(.data .data.*)
+        *(.got .got.*)
+    }
+    _mbr_end = .;
+
+    . = 0x7c00 + 446;
+    .partition_table :
+    {
+        SHORT(0x0000)       /* partition table entry 0 */
+        SHORT(0x0000)       /* partition table entry 1 */
+        SHORT(0x0000)       /* partition table entry 2 */
+        SHORT(0x0000)       /* partition table entry 3 */
+    }
+
+    . = 0x7c00 + 510;
+
+    .magic_number :
+    {
+        SHORT(0xaa55)       /* magic number for bootable disk */
+    }
+}

real_mode/first_stage/16-bit-linker.ld

@@ -0,0 +1,16 @@
+[package]
+name = "first_stage"
+version = "0.1.0"
+authors = ["Philipp Oppermann <dev@phil-opp.com>"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[profile.release]
+opt-level = "s"
+lto = true
+codegen-units = 1
+
+# debug = true

real_mode/first_stage/Cargo.lock

@@ -0,0 +1,16 @@
+# First Stage: Bootsector
+
+This executable needs to fit into the 512-byte boot sector, so we need to use all kinds of tricks to keep the size down.
+
+## Build Commands
+
+1. `cargo build --release -Zbuild-std=core --target x86-16bit.json -Zbuild-std-features=compiler-builtins-mem`
+2. `objcopy -I elf32-i386 -O binary target/x86-16bit/release/first_stage target/disk_image.bin
+
+To run in QEMU:
+
+- `qemu-system-x86_64 -drive format=raw,file=target/disk_image.bin`
+
+To print the contents of the ELF file, e.g. for trying to bring the size down:
+
+- `objdump -xsdS -M i8086,intel target/x86-16bit/release/first_stage`

real_mode/first_stage/Cargo.toml

@@ -0,0 +1,50 @@
+.section .boot, "awx"
+.global _start
+.code16
+
+# This stage initializes the stack, enables the A20 line
+
+_start:
+    # zero segment registers
+    xor ax, ax
+    mov ds, ax
+    mov es, ax
+    mov ss, ax
+    mov fs, ax
+    mov gs, ax
+
+    # clear the direction flag (e.g. go forward in memory when using
+    # instructions like lodsb)
+    cld
+
+    # initialize stack
+    mov sp, 0x7c00
+
+enable_a20:
+    # enable A20-Line via IO-Port 92, might not work on all motherboards
+    in al, 0x92
+    test al, 2
+    jnz enable_a20_after
+    or al, 2
+    and al, 0xFE
+    out 0x92, al
+enable_a20_after:
+
+check_int13h_extensions:
+    push 'y'    # error code
+    mov ah, 0x41
+    mov bx, 0x55aa
+    # dl contains drive number
+    int 0x13
+    jc fail
+    pop ax      # pop error code again
+
+rust:
+    # push arguments
+    push dx     # disk number
+    call first_stage
+
+spin:
+    hlt
+    jmp spin
+

real_mode/first_stage/README.md

@@ -0,0 +1,58 @@
+use core::arch::{asm, global_asm};
+
+#[repr(packed)]
+pub struct DiskAddressPacket {
+    /// Size of the DAP structure
+    packet_size: u8,
+    /// always zero
+    zero: u8,
+    /// Number of sectors to transfer
+    number_of_sectors: u16,
+    /// Offset to memory buffer
+    offset: u16,
+    /// Segment of memory buffer
+    segment: u16,
+    /// Start logical block address
+    start_lba: u64,
+}
+
+impl DiskAddressPacket {
+    pub fn new(memory_buffer_start: u16, file_offset: u64, bytes: u32) -> Self {
+        Self {
+            packet_size: 0x10,
+            zero: 0,
+            number_of_sectors: (bytes / 512) as u16,
+            offset: memory_buffer_start,
+            segment: 0,
+            start_lba: file_offset / 512,
+        }
+    }
+
+    pub fn from_lba(memory_buffer_start: u16, start_lba: u64, number_of_sectors: u16) -> Self {
+        Self {
+            packet_size: 0x10,
+            zero: 0,
+            number_of_sectors,
+            offset: memory_buffer_start,
+            segment: 0,
+            start_lba,
+        }
+    }
+
+    pub unsafe fn perform_load(&self, disk_number: u16) {
+        let self_addr = self as *const Self as u16;
+        asm!(
+            "push 0x7a", // error code `z`, passed to `fail` on error
+            "mov {1:x}, si",
+            "mov si, {0:x}",
+            "int 0x13",
+            "jc fail",
+            "pop si", // remove error code again
+            "mov si, {1:x}",
+            in(reg) self_addr,
+            out(reg) _,
+            in("ax") 0x4200u16,
+            in("dx") disk_number,
+        );
+    }
+}

real_mode/first_stage/src/boot.s

@@ -0,0 +1,59 @@
+use core::arch::asm;
+
+pub trait UnwrapOrFail {
+    type Out;
+
+    fn unwrap_or_fail(self, code: u8) -> Self::Out;
+}
+
+impl<T> UnwrapOrFail for Option<T> {
+    type Out = T;
+
+    fn unwrap_or_fail(self, code: u8) -> Self::Out {
+        match self {
+            Some(v) => v,
+            None => fail(code),
+        }
+    }
+}
+
+impl<T, E> UnwrapOrFail for Result<T, E> {
+    type Out = T;
+
+    fn unwrap_or_fail(self, code: u8) -> Self::Out {
+        match self {
+            Ok(v) => v,
+            Err(_) => fail(code),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn print_char(c: u8) {
+    let ax = u16::from(c) | 0x0e00;
+    unsafe {
+        asm!("int 0x10", in("ax") ax, in("bx") 0);
+    }
+}
+
+#[cold]
+#[inline(never)]
+#[no_mangle]
+pub extern "C" fn fail(code: u8) -> ! {
+    print_char(b'!');
+    print_char(code);
+    loop {
+        hlt()
+    }
+}
+
+fn hlt() {
+    unsafe {
+        asm!("hlt");
+    }
+}
+
+#[panic_handler]
+pub fn panic(_info: &core::panic::PanicInfo) -> ! {
+    fail(b'P');
+}