Guard the lower 1MB of memory

This also adds a new fuction to ignore the attempts to guard the
lower 1MB if it's really required.

Author: jasoncouture

api/src/info.rs

@@ -141,14 +141,14 @@ impl MemoryRegion {
 /// Represents the different types of memory.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 #[non_exhaustive]
-#[repr(C)]
+#[repr(C, u64)]
 pub enum MemoryRegionKind {
     /// Unused conventional memory, can be used by the kernel.
     Usable,
     /// Memory mappings created by the bootloader, including the page table and boot info mappings.
     ///
     /// This memory should _not_ be used by the kernel.
-    Bootloader,
+    Bootloader = 0x8FFFFFFF,
     /// An unknown memory region reported by the UEFI firmware.
     ///
     /// Contains the UEFI memory type tag.

common/src/legacy_memory_region.rs

@@ -28,6 +28,7 @@ pub struct LegacyFrameAllocator<I, D> {
     memory_map: I,
     current_descriptor: Option<D>,
     next_frame: PhysFrame,
+    start_frame: PhysFrame,
 }
 
 impl<I, D> LegacyFrameAllocator<I, D>
@@ -42,18 +43,32 @@ where
     /// library assumes that references can never point to virtual address `0`.  
     pub fn new(memory_map: I) -> Self {
         // skip frame 0 because the rust core library does not see 0 as a valid address
-        let start_frame = PhysFrame::containing_address(PhysAddr::new(0x1000));
-        Self::new_starting_at(start_frame, memory_map)
+        // also skip the first 1MB of frames, there are use cases that require lower conventional memory access. (Such as SMP SIPI)
+        let start_frame = PhysFrame::containing_address(PhysAddr::new(0x100000));
+        unsafe { Self::unsafe_new_starting_at(start_frame, memory_map) }
     }
 
     /// Creates a new frame allocator based on the given legacy memory regions. Skips any frames
-    /// before the given `frame`.
+    /// before the given `frame`, or 0x100000, whichever is higher.
     pub fn new_starting_at(frame: PhysFrame, memory_map: I) -> Self {
+        if frame.start_address().as_u64() < 0x100000 {
+            // Skip the first 1MB of frames, regardless of what was requested.
+            // there are use cases that require lower conventional memory access. (Such as SMP SIPI)
+            return Self::new(memory_map);
+        }
+
+        return unsafe { Self::unsafe_new_starting_at(frame, memory_map) };
+    }
+
+    /// Creates a new frame allocator based on the given legacy memory regions. Skips any frames
+    /// before the given `frame`, without attempting to protect the lower 1MB of memory.
+    pub unsafe fn unsafe_new_starting_at(frame: PhysFrame, memory_map: I) -> Self {
         Self {
             original: memory_map.clone(),
             memory_map,
             current_descriptor: None,
             next_frame: frame,
+            start_frame: frame,
         }
     }
 
@@ -121,9 +136,11 @@ where
             let next_free = self.next_frame.start_address();
             let kind = match descriptor.kind() {
                 MemoryRegionKind::Usable => {
-                    if end <= next_free {
+                    if end <= next_free && end > self.start_frame.start_address() {
                         MemoryRegionKind::Bootloader
-                    } else if descriptor.start() >= next_free {
+                    } else if descriptor.start() >= next_free
+                        || end <= self.start_frame.start_address()
+                    {
                         MemoryRegionKind::Usable
                     } else {
                         // part of the region is used -> add it separately

uefi/src/memory_descriptor.rs

@@ -20,6 +20,12 @@ impl LegacyMemoryRegion for UefiMemoryDescriptor {
     fn kind(&self) -> MemoryRegionKind {
         match self.0.ty {
             MemoryType::CONVENTIONAL => MemoryRegionKind::Usable,
+            MemoryType::LOADER_CODE => MemoryRegionKind::Usable,
+            // We load the kernel under this type, probably not wise to mark it free after boot, even if it is.
+            // Or perhaps we should use a different memory type (Such as the OS Loader range from the EFI spec (0x80000000-0xFFFFFFFF))?
+            MemoryType::LOADER_DATA => MemoryRegionKind::Bootloader,
+            MemoryType::BOOT_SERVICES_CODE => MemoryRegionKind::Usable,
+            MemoryType::BOOT_SERVICES_DATA => MemoryRegionKind::Usable,
             other => MemoryRegionKind::UnknownUefi(other.0),
         }
     }
@@ -28,7 +34,6 @@ impl LegacyMemoryRegion for UefiMemoryDescriptor {
         match self.0.ty {
             MemoryType::CONVENTIONAL => true,
             MemoryType::LOADER_CODE
-            | MemoryType::LOADER_DATA
             | MemoryType::BOOT_SERVICES_CODE
             | MemoryType::BOOT_SERVICES_DATA => {
                 // we don't need this data anymore after the bootloader