WIP

Author: phip1611

integration-test/bins/Cargo.lock

@@ -16,3 +16,5 @@ log = { version = "0.4.17", default-features = false }
 good_memory_allocator = "0.1.7"
 multiboot = "0.8.0"
 util = { path = "../util" }
+multiboot2 = { path = "../../../multiboot2" }
+multiboot2-header = { path = "../../../multiboot2-header" }

integration-test/bins/multiboot2_chainloader/Cargo.toml

@@ -1,5 +1,58 @@
+use core::any::Any;
+use elf_rs::{ElfFile, ProgramHeaderEntry, ProgramType};
+
 /// 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 {}
+pub fn load_module(mut modules: multiboot::information::ModuleIter) -> ! {
+    let elf_mod = modules.next().expect("Should have payload");
+    let elf_bytes = unsafe {
+        core::slice::from_raw_parts(
+            elf_mod.start as *const u64 as *const u8,
+            (elf_mod.end - elf_mod.start) as usize,
+        )
+    };
+    log::info!("Bootstrapping ELF: {}", elf_mod.string.unwrap_or("<unknown>"));
+    let elf = elf_rs::Elf32::from_bytes(elf_bytes).expect("Should be valid ELF");
+    elf.program_header_iter()
+        .filter(|ph| ph.ph_type() == ProgramType::LOAD)
+        .for_each(|ph| {
+       map_memory(ph);
+    });
+
+    // TODO check if ELF has multiboot2 header tag
+
+    // TODO build MBI
+
+
+    // TODO
+    let mbi = 0;
+    // handoff
+    unsafe {
+        core::arch::asm!(
+            "jmp *%ecx",
+            in("eax") multiboot2::MULTIBOOT2_BOOTLOADER_MAGIC,
+            in("ebx") mbi,
+            in("ecx") elf.entry_point() as u32,
+        options(noreturn, att_syntax));
+    }
+}
+
+/// Blindly copies the LOAD segment content at its desired address in physical
+/// address space. The loader assumes that the addresses to not clash with the
+/// loader (or anything else).
+fn map_memory(ph: ProgramHeaderEntry) {
+    log::debug!("Mapping LOAD segment {ph:#?}");
+    let dest_ptr = ph.vaddr() as *mut u8;
+    let content = ph.content().expect("Should have content");
+    unsafe {
+        core::ptr::copy(content.as_ptr(), dest_ptr, content.len())
+    };
+    let mut dest_ptr = unsafe { dest_ptr.add(ph.filesz() as usize) };
+
+    // Zero .bss memory
+    for _ in 0..(ph.memsz() - ph.filesz()) {
+        unsafe {
+            core::ptr::write(dest_ptr, 0);
+        }
+    }
 }

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

@@ -24,5 +24,3 @@ fn rust_entry(multiboot_magic: u32, multiboot_hdr: *const u32) -> ! {
     let module_iter = mbi.modules().expect("Should provide modules");
     loader::load_module(module_iter);
 }
-
-

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

@@ -1,24 +1,22 @@
 //! 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};
+use core::slice;
 pub use multiboot::information::ModuleIter;
 pub use multiboot::information::Multiboot as Mbi;
+use multiboot::information::{MemoryManagement, Multiboot, PAddr, SIGNATURE_EAX};
 
 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>>
