Use new UEFI bootloader

Makefile

@@ -193,7 +193,7 @@ ifeq ($(boot_spec), uefi)
 		--release \
 		-Z bindeps \
 		--manifest-path \
-		$(ROOT_DIR)/tools/uefi_builder/Cargo.toml -- \
+		$(ROOT_DIR)/tools/uefi_builder/x86_64/Cargo.toml -- \
 		--kernel $(nano_core_binary) \
 		--modules $(OBJECT_FILES_BUILD_DIR) \
 		--efi-image $(iso) \

kernel/boot_info/Cargo.toml

@@ -11,11 +11,10 @@ kernel_config = { path = "../kernel_config" }
 memory_structs = { path = "../memory_structs" }
 multiboot2 = { version = "0.14", optional = true }
 
-[dependencies.bootloader_api]
-git = "https://github.com/theseus-os/bootloader"
-branch = "theseus"
+[dependencies.uefi-bootloader-api]
+git = "https://github.com/theseus-os/uefi-bootloader"
 optional = true
 
 [features]
-uefi = ["dep:bootloader_api"]
+uefi = ["dep:uefi-bootloader-api"]
 multiboot2 = ["dep:multiboot2"]

kernel/boot_info/src/lib.rs

@@ -38,7 +38,8 @@ pub trait ElfSection {
     /// Returns the section's starting virtual address.
     fn start(&self) -> VirtualAddress;
 
-    /// Returns the section's length.
+    /// Returns the section's length in memory, as opposed to its length in the
+    /// ELF file.
     fn len(&self) -> usize;
 
     /// Returns whether the section is empty.
@@ -121,8 +122,8 @@ pub trait BootInformation: 'static {
         &self,
     ) -> Result<Self::AdditionalReservedMemoryRegions, &'static str>;
 
-    /// Returns the end of the kernel's image in physical memory.
-    fn kernel_end(&self) -> Result<PhysicalAddress, &'static str>;
+    /// Returns the end of the kernel's image in memory.
+    fn kernel_end(&self) -> Result<VirtualAddress, &'static str>;
 
     /// Returns the RSDP if it was provided by the bootloader.
     fn rsdp(&self) -> Option<PhysicalAddress>;

kernel/boot_info/src/multiboot2.rs

@@ -196,9 +196,12 @@ impl crate::BootInformation for multiboot2::BootInformation {
         .into_iter())
     }
 
-    fn kernel_end(&self) -> Result<PhysicalAddress, &'static str> {
-        let reserved_region = kernel_memory_region(self)?;
-        Ok(reserved_region.start + reserved_region.len)
+    fn kernel_end(&self) -> Result<VirtualAddress, &'static str> {
+        use crate::ElfSection;
+        self.elf_sections()?
+            .map(|section| section.start() + section.len())
+            .max()
+            .ok_or("no elf sections")
     }
 
     fn rsdp(&self) -> Option<PhysicalAddress> {

kernel/boot_info/src/uefi.rs

@@ -1,7 +1,6 @@
 use crate::ElfSectionFlags;
-use bootloader_api::info;
 use core::iter::{Iterator, Peekable};
-use kernel_config::memory::{KERNEL_OFFSET, KERNEL_STACK_SIZE_IN_PAGES, PAGE_SIZE};
+use kernel_config::memory::{KERNEL_STACK_SIZE_IN_PAGES, PAGE_SIZE};
 use memory_structs::{PhysicalAddress, VirtualAddress};
 
 // TODO: Ideally this would be defined in nano_core. However, that would
@@ -11,66 +10,50 @@ use memory_structs::{PhysicalAddress, VirtualAddress};
 pub const STACK_SIZE: usize = (KERNEL_STACK_SIZE_IN_PAGES + 2) * PAGE_SIZE;
 
 /// A custom memory region kind used by the bootloader for the modules.
-const MODULES_MEMORY_KIND: info::MemoryRegionKind = info::MemoryRegionKind::UnknownUefi(0x80000000);
+const MODULES_MEMORY_KIND: uefi_bootloader_api::MemoryRegionKind =
+    uefi_bootloader_api::MemoryRegionKind::UnknownUefi(0x80000000);
 
-pub struct MemoryRegion {
-    start: PhysicalAddress,
-    len: usize,
-    is_usable: bool,
-}
-
-impl From<info::MemoryRegion> for MemoryRegion {
-    fn from(info::MemoryRegion { start, end, kind }: info::MemoryRegion) -> Self {
-        Self {
-            start: PhysicalAddress::new_canonical(start as usize),
-            len: (end - start) as usize,
-            is_usable: matches!(kind, info::MemoryRegionKind::Usable),
-        }
-    }
-}
-
-impl crate::MemoryRegion for MemoryRegion {
+impl crate::MemoryRegion for uefi_bootloader_api::MemoryRegion {
     fn start(&self) -> PhysicalAddress {
-        self.start
+        PhysicalAddress::new_canonical(self.start)
     }
 
     fn len(&self) -> usize {
         self.len
     }
 
     fn is_usable(&self) -> bool {
-        self.is_usable
+        matches!(self.kind, uefi_bootloader_api::MemoryRegionKind::Usable)
     }
 }
 
-pub struct MemoryRegions {
-    inner: Peekable<core::slice::Iter<'static, info::MemoryRegion>>,
+pub struct MemoryRegions<'a> {
+    inner: Peekable<core::slice::Iter<'a, uefi_bootloader_api::MemoryRegion>>,
 }
 
-impl Iterator for MemoryRegions {
-    type Item = MemoryRegion;
+impl<'a> Iterator for MemoryRegions<'a> {
+    type Item = uefi_bootloader_api::MemoryRegion;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let mut area: MemoryRegion = (*self.inner.next()?).into();
+        let mut region = *self.inner.next()?;
 
         // UEFI often separates contiguous memory into separate memory regions. We
         // consolidate them to minimise the number of entries in the frame allocator's
         // reserved and available lists.
-        while let Some(next) = self.inner.next_if(|next| {
-            let next = MemoryRegion::from(**next);
-            area.is_usable == next.is_usable && (area.start + area.len) == next.start
-        }) {
-            let next = MemoryRegion::from(*next);
-            area.len += next.len;
+        while let Some(next) = self
+            .inner
+            .next_if(|next| region.kind == next.kind && (region.start + region.len) == next.start)
+        {
+            region.len += next.len;
         }
 
-        Some(area)
+        Some(region)
     }
 }
 
-impl<'a> crate::ElfSection for &'a info::ElfSection {
+impl<'a> crate::ElfSection for &'a uefi_bootloader_api::ElfSection {
     fn name(&self) -> &str {
-        info::ElfSection::name(self)
+        uefi_bootloader_api::ElfSection::name(self)
     }
 
     fn start(&self) -> VirtualAddress {
@@ -86,14 +69,15 @@ impl<'a> crate::ElfSection for &'a info::ElfSection {
     }
 }
 
+#[derive(Debug)]
 pub struct Module {
-    inner: info::Module,
-    regions: &'static info::MemoryRegions,
+    inner: uefi_bootloader_api::Module,
+    regions: &'static uefi_bootloader_api::MemoryRegions,
 }
 
 impl crate::Module for Module {
     fn name(&self) -> Result<&str, &'static str> {
-        Ok(info::Module::name(&self.inner))
+        Ok(uefi_bootloader_api::Module::name(&self.inner))
     }
 
     fn start(&self) -> PhysicalAddress {
@@ -113,8 +97,8 @@ impl crate::Module for Module {
 }
 
 pub struct Modules {
-    inner: &'static info::Modules,
-    regions: &'static info::MemoryRegions,
+    inner: &'static uefi_bootloader_api::Modules,
+    regions: &'static uefi_bootloader_api::MemoryRegions,
     index: usize,
 }
 
@@ -132,12 +116,12 @@ impl Iterator for Modules {
     }
 }
 
-impl crate::BootInformation for &'static bootloader_api::BootInfo {
-    type MemoryRegion<'a> = MemoryRegion;
-    type MemoryRegions<'a> = MemoryRegions;
+impl crate::BootInformation for &'static uefi_bootloader_api::BootInformation {
+    type MemoryRegion<'a> = uefi_bootloader_api::MemoryRegion;
+    type MemoryRegions<'a> = MemoryRegions<'a>;
 
-    type ElfSection<'a> = &'a info::ElfSection;
-    type ElfSections<'a> = core::slice::Iter<'a, info::ElfSection>;
+    type ElfSection<'a> = &'a uefi_bootloader_api::ElfSection;
+    type ElfSections<'a> = core::slice::Iter<'a, uefi_bootloader_api::ElfSection>;
 
     type Module<'a> = Module;
     type Modules<'a> = Modules;
@@ -176,24 +160,23 @@ impl crate::BootInformation for &'static bootloader_api::BootInfo {
         Ok(core::iter::empty())
     }
 
-    fn kernel_end(&self) -> Result<PhysicalAddress, &'static str> {
+    fn kernel_end(&self) -> Result<VirtualAddress, &'static str> {
         use crate::ElfSection;
 
-        PhysicalAddress::new(
+        VirtualAddress::new(
             self.elf_sections()?
                 .filter(|section| section.flags().contains(ElfSectionFlags::ALLOCATED))
+                .filter(|section| section.size > 0)
                 .map(|section| section.start + section.size)
                 .max()
-                .ok_or("couldn't find kernel end address")? as usize
-                - KERNEL_OFFSET,
+                .ok_or("couldn't find kernel end address")? as usize,
         )
-        .ok_or("kernel physical end address was invalid")
+        .ok_or("kernel virtual end address was invalid")
     }
 
     fn rsdp(&self) -> Option<PhysicalAddress> {
-        self.rsdp_addr
-            .into_option()
-            .map(|address| PhysicalAddress::new_canonical(address as usize))
+        self.rsdp_address
+            .map(|address| PhysicalAddress::new_canonical(address))
     }
 
     fn stack_size(&self) -> Result<usize, &'static str> {

kernel/captain/src/lib.rs

@@ -85,6 +85,7 @@ pub fn init(
     bsp_initial_stack: NoDrop<Stack>,
     ap_start_realmode_begin: VirtualAddress,
     ap_start_realmode_end: VirtualAddress,
+    ap_gdt: VirtualAddress,
     rsdp_address: Option<PhysicalAddress>,
 ) -> Result<(), &'static str> {
     #[cfg(mirror_log_to_vga)]
@@ -128,6 +129,7 @@ pub fn init(
         &kernel_mmi_ref,
         ap_start_realmode_begin,
         ap_start_realmode_end,
+        ap_gdt,
         Some(kernel_config::display::FRAMEBUFFER_MAX_RESOLUTION),
     )?;
     let cpu_count = ap_count + 1;

kernel/memory/src/lib.rs

@@ -21,6 +21,7 @@ mod paging;
 pub use self::paging::{
     PageTable, Mapper, Mutability, Mutable, Immutable,
     MappedPages, BorrowedMappedPages, BorrowedSliceMappedPages,
+    translate,
 };
 
 pub use memory_structs::{Frame, Page, FrameRange, PageRange, VirtualAddress, PhysicalAddress};
@@ -220,7 +221,18 @@ pub fn init(
     debug!("Initialized new frame allocator!");
     frame_allocator::dump_frame_allocator_state();
 
-    page_allocator::init(VirtualAddress::new_canonical(boot_info.kernel_end()?.value()))?;
+    page_allocator::init(
+        VirtualAddress::new(
+            // We subtract 1 when translating because `kernel_end` returns an exclusive
+            // upper bound, which can cause problems if the kernel ends on a page boundary.
+            // We then add it back later to get the correct identity virtual address.
+            translate(boot_info.kernel_end()? - 1)
+                .ok_or("couldn't translate kernel end virtual address")?
+                .value()
+                + 1,
+        )
+        .ok_or("couldn't convert kernel end physical address into virtual address")?,
+    )?;
     debug!("Initialized new page allocator!");
     page_allocator::dump_page_allocator_state();
 

kernel/memory/src/paging/mapper.rs

@@ -50,6 +50,11 @@ use owned_borrowed_trait::{OwnedOrBorrowed, Owned, Borrowed};
 /// that it is only invoked for `UnmappedFrames`.
 pub(super) static INTO_ALLOCATED_FRAMES_FUNC: Once<fn(FrameRange) -> AllocatedFrames> = Once::new();
 
+/// A convenience function to translate the given virtual address into a
+/// physical address using the currently-active page table.
+pub fn translate(virtual_address: VirtualAddress) -> Option<PhysicalAddress> {
+    Mapper::from_current().translate(virtual_address)
+}
 
 pub struct Mapper {
     p4: Unique<Table<Level4>>,