Report UEFI/BIOS memory type IDs in memory map

Also: Reuse some UEFI regions that are no longer needed as `Usable` before switching to kernel.

Author: phil-opp

src/binary/bios/memory_descriptor.rs

@@ -1,4 +1,4 @@
-use crate::binary::legacy_memory_region::LegacyMemoryRegion;
+use crate::{binary::legacy_memory_region::LegacyMemoryRegion, memory_map::MemoryRegionKind};
 use x86_64::PhysAddr;
 
 impl LegacyMemoryRegion for E820MemoryRegion {
@@ -10,8 +10,11 @@ impl LegacyMemoryRegion for E820MemoryRegion {
         self.len
     }
 
-    fn usable(&self) -> bool {
-        self.region_type == 1
+    fn kind(&self) -> MemoryRegionKind {
+        match self.region_type {
+            1 => MemoryRegionKind::Usable,
+            other => MemoryRegionKind::UnknownBios(other),
+        }
     }
 
     fn set_start(&mut self, new_start: PhysAddr) {
@@ -28,22 +31,3 @@ pub struct E820MemoryRegion {
     pub region_type: u32,
     pub acpi_extended_attributes: u32,
 }
-
-/*
-impl From<E820MemoryRegion> for MemoryRegion {
-    fn from(region: E820MemoryRegion) -> MemoryRegion {
-        let region_type = match region.region_type {
-            1 => MemoryRegionType::Usable,
-            2 => MemoryRegionType::Reserved,
-            3 => MemoryRegionType::AcpiReclaimable,
-            4 => MemoryRegionType::AcpiNvs,
-            5 => MemoryRegionType::BadMemory,
-            t => panic!("invalid region type {}", t),
-        };
-        MemoryRegion {
-            range: FrameRange::new(region.start_addr, region.start_addr + region.len),
-            region_type,
-        }
-    }
-}
-*/

src/binary/legacy_memory_region.rs

@@ -1,4 +1,4 @@
-use crate::memory_map::MemoryRegion;
+use crate::memory_map::{MemoryRegion, MemoryRegionKind};
 use core::mem::MaybeUninit;
 use x86_64::{
     structures::paging::{FrameAllocator, PhysFrame, Size4KiB},
@@ -8,7 +8,7 @@ use x86_64::{
 pub trait LegacyMemoryRegion: Copy + core::fmt::Debug {
     fn start(&self) -> PhysAddr;
     fn len(&self) -> u64;
-    fn usable(&self) -> bool;
+    fn kind(&self) -> MemoryRegionKind;
 
     fn set_start(&mut self, new_start: PhysAddr);
 }
@@ -76,34 +76,47 @@ where
         self,
         regions: &mut [MaybeUninit<MemoryRegion>],
     ) -> &mut [MemoryRegion] {
-        use crate::memory_map::MemoryRegionKind;
-
         let mut next_index = 0;
 
         for mut descriptor in self.original {
             let end = descriptor.start() + descriptor.len();
             let next_free = self.next_frame.start_address();
-            let kind = if descriptor.usable() {
-                if end <= next_free {
-                    MemoryRegionKind::Bootloader
-                } else if descriptor.start() >= next_free {
-                    MemoryRegionKind::Usable
-                } else {
-                    // part of the region is used -> add is separately
-                    let used_region = MemoryRegion {
-                        start: descriptor.start().as_u64(),
-                        end: next_free.as_u64(),
-                        kind: MemoryRegionKind::Bootloader,
-                    };
-                    Self::add_region(used_region, regions, &mut next_index)
-                        .expect("Failed to add memory region");
-
-                    // add unused part normally
-                    descriptor.set_start(next_free);
-                    MemoryRegionKind::Usable
+            let kind = match descriptor.kind() {
+                MemoryRegionKind::Usable => {
+                    if end <= next_free {
+                        MemoryRegionKind::Bootloader
+                    } else if descriptor.start() >= next_free {
+                        MemoryRegionKind::Usable
+                    } else {
+                        // part of the region is used -> add is separately
+                        let used_region = MemoryRegion {
+                            start: descriptor.start().as_u64(),
+                            end: next_free.as_u64(),
+                            kind: MemoryRegionKind::Bootloader,
+                        };
+                        Self::add_region(used_region, regions, &mut next_index)
+                            .expect("Failed to add memory region");
+
+                        // add unused part normally
+                        descriptor.set_start(next_free);
+                        MemoryRegionKind::Usable
+                    }
+                }
+                // some mappings created by the UEFI firmware become usable again at this point
+                #[cfg(feature = "uefi_bin")]
+                MemoryRegionKind::UnknownUefi(other) => {
+                    use uefi::table::boot::MemoryType as M;
+                    match M::custom(other) {
+                        M::LOADER_CODE
+                        | M::LOADER_DATA
+                        | M::BOOT_SERVICES_CODE
+                        | M::BOOT_SERVICES_DATA
+                        | M::RUNTIME_SERVICES_CODE
+                        | M::RUNTIME_SERVICES_DATA => MemoryRegionKind::Usable,
+                        other => MemoryRegionKind::UnknownUefi(other.0),
+                    }
                 }
-            } else {
-                MemoryRegionKind::Reserved // FIXME more types
+                other => other,
             };
 
             let region = MemoryRegion {
@@ -152,7 +165,7 @@ where
 
         // find next suitable descriptor
         while let Some(descriptor) = self.memory_map.next() {
-            if !descriptor.usable() {
+            if descriptor.kind() != MemoryRegionKind::Usable {
                 continue;
             }
             if let Some(frame) = self.allocate_frame_from_descriptor(descriptor) {

src/binary/uefi/memory_descriptor.rs

@@ -1,4 +1,4 @@
-use crate::binary::legacy_memory_region::LegacyMemoryRegion;
+use crate::{binary::legacy_memory_region::LegacyMemoryRegion, memory_map::MemoryRegionKind};
 use uefi::table::boot::{MemoryDescriptor, MemoryType};
 use x86_64::PhysAddr;
 
@@ -13,8 +13,11 @@ impl<'a> LegacyMemoryRegion for MemoryDescriptor {
         self.page_count * PAGE_SIZE
     }
 
-    fn usable(&self) -> bool {
-        self.ty == MemoryType::CONVENTIONAL
+    fn kind(&self) -> MemoryRegionKind {
+        match self.ty {
+            MemoryType::CONVENTIONAL => MemoryRegionKind::Usable,
+            other => MemoryRegionKind::UnknownUefi(other.0),
+        }
     }
 
     fn set_start(&mut self, new_start: PhysAddr) {

src/memory_map.rs

@@ -16,8 +16,20 @@ impl MemoryRegion {
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[non_exhaustive]
 pub enum MemoryRegionKind {
+    /// Unused conventional memory, can be used by the kernel.
     Usable,
-    Reserved,
+    /// Memory mappings created by the bootloader, including the kernel and boot info mappings.
+    ///
+    /// This memory should _not_ be used by the kernel.
     Bootloader,
+    /// An unknown memory region reported by the UEFI firmware.
+    ///
+    /// This should only be used if the UEFI memory type is known as usable.
+    UnknownUefi(u32),
+    /// An unknown memory region reported by the BIOS firmware.
+    ///
+    /// This should only be used if the BIOS memory type is known as usable.
+    UnknownBios(u32),
 }