-{
+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"))
+    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.

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

@@ -49,8 +49,8 @@ start:
     push    %ebp
     mov     %esp,   %ebp
     # x86 SystemV calling convention: Push arguments in reverse order to stack
-    push    %edi
     push    %esi
+    push    %edi
     call    rust_entry
     ud2
 

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

@@ -14,7 +14,5 @@ anyhow = { version = "1.0.69", default-features = false }
 good_memory_allocator = "0.1.7"
 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

@@ -98,12 +98,8 @@ fn print_module_info(mbi: &BootInformation) -> anyhow::Result<()> {
     );
     println!(" grub cfg passed as boot module:");
     let grup_cfg_ptr = module.start_address() as *const u32 as *const u8;
-    let grub_cfg = unsafe {
-        core::slice::from_raw_parts(
-            grup_cfg_ptr,
-            module.module_size() as usize,
-        )
-    };
+    let grub_cfg =
+        unsafe { core::slice::from_raw_parts(grup_cfg_ptr, module.module_size() as usize) };
     let grub_cfg = core::str::from_utf8(grub_cfg).map_err(anyhow::Error::msg)?;
     println!("=== file begin ===");
     for line in grub_cfg.lines() {

integration-test/bins/multiboot2_payload/src/integrationtest.rs

@@ -10,24 +10,16 @@ extern crate util;
 core::arch::global_asm!(include_str!("start.S"), options(att_syntax));
 core::arch::global_asm!(include_str!("multiboot2_header.S"));
 
-use alloc::vec;
-use core::panic::PanicInfo;
-use log::{debug, error, info};
-use qemu_exit::QEMUExit;
-use util::init_environment;
+use util::{init_environment, qemu_exit_success};
 
 mod integrationtest;
 
-const QEMU_EXIT_PORT: u16 = 0xf4;
-/// Custom error code to report success.
-const QEMU_EXIT_SUCCESS: u32 = 73;
-
 /// Entry into the Rust code from assembly.
 #[no_mangle]
 fn rust_entry(multiboot2_magic: u32, multiboot2_hdr: *const u32) -> ! {
     main(multiboot2_magic, multiboot2_hdr).expect("Should run multiboot2 integration test");
-    info!("Integration test finished successfully");
-    qemu_exit::x86::X86::new(QEMU_EXIT_PORT, QEMU_EXIT_SUCCESS).exit_success()
+    log::info!("Integration test finished successfully");
+    qemu_exit_success()
 }
 
 /// Executes the main logic.
@@ -36,7 +28,7 @@ fn main(multiboot2_magic: u32, multiboot2_hdr: *const u32) -> anyhow::Result<()>
     if multiboot2_magic != multiboot2::MULTIBOOT2_BOOTLOADER_MAGIC {
         Err(anyhow::Error::msg("Invalid bootloader magic"))?
     }
-    debug!("multiboot2_hdr={multiboot2_hdr:x?}, multiboot2_magic=0x{multiboot2_magic:x?}");
+    log::debug!("multiboot2_hdr={multiboot2_hdr:x?}, multiboot2_magic=0x{multiboot2_magic:x?}");
 
     let mbi = unsafe { multiboot2::load(multiboot2_hdr as _) }.map_err(anyhow::Error::msg)?;
 

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

@@ -8,3 +8,5 @@ publish = false
 [dependencies]
 good_memory_allocator = "0.1.7"
 log = { version = "0.4.17", default-features = false }
+# Wait for release > 3.0.1
+qemu-exit = { git = "https://github.com/rust-embedded/qemu-exit.git", rev = "3cee0efb5c1842b5261850c57b3b4d608542ff03" }

integration-test/tests/multiboot2/rust-toolchain.toml renamed to integration-test/bins/rust-toolchain.toml

@@ -5,12 +5,19 @@ extern crate alloc;
 
 use core::panic::PanicInfo;
 use log::error;
+use qemu_exit::QEMUExit;
+
+static QEMU_EXIT: qemu_exit::X86 = qemu_exit::X86::new(QEMU_EXIT_PORT, QEMU_EXIT_SUCCESS);
 
 #[macro_use]
 pub mod macros;
 pub mod allocator;
 pub mod debugcon;
 
+const QEMU_EXIT_PORT: u16 = 0xf4;
+/// Custom error code to report success.
+const QEMU_EXIT_SUCCESS: u32 = 73;
+
 /// Initializes the environment.
 pub fn init_environment() {
     debugcon::DebugconLogger::init();
@@ -22,5 +29,14 @@ pub fn init_environment() {
 #[panic_handler]
 fn panic_handler(info: &PanicInfo) -> ! {
     error!("PANIC! {}", info);
-    loop {}
+    qemu_exit_failure()
+}
+
+
+pub fn qemu_exit_success() -> ! {
+    QEMU_EXIT.exit_success()
+}
+
+pub fn qemu_exit_failure() -> ! {
+    QEMU_EXIT.exit_failure()
 }