Trying to get tests to work

Author: jasoncouture

Diff for: tests/default_settings.rs

@@ -4,7 +4,7 @@ use bootloader_test_runner::run_test_kernel;
 fn basic_boot() {
     run_test_kernel(
         env!("CARGO_BIN_FILE_TEST_KERNEL_DEFAULT_SETTINGS_basic_boot"),
-        None,
+        Some("tests/ramdisk.txt"),
     );
 }
 

Diff for: tests/ramdisk.rs

@@ -1,21 +1,20 @@
 use std::path::Path;
 
 use bootloader_test_runner::run_test_kernel;
+static RAMDISK_PATH: &str = "tests/ramdisk.txt";
 
 #[test]
 fn basic_boot() {
-    let ramdisk = Path::new("ramdisk.txt").canonicalize().unwrap();
     run_test_kernel(
         env!("CARGO_BIN_FILE_TEST_KERNEL_RAMDISK_basic_boot"),
-        Some(&ramdisk),
+        Some(RAMDISK_PATH),
     );
 }
 
 #[test]
 fn check_ramdisk() {
-    let ramdisk = Path::new("ramdisk.txt").canonicalize().unwrap();
     run_test_kernel(
         env!("CARGO_BIN_FILE_TEST_KERNEL_RAMDISK_ramdisk"),
-        Some(&ramdisk),
+        Some(RAMDISK_PATH),
     );
 }

Diff for: tests/runner/src/lib.rs

@@ -8,10 +8,16 @@ const QEMU_ARGS: &[&str] = &[
     "-display",
     "none",
     "--no-reboot",
+    "-m",
+    "size=2048",
 ];
 
-pub fn run_test_kernel(kernel_binary_path: &str, ramdisk_path: Option<&Path>) {
+pub fn run_test_kernel(kernel_binary_path: &str, ramdisk_path: Option<&str>) {
     let kernel_path = Path::new(kernel_binary_path);
+    let ramdisk_path = match ramdisk_path {
+        Some(rdp) => Some(Path::new(rdp)),
+        None => None
+    };
 
     // create an MBR disk image for legacy BIOS booting
     let mbr_path = kernel_path.with_extension("mbr");

Diff for: tests/test_kernels/default_settings/src/bin/basic_boot.rs

@@ -2,20 +2,20 @@
 #![no_main] // disable all Rust-level entry points
 
 use bootloader_api::{entry_point, BootInfo};
-use test_kernel_default_settings::{exit_qemu, QemuExitCode};
+use core::fmt::Write;
+use test_kernel_default_settings::{exit_qemu, QemuExitCode, serial};
 
 entry_point!(kernel_main);
 
-fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
+    writeln!(serial(), "Entered kernel with boot info: {:?}", boot_info).unwrap();
     exit_qemu(QemuExitCode::Success);
 }
 
 /// This function is called on panic.
 #[panic_handler]
 #[cfg(not(test))]
 fn panic(info: &core::panic::PanicInfo) -> ! {
-    use core::fmt::Write;
-
-    let _ = writeln!(test_kernel_default_settings::serial(), "PANIC: {}", info);
+    let _ = writeln!(serial(), "PANIC: {}", info);
     exit_qemu(QemuExitCode::Failed);
 }

Diff for: uefi/src/main.rs

@@ -11,7 +11,6 @@ use bootloader_x86_64_common::{
 use core::{
     cell::UnsafeCell,
     fmt::Write,
-    mem,
     ops::{Deref, DerefMut},
     ptr, slice,
 };
@@ -32,7 +31,7 @@ use uefi::{
         ProtocolPointer,
     },
     table::boot::{
-        AllocateType, MemoryDescriptor, MemoryType, OpenProtocolAttributes, OpenProtocolParams,
+        AllocateType, MemoryType, OpenProtocolAttributes, OpenProtocolParams,
         ScopedProtocol,
     },
     CStr16, CStr8,
@@ -73,6 +72,7 @@ fn efi_main(image: Handle, st: SystemTable<Boot>) -> Status {
 
 fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
     // temporarily clone the y table for printing panics
+
     unsafe {
         *SYSTEM_TABLE.get() = Some(st.unsafe_clone());
     }
@@ -111,28 +111,52 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
     .unwrap();
 
     let framebuffer = init_logger(&st, kernel.config);
-
-    // we no longer need the system table for printing panics
-    unsafe {
-        *SYSTEM_TABLE.get() = None;
+    if let Some(_) = framebuffer {
+        // we no longer need the system table for printing panics
+        unsafe {
+            *SYSTEM_TABLE.get() = None;
+        }
+    } else {
+        writeln!(
+            stdout,
+            "Framebuffer not found, keeping stdout and SYSTEM_TABLE"
+        )
+        .unwrap();
     }
 
     log::info!("UEFI bootloader started");
     log::info!("Reading kernel and configuration from disk was successful");
     if let Some(framebuffer) = framebuffer {
         log::info!("Using framebuffer at {:#x}", framebuffer.addr);
     }
-
+    writeln!(stdout, "Creating memory map storage").unwrap();
     let mmap_storage = {
-        let max_mmap_size =
-            st.boot_services().memory_map_size().map_size + 8 * mem::size_of::<MemoryDescriptor>();
-        let ptr = st
-            .boot_services()
-            .allocate_pool(MemoryType::LOADER_DATA, max_mmap_size)
-            .expect("Failed to allocate memory for mmap storage");
-        unsafe { slice::from_raw_parts_mut(ptr, max_mmap_size) }
+        let mut memory_map_size = st.boot_services().memory_map_size();
+        let mut target_size = memory_map_size.map_size + (64 * memory_map_size.entry_size);
+        let mut storage: &mut [u8];
+        loop {
+            let ptr = st
+                .boot_services()
+                .allocate_pool(MemoryType::LOADER_DATA, target_size)
+                .expect("Failed to allocate memory for mmap storage");
+            storage = unsafe { slice::from_raw_parts_mut(ptr, target_size) };
+            if let Err(_) = st.boot_services().memory_map(storage) {
+                memory_map_size = st.boot_services().memory_map_size();
+                // By measuring the size here, we can find out exactly how much we need.
+                // We may hit this code twice, if the map allocation ends up spanning more pages.
+                let next_target_size = memory_map_size.map_size + (64 * memory_map_size.entry_size);
+                writeln!(stdout, "Allocated {} bytes for the memory map, but we need {}, trying again.", target_size, next_target_size).unwrap();
+                target_size = next_target_size;
+                st.boot_services().free_pool(ptr).expect("Failed to free temporary memory for memory map!");
+                continue;
+            }
+            writeln!(stdout, "Allocated {} bytes for memory map storage, reported required is {}", target_size, memory_map_size.map_size).unwrap();
+            break;
+        }
+        storage
     };
 
+    writeln!(stdout, "Exiting boot services").unwrap();
     log::trace!("exiting boot services");
     let (system_table, memory_map) = st
         .exit_boot_services(image, mmap_storage)
@@ -443,12 +467,20 @@ fn create_page_tables(
 }
 
 fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> Option<RawFrameBufferInfo> {
-    let gop = unsafe {
+    let stdout = unsafe { (&mut *SYSTEM_TABLE.get()).as_mut().unwrap().stdout() };
+    writeln!(stdout, "Attempting to open GOP").unwrap();
+    let gop_handle = st
+        .boot_services()
+        .get_handle_for_protocol::<GraphicsOutput>()
+        .ok()?;
+    writeln!(stdout, "Opened GOP handle: {:?}", gop_handle).unwrap();
+    let mut gop = unsafe {
+
         st.boot_services()
-            .locate_protocol::<GraphicsOutput>()
+            .open_protocol::<GraphicsOutput>(OpenProtocolParams { handle: gop_handle, agent: st.boot_services().image_handle(), controller: None }, OpenProtocolAttributes::Exclusive)
             .ok()?
     };
-    let gop = unsafe { &mut *gop.get() };
+    writeln!(stdout, "Opened GOP, getting framebuffer info").unwrap();
 
     let mode = {
         let modes = gop.modes();
@@ -474,6 +506,7 @@ fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> Option<RawFr
         }
     };
     if let Some(mode) = mode {
+        writeln!(stdout, "Setting graphics mode to {:?}", mode.info()).unwrap();
         gop.set_mode(&mode)
             .expect("Failed to apply the desired display mode");
     }
@@ -495,10 +528,9 @@ fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> Option<RawFr
         bytes_per_pixel: 4,
         stride: mode_info.stride(),
     };
-
-    log::info!("UEFI boot");
-
+    writeln!(stdout, "Switching to framebuffer logging.").unwrap();
     bootloader_x86_64_common::init_logger(slice, info);
+    log::info!("UEFI boot");
 
     Some(RawFrameBufferInfo {
         addr: PhysAddr::new(framebuffer.as_mut_ptr() as u64),