UEFI Allocator: Implement cores allocator_api

uefi-test-runner/src/boot/memory.rs

@@ -1,15 +1,11 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use alloc::vec::Vec;
-use uefi::boot;
-use uefi::mem::memory_map::{MemoryMap, MemoryMapMut};
-use uefi_raw::table::boot::MemoryType;
-
 pub fn test() {
     info!("Testing memory functions");
 
     bootservices::allocate_pages();
     bootservices::allocate_pool();
+    bootservices::test_memory_map();
 
     global::alloc_vec();
     global::alloc_alignment();
@@ -19,8 +15,10 @@ pub fn test() {
 
 /// Tests that directly use UEFI boot services to allocate memory.
 mod bootservices {
+    use alloc::vec::Vec;
     use uefi::boot;
     use uefi::boot::AllocateType;
+    use uefi::mem::memory_map::{MemoryMap, MemoryMapMut};
     use uefi_raw::table::boot::MemoryType;
 
     /// Tests the `allocate_pages` boot service.
@@ -53,6 +51,44 @@ mod bootservices {
         }
         unsafe { boot::free_pool(ptr) }.unwrap();
     }
+
+    /// Tests getting the memory map.
+    pub fn test_memory_map() {
+        info!("Testing memory map functions");
+
+        let mut memory_map =
+            boot::memory_map(MemoryType::LOADER_DATA).expect("Failed to retrieve UEFI memory map");
+
+        memory_map.sort();
+
+        // Collect the descriptors into a vector
+        let descriptors = memory_map.entries().copied().collect::<Vec<_>>();
+
+        // Ensured we have at least one entry.
+        // Real memory maps usually have dozens of entries.
+        assert!(!descriptors.is_empty(), "Memory map is empty");
+
+        let mut curr_value = descriptors[0];
+
+        for value in descriptors.iter().skip(1) {
+            if value.phys_start <= curr_value.phys_start {
+                panic!("memory map sorting failed");
+            }
+            curr_value = *value;
+        }
+
+        // This is pretty much a basic sanity test to ensure returned memory
+        // isn't filled with random values.
+        let first_desc = descriptors[0];
+
+        #[cfg(target_arch = "x86_64")]
+        {
+            let phys_start = first_desc.phys_start;
+            assert_eq!(phys_start, 0, "Memory does not start at address 0");
+        }
+        let page_count = first_desc.page_count;
+        assert!(page_count != 0, "Memory map entry has size zero");
+    }
 }
 
 /// Tests that use [`uefi::allocator::Allocator`], which is configured as the
@@ -97,40 +133,3 @@ mod global {
         }
     }
 }
-
-fn test_memory_map() {
-    info!("Testing memory map functions");
-
-    let mut memory_map =
-        boot::memory_map(MemoryType::LOADER_DATA).expect("Failed to retrieve UEFI memory map");
-
-    memory_map.sort();
-
-    // Collect the descriptors into a vector
-    let descriptors = memory_map.entries().copied().collect::<Vec<_>>();
-
-    // Ensured we have at least one entry.
-    // Real memory maps usually have dozens of entries.
-    assert!(!descriptors.is_empty(), "Memory map is empty");
-
-    let mut curr_value = descriptors[0];
-
-    for value in descriptors.iter().skip(1) {
-        if value.phys_start <= curr_value.phys_start {
-            panic!("memory map sorting failed");
-        }
-        curr_value = *value;
-    }
-
-    // This is pretty much a basic sanity test to ensure returned memory
-    // isn't filled with random values.
-    let first_desc = descriptors[0];
-
-    #[cfg(target_arch = "x86_64")]
-    {
-        let phys_start = first_desc.phys_start;
-        assert_eq!(phys_start, 0, "Memory does not start at address 0");
-    }
-    let page_count = first_desc.page_count;
-    assert!(page_count != 0, "Memory map entry has size zero");
-}

uefi/CHANGELOG.md

@@ -41,8 +41,10 @@
 - The `Display` impl for `CStr8` now excludes the trailing null character.
 - `VariableKeys` initializes with a larger name buffer to work around firmware
   bugs on some devices.
-- The UEFI `allocator::Allocator` has been optimized for page-aligned 
+- The UEFI `allocator::Allocator` has been optimized for page-aligned
   allocations.
+- The UEFI `allocator::Allocator` now implements `core::alloc::Allocator`
+  (`allocator_api`), when the `unstable` feature is used.
 
 
 # uefi - 0.34.1 (2025-02-07)

uefi/src/allocator.rs

@@ -169,3 +169,17 @@ unsafe impl GlobalAlloc for Allocator {
         }
     }
 }
+
+#[cfg(feature = "unstable")]
+unsafe impl core::alloc::Allocator for Allocator {
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
+        let ptr = unsafe { <Allocator as GlobalAlloc>::alloc(self, layout) };
+        NonNull::new(ptr)
+            .ok_or(core::alloc::AllocError)
+            .map(|ptr| NonNull::slice_from_raw_parts(ptr, layout.size()))
+    }
+
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        unsafe { <Allocator as GlobalAlloc>::dealloc(self, ptr.as_ptr(), layout) }
+    }
+}

uefi/src/lib.rs

@@ -212,7 +212,7 @@
 //! [uefi-std-tr-issue]: https://github.com/rust-lang/rust/issues/100499
 //! [unstable features]: https://doc.rust-lang.org/unstable-book/
 
-#![cfg_attr(all(feature = "unstable", feature = "alloc"), feature(allocator_api))]
+#![cfg_attr(feature = "unstable", feature(allocator_api))]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![no_std]
 #![deny(