wip

Author: phip1611

integration-test/bins/multiboot2_payload/.cargo/config.toml renamed to integration-test/bins/.cargo/config.toml

@@ -6,6 +6,6 @@ build-std-features = ["compiler-builtins-mem"]
 target = "x86-unknown-none.json"
 rustflags = [
     "-C", "code-model=kernel",
-    "-C", "link-arg=-Tlink.ld",
+    # "-C", "link-arg=-Tlink.ld",
     "-C", "relocation-model=static",
 ]

integration-test/bins/multiboot2_payload/Cargo.lock renamed to integration-test/bins/Cargo.lock

@@ -0,0 +1,6 @@
+[workspace]
+members = [
+    "multiboot2_chainloader",
+    "multiboot2_payload",
+    "util"
+]

integration-test/bins/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "multiboot2_chainloader"
+description = "Multiboot chainloader that loads a Multiboot2 payload"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[profile.release]
+codegen-units = 1
+lto = true
+
+[dependencies]
+anyhow = { version = "1.0.69", default-features = false }
+elf_rs = "0.3.0"
+log = { version = "0.4.17", default-features = false }
+good_memory_allocator = "0.1.7"
+multiboot = "0.8.0"
+util = { path = "../util" }

integration-test/bins/multiboot2_chainloader/Cargo.toml

@@ -0,0 +1,5 @@
+fn main() {
+    let linker_script = "multiboot2_chainloader/link.ld";
+    println!("cargo:rerun-if-changed={linker_script}");
+    println!("cargo:rustc-link-arg=-T{linker_script}");
+}

integration-test/bins/multiboot2_chainloader/build.rs

@@ -0,0 +1,40 @@
+ENTRY(start)
+
+PHDRS
+{
+    /* PT_LOAD FLAGS (page table permissions) not necessary, as we perform
+       legacy boot. Linker probably sets sensible defaults anyway. */
+    kernel_rx     PT_LOAD;
+    kernel_rw     PT_LOAD;
+    kernel_ro     PT_LOAD;
+}
+
+SECTIONS {
+    /* Chainloader linked at 8M, payload at 16M */
+    .text 8M : AT(8M) ALIGN(4K)
+    {
+        KEEP(*(.multiboot_header));
+        *(.text .text.*)
+    } : kernel_rx
+
+    .rodata :
+    {
+        *(.rodata .rodata.*)
+    } : kernel_ro
+
+    .data :
+    {
+        *(.data .data.*)
+    } : kernel_rw
+
+    .bss :
+    {
+        *(COMMON)
+        *(.bss .bss.*)
+    } : kernel_rw
+
+    /DISCARD/ :
+    {
+        *(.eh_frame .eh_frame*)
+    }
+}

integration-test/bins/multiboot2_chainloader/link.ld

@@ -0,0 +1,5 @@
+/// Loads the first module into memory. Assumes that the module is a ELF file.
+/// The handoff is performed according to the Multiboot2 spec.
+pub fn load_module(modules: multiboot::information::ModuleIter) -> ! {
+    loop {}
+}

integration-test/bins/multiboot2_chainloader/src/loader.rs

@@ -0,0 +1,28 @@
+#![no_main]
+#![no_std]
+#![feature(error_in_core)]
+
+mod loader;
+mod multiboot;
+
+extern crate alloc;
+
+#[macro_use]
+extern crate util;
+
+use util::init_environment;
+
+core::arch::global_asm!(include_str!("start.S"), options(att_syntax));
+
+/// Entry into the Rust code from assembly using the x86 SystemV calling
+/// convention.
+#[no_mangle]
+fn rust_entry(multiboot_magic: u32, multiboot_hdr: *const u32) -> ! {
+    init_environment();
+    log::debug!("multiboot_hdr={multiboot_hdr:x?}, multiboot_magic=0x{multiboot_magic:x?}");
+    let mbi = multiboot::get_mbi(multiboot_magic, multiboot_hdr as u32).unwrap();
+    let module_iter = mbi.modules().expect("Should provide modules");
+    loader::load_module(module_iter);
+}
+
+

integration-test/bins/multiboot2_chainloader/src/main.rs

@@ -0,0 +1,43 @@
+//! Parsing the Multiboot information. Glue code for the [`multiboot`] code.
+
+use core::{mem, slice};
+use core::str::Utf8Error;
+use anyhow::anyhow;
+use multiboot::information::{MemoryManagement, Multiboot, PAddr, SIGNATURE_EAX};
+pub use multiboot::information::ModuleIter;
+pub use multiboot::information::Multiboot as Mbi;
+
+static mut MEMORY_MANAGEMENT: Mem = Mem;
+
+/// Returns an object to access the fields of the Multiboot information
+/// structure.
+pub fn get_mbi<'a>(magic: u32, ptr: u32) -> anyhow::Result<Multiboot<'a, 'static>>
+{
+    if magic != SIGNATURE_EAX {
+        return Err(anyhow!("Unknown Multiboot signature {magic:x}"));
+    }
+    unsafe {
+        Multiboot::from_ptr(ptr as u64, &mut MEMORY_MANAGEMENT)
+    }.ok_or(anyhow!("Can't read Multiboot boot information from pointer"))
+}
+
+/// Glue object between the global allocator and the multiboot crate.
+struct Mem;
+
+impl MemoryManagement for Mem {
+    unsafe fn paddr_to_slice(&self, addr: PAddr, size: usize) -> Option<&'static [u8]> {
+        let ptr = addr as *const u64 as *const u8;
+        Some(slice::from_raw_parts(ptr, size))
+    }
+
+    // If you only want to read fields, you can simply return `None`.
+    unsafe fn allocate(&mut self, _length: usize) -> Option<(PAddr, &mut [u8])> {
+        None
+    }
+
+    unsafe fn deallocate(&mut self, addr: PAddr) {
+        if addr != 0 {
+            unimplemented!()
+        }
+    }
+}

integration-test/bins/multiboot2_chainloader/src/multiboot.rs

@@ -0,0 +1,63 @@
+# Symbol from main.rs
+.extern rust_entry
+
+.code32
+
+.section .multiboot_header, "a", @progbits
+
+/*
+ * Multiboot v1 Header.
+ * Required so that we can be booted by QEMU via the "-kernel" parameter.
+ */
+.align 8
+.global multiboot_header
+multiboot_header:
+    .long   0x1badb002
+    .long   0x0
+    .long  -0x1badb002
+
+.section .text
+
+.global start
+start:
+    # Prepare Multiboot2-handoff parameters for Rust
+    mov     %eax,       %edi
+    mov     %ebx,       %esi
+
+    # Prepare stack + align it to 16 byte (for SSE registers)
+    mov     $stack_end, %eax
+    sub     $16,        %eax
+    # x86 quirk: stack is n-aligned at address x when %esp+$8 is n-aligned
+    add     $8,         %eax
+
+    # Set stack
+    mov     %eax,       %esp
+    mov     %eax,       %ebp
+
+    # Enable SSE.
+    # Strictly speaking, this is not necessary, but I activated SSE in the
+    # compiler spec json file. Rustc/LLVM produces SSE coe for example from the
+    # core::fmt code.
+    mov %cr0,       %eax
+    and $0xFFFB,    %ax     # clear coprocessor emulation CR0.EM
+    or  $0x2,       %ax		# set coprocessor monitoring  CR0.MP
+    mov %eax,       %cr0
+    mov %cr4,       %eax
+    or  $(3 << 9),  %ax		# set CR4.OSFXSR and CR4.OSXMMEXCPT
+    mov %eax,       %cr4
+
+    push    %ebp
+    mov     %esp,   %ebp
+    # x86 SystemV calling convention: Push arguments in reverse order to stack
+    push    %edi
+    push    %esi
+    call    rust_entry
+    ud2
+
+.section .data
+
+# 16K natural-aligned stack.
+.align 16384
+stack_begin:
+    .zero 16384
+stack_end:

integration-test/bins/multiboot2_chainloader/src/start.S

@@ -16,4 +16,5 @@ log = { version = "0.4.17", default-features = false }
 multiboot2 = { path = "../../../multiboot2", features = ["unstable"] }
 # Wait for release > 3.0.1
 qemu-exit = { git = "https://github.com/rust-embedded/qemu-exit.git", rev = "3cee0efb5c1842b5261850c57b3b4d608542ff03" }
+util = { path = "../util" }
 x86 = "0.52.0"

integration-test/bins/multiboot2_payload/Cargo.toml

@@ -1,3 +1,5 @@
 fn main() {
-    println!("cargo:rerun-if-changed=link.ld");
+    let linker_script = "multiboot2_payload/link.ld";
+    println!("cargo:rerun-if-changed={linker_script}");
+    println!("cargo:rustc-link-arg=-T{linker_script}");
 }

integration-test/bins/multiboot2_payload/build.rs

@@ -10,6 +10,7 @@ PHDRS
 }
 
 SECTIONS {
+    /* Chainloader linked at 8M, payload at 16M */
     .text 16M : AT(16M) ALIGN(4K)
     {
         *(.multiboot2_header)
@@ -34,6 +35,6 @@ SECTIONS {
 
     /DISCARD/ :
     {
-        *(.eh_frame .eh_frame.*)
+        *(.eh_frame .eh_frame*)
     }
 }

integration-test/bins/multiboot2_payload/link.ld

@@ -1,4 +1,3 @@
-use crate::println;
 use alloc::format;
 use alloc::vec::Vec;
 use multiboot2::BootInformation;