First working version of dynamic kernel loading in UEFI bootloader

Author: phil-opp

src/bin/uefi.rs

@@ -4,12 +4,9 @@
 #![feature(maybe_uninit_extra)]
 #![deny(unsafe_op_in_unsafe_fn)]
 
-#[repr(align(4096))]
-struct PageAligned<T>(T);
-
 use bootloader::binary::{legacy_memory_region::LegacyFrameAllocator, Kernel, SystemInfo};
 use bootloader_api::{info::FrameBufferInfo, BootloaderConfig};
-use core::{arch::asm, mem, panic::PanicInfo, ptr, slice};
+use core::{arch::asm, cell::UnsafeCell, fmt::Write, mem, panic::PanicInfo, ptr, slice};
 use uefi::{
     prelude::{entry, Boot, Handle, ResultExt, Status, SystemTable},
     proto::{
@@ -22,46 +19,125 @@ use uefi::{
         },
     },
     table::boot::{AllocateType, MemoryDescriptor, MemoryType},
-    CStr16, Completion,
+    Completion,
 };
 use x86_64::{
     structures::paging::{FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB},
     PhysAddr, VirtAddr,
 };
 use xmas_elf::ElfFile;
 
+static SYSTEM_TABLE: VeryUnsafeCell<Option<SystemTable<Boot>>> = VeryUnsafeCell::new(None);
+
+struct VeryUnsafeCell<T>(UnsafeCell<T>);
+
+impl<T> VeryUnsafeCell<T> {
+    const fn new(v: T) -> Self {
+        Self(UnsafeCell::new(v))
+    }
+}
+
+unsafe impl<T> Sync for VeryUnsafeCell<T> {}
+
+impl<T> core::ops::Deref for VeryUnsafeCell<T> {
+    type Target = UnsafeCell<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 #[entry]
 fn efi_main(image: Handle, st: SystemTable<Boot>) -> Status {
     main_inner(image, st)
 }
 
 fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
-    let mut buf = [0; 100];
-    st.stdout()
-        .output_string(
-            CStr16::from_str_with_buf("UEFI bootloader started; trying to load kernel", &mut buf)
-                .unwrap(),
-        )
-        .unwrap()
-        .unwrap();
+    // temporarily clone the system table for printing panics
+    unsafe {
+        *SYSTEM_TABLE.get() = Some(st.unsafe_clone());
+    }
+
+    st.stdout().clear().unwrap().unwrap();
+    writeln!(
+        st.stdout(),
+        "UEFI bootloader started; trying to load kernel"
+    )
+    .unwrap();
+
+    let kernel = load_kernel(image, &st);
+
+    let (framebuffer_addr, framebuffer_info) = init_logger(&st, kernel.config);
+
+    // we no longer need the system table for printing panics
+    unsafe {
+        *SYSTEM_TABLE.get() = None;
+    }
+
+    log::info!("UEFI bootloader started");
+    log::info!("Reading kernel and configuration from disk was successful");
+    log::info!("Using framebuffer at {:#x}", framebuffer_addr);
+
+    let mmap_storage = {
+        let max_mmap_size =
+            st.boot_services().memory_map_size() + 8 * mem::size_of::<MemoryDescriptor>();
+        let ptr = st
+            .boot_services()
+            .allocate_pool(MemoryType::LOADER_DATA, max_mmap_size)?
+            .log();
+        unsafe { slice::from_raw_parts_mut(ptr, max_mmap_size) }
+    };
+
+    log::trace!("exiting boot services");
+    let (system_table, memory_map) = st
+        .exit_boot_services(image, mmap_storage)
+        .expect_success("Failed to exit boot services");
+
+    let mut frame_allocator = LegacyFrameAllocator::new(memory_map.copied());
+
+    let page_tables = create_page_tables(&mut frame_allocator);
+
+    let system_info = SystemInfo {
+        framebuffer_addr,
+        framebuffer_info,
+        rsdp_addr: {
+            use uefi::table::cfg;
+            let mut config_entries = system_table.config_table().iter();
+            // look for an ACPI2 RSDP first
+            let acpi2_rsdp = config_entries.find(|entry| matches!(entry.guid, cfg::ACPI2_GUID));
+            // if no ACPI2 RSDP is found, look for a ACPI1 RSDP
+            let rsdp = acpi2_rsdp
+                .or_else(|| config_entries.find(|entry| matches!(entry.guid, cfg::ACPI_GUID)));
+            rsdp.map(|entry| PhysAddr::new(entry.address as u64))
+        },
+    };
 
+    bootloader::binary::load_and_switch_to_kernel(
+        kernel,
+        frame_allocator,
+        page_tables,
+        system_info,
+    );
+}
+
+fn load_kernel(image: Handle, st: &SystemTable<Boot>) -> Kernel<'static> {
     let file_system_raw = {
         let ref this = st.boot_services();
         let loaded_image = this
-            .handle_protocol::<LoadedImage>(image)?
-            .expect("Failed to retrieve `LoadedImage` protocol from handle");
+            .handle_protocol::<LoadedImage>(image)
+            .expect_success("Failed to retrieve `LoadedImage` protocol from handle");
         let loaded_image = unsafe { &*loaded_image.get() };
 
         let device_handle = loaded_image.device();
 
         let device_path = this
-            .handle_protocol::<DevicePath>(device_handle)?
-            .expect("Failed to retrieve `DevicePath` protocol from image's device handle");
+            .handle_protocol::<DevicePath>(device_handle)
+            .expect_success("Failed to retrieve `DevicePath` protocol from image's device handle");
         let mut device_path = unsafe { &*device_path.get() };
 
         let device_handle = this
-            .locate_device_path::<SimpleFileSystem>(&mut device_path)?
-            .expect("Failed to locate `SimpleFileSystem` protocol on device path");
+            .locate_device_path::<SimpleFileSystem>(&mut device_path)
+            .expect_success("Failed to locate `SimpleFileSystem` protocol on device path");
 
         this.handle_protocol::<SimpleFileSystem>(device_handle)
     }
@@ -72,14 +148,14 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
     let mut root = file_system.open_volume().unwrap().unwrap();
     let kernel_file_handle = root
         .open("kernel-x86_64", FileMode::Read, FileAttribute::empty())
-        .unwrap()
+        .expect("Failed to load kernel (expected file named `kernel-x86_64`)")
         .unwrap();
     let mut kernel_file = match kernel_file_handle.into_type().unwrap().unwrap() {
         uefi::proto::media::file::FileType::Regular(f) => f,
         uefi::proto::media::file::FileType::Dir(_) => panic!(),
     };
 
-    let mut buf = [0; 100];
+    let mut buf = [0; 500];
     let kernel_info: &mut FileInfo = kernel_file.get_info(&mut buf).unwrap().unwrap();
     let kernel_size = usize::try_from(kernel_info.file_size()).unwrap();
 
@@ -106,56 +182,10 @@ fn main_inner(image: Handle, mut st: SystemTable<Boot>) -> Status {
         BootloaderConfig::deserialize(raw).unwrap()
     };
 
-    let kernel = Kernel {
+    Kernel {
         elf: kernel_elf,
         config,
-    };
-
-    let (framebuffer_addr, framebuffer_info) = init_logger(&st, config);
-    log::info!("UEFI bootloader started");
-    log::info!("Reading kernel and configuration from disk was successful");
-    log::info!("Using framebuffer at {:#x}", framebuffer_addr);
-
-    let mmap_storage = {
-        let max_mmap_size =
-            st.boot_services().memory_map_size() + 8 * mem::size_of::<MemoryDescriptor>();
-        let ptr = st
-            .boot_services()
-            .allocate_pool(MemoryType::LOADER_DATA, max_mmap_size)?
-            .log();
-        unsafe { slice::from_raw_parts_mut(ptr, max_mmap_size) }
-    };
-
-    log::trace!("exiting boot services");
-    let (system_table, memory_map) = st
-        .exit_boot_services(image, mmap_storage)
-        .expect_success("Failed to exit boot services");
-
-    let mut frame_allocator = LegacyFrameAllocator::new(memory_map.copied());
-
-    let page_tables = create_page_tables(&mut frame_allocator);
-
-    let system_info = SystemInfo {
-        framebuffer_addr,
-        framebuffer_info,
-        rsdp_addr: {
-            use uefi::table::cfg;
-            let mut config_entries = system_table.config_table().iter();
-            // look for an ACPI2 RSDP first
-            let acpi2_rsdp = config_entries.find(|entry| matches!(entry.guid, cfg::ACPI2_GUID));
-            // if no ACPI2 RSDP is found, look for a ACPI1 RSDP
-            let rsdp = acpi2_rsdp
-                .or_else(|| config_entries.find(|entry| matches!(entry.guid, cfg::ACPI_GUID)));
-            rsdp.map(|entry| PhysAddr::new(entry.address as u64))
-        },
-    };
-
-    bootloader::binary::load_and_switch_to_kernel(
-        kernel,
-        frame_allocator,
-        page_tables,
-        system_info,
-    );
+    }
 }
 
 /// Creates page table abstraction types for both the bootloader and kernel page tables.
@@ -286,12 +316,17 @@ fn init_logger(st: &SystemTable<Boot>, config: BootloaderConfig) -> (PhysAddr, F
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
+    if let Some(st) = unsafe { &mut *SYSTEM_TABLE.get() } {
+        let _ = writeln!(st.stdout(), "{}", info);
+    }
+
     unsafe {
         bootloader::binary::logger::LOGGER
             .get()
             .map(|l| l.force_unlock())
     };
     log::error!("{}", info);
+
     loop {
         unsafe { asm!("cli; hlt") };
     }