Merge branch 'bullhh-new_alloc' into next

Author: bullhh

Cargo.lock

@@ -15,8 +15,8 @@ tracking = ["dep:percpu", "dep:axbacktrace", "buddy-slab-allocator/tracking"]
 buddy-slab-allocator = {git = "https://github.com/arceos-hypervisor/buddy-slab-allocator.git", branch = "main", features = ["log"] }
 axbacktrace = { workspace = true, optional = true }
 axerrno.workspace = true
-cfg-if.workspace = true
 kspin.workspace = true
+kernel_guard.workspace = true
 log.workspace = true
 memory_addr.workspace = true
 percpu = { workspace = true, optional = true }

modules/axalloc/Cargo.toml

@@ -16,6 +16,8 @@ use buddy_slab_allocator::{AllocResult, PageAllocator};
 use kspin::SpinNoIrq;
 use strum::{IntoStaticStr, VariantArray};
 
+pub use buddy_slab_allocator::AddrTranslator;
+
 // Page size can be configured from here
 const PAGE_SIZE: usize = 0x1000;
 
@@ -78,7 +80,7 @@ impl fmt::Debug for Usages {
 /// This is an adapter around the allocator::GlobalAllocator that provides
 /// compatibility with the original axalloc API.
 pub struct GlobalAllocator {
-    inner: buddy_slab_allocator::GlobalAllocator<PAGE_SIZE>,
+    inner: SpinNoIrq<buddy_slab_allocator::GlobalAllocator<PAGE_SIZE>>,
     usages: SpinNoIrq<Usages>,
 }
 
@@ -92,40 +94,50 @@ impl GlobalAllocator {
     /// Creates an empty [`GlobalAllocator`].
     pub const fn new() -> Self {
         Self {
-            inner: buddy_slab_allocator::GlobalAllocator::<PAGE_SIZE>::new(),
+            inner: SpinNoIrq::new(buddy_slab_allocator::GlobalAllocator::<PAGE_SIZE>::new()),
             usages: SpinNoIrq::new(Usages::new()),
         }
     }
 
+    /// Configure the address translator used by the underlying allocator so
+    /// that it can reason about physical address ranges (e.g. low-memory
+    /// regions below 4GiB).
+    pub fn set_addr_translator(
+        &self,
+        translator: &'static dyn buddy_slab_allocator::AddrTranslator,
+    ) {
+        self.inner.lock().set_addr_translator(translator);
+    }
+
     /// Returns the name of the allocator.
     pub const fn name(&self) -> &'static str {
-        "buddy_slab_allocator"
+        "buddy-slab-allocator"
     }
 
     /// Initializes the allocator with the given region.
     pub fn init(&self, start_vaddr: usize, size: usize) {
         info!(
-            "Initialize global memory allocator, addr:[{:#x}-{:#x})",
-            start_vaddr, start_vaddr + size
+            "Initialize global memory allocator, start_vaddr: {}, size: {}",
+            start_vaddr, size
         );
-        if let Err(e) = self.inner.init(start_vaddr, size) {
+        if let Err(e) = self.inner.lock().init(start_vaddr, size) {
             panic!("Failed to initialize allocator: {:?}", e);
         }
     }
 
     /// Add the given region to the allocator.
     pub fn add_memory(&self, start_vaddr: usize, size: usize) -> AllocResult {
-         info!(
-            "Add memory region to allocator, addr:[{:#x}-{:#x})",
-            start_vaddr, start_vaddr + size
+        info!(
+            "Add memory region, start_vaddr: {}, size: {}",
+            start_vaddr, size
         );
-        self.inner.add_memory(start_vaddr, size)
+        self.inner.lock().add_memory(start_vaddr, size)
     }
 
     /// Allocate arbitrary number of bytes. Returns the left bound of the
     /// allocated region.
     pub fn alloc(&self, layout: Layout) -> AllocResult<NonNull<u8>> {
-        let result = self.inner.alloc(layout);
+        let result = self.inner.lock().alloc(layout);
         if let Ok(_ptr) = result {
             self.usages.lock().alloc(UsageKind::RustHeap, layout.size());
         }
@@ -137,7 +149,7 @@ impl GlobalAllocator {
         self.usages
             .lock()
             .dealloc(UsageKind::RustHeap, layout.size());
-        self.inner.dealloc(pos, layout);
+        self.inner.lock().dealloc(pos, layout);
     }
 
     /// Allocates contiguous pages.
@@ -147,7 +159,22 @@ impl GlobalAllocator {
         alignment: usize,
         kind: UsageKind,
     ) -> AllocResult<usize> {
-        let result = self.inner.alloc_pages(num_pages, alignment);
+        let result = self.inner.lock().alloc_pages(num_pages, alignment);
+        if let Ok(_addr) = result {
+            let size = num_pages * PAGE_SIZE;
+            self.usages.lock().alloc(kind, size);
+        }
+        result
+    }
+
+    /// Allocates contiguous low-memory pages (physical address < 4GiB).
+    pub fn alloc_dma32_pages(
+        &self,
+        num_pages: usize,
+        alignment: usize,
+        kind: UsageKind,
+    ) -> AllocResult<usize> {
+        let result = self.inner.lock().alloc_dma32_pages(num_pages, alignment);
         if let Ok(_addr) = result {
             let size = num_pages * PAGE_SIZE;
             self.usages.lock().alloc(kind, size);
@@ -157,13 +184,16 @@ impl GlobalAllocator {
 
     /// Allocates contiguous pages starting from the given address.
     pub fn alloc_pages_at(
-        &mut self,
+        &self,
         start: usize,
         num_pages: usize,
         alignment: usize,
         kind: UsageKind,
     ) -> AllocResult<usize> {
-        let result = self.inner.alloc_pages_at(start, num_pages, alignment);
+        let result = self
+            .inner
+            .lock()
+            .alloc_pages_at(start, num_pages, alignment);
         if let Ok(_addr) = result {
             let size = num_pages * PAGE_SIZE;
             self.usages.lock().alloc(kind, size);
@@ -175,35 +205,35 @@ impl GlobalAllocator {
     pub fn dealloc_pages(&self, pos: usize, num_pages: usize, kind: UsageKind) {
         let size = num_pages * PAGE_SIZE;
         self.usages.lock().dealloc(kind, size);
-        self.inner.dealloc_pages(pos, num_pages);
+        self.inner.lock().dealloc_pages(pos, num_pages);
     }
 
     /// Returns the number of allocated bytes in the byte allocator.
     #[cfg(feature = "tracking")]
     pub fn used_bytes(&self) -> usize {
-        let stats = self.inner.get_stats();
+        let stats = self.inner.lock().get_stats();
         stats.heap_bytes + stats.slab_bytes
     }
 
     /// Returns the number of available bytes in the byte allocator.
     #[cfg(feature = "tracking")]
     pub fn available_bytes(&self) -> usize {
         // The new allocator doesn't have this exact method, so we approximate
-        let stats = self.inner.get_stats();
+        let stats = self.inner.lock().get_stats();
         stats.free_pages * PAGE_SIZE
     }
 
     /// Returns the number of allocated pages in the page allocator.
     #[cfg(feature = "tracking")]
     pub fn used_pages(&self) -> usize {
-        let stats = self.inner.get_stats();
+        let stats = self.inner.lock().get_stats();
         stats.used_pages
     }
 
     /// Returns the number of available pages in the page allocator.
     #[cfg(feature = "tracking")]
     pub fn available_pages(&self) -> usize {
-        let stats = self.inner.get_stats();
+        let stats = self.inner.lock().get_stats();
         stats.free_pages
     }
 
@@ -312,8 +342,30 @@ pub fn global_init(start_vaddr: usize, size: usize) {
     info!("global allocator initialized");
 }
 
+struct FnAddrTranslator {
+    func: fn(memory_addr::VirtAddr) -> memory_addr::PhysAddr,
+}
+
+impl buddy_slab_allocator::AddrTranslator for FnAddrTranslator {
+    fn virt_to_phys(&self, va: usize) -> Option<usize> {
+        Some((self.func)(memory_addr::VirtAddr::from(va)).as_usize())
+    }
+}
+
+static mut GLOBAL_ADDR_TRANSLATOR: FnAddrTranslator = FnAddrTranslator {
+    func: |_| memory_addr::PhysAddr::from(0usize),
+};
+
+pub fn configure_addr_translator(func: fn(memory_addr::VirtAddr) -> memory_addr::PhysAddr) {
+    unsafe {
+        GLOBAL_ADDR_TRANSLATOR.func = func;
+        let translator: &'static FnAddrTranslator = &*(&raw const GLOBAL_ADDR_TRANSLATOR);
+        GLOBAL_ALLOCATOR.set_addr_translator(translator);
+    }
+}
+
 /// Add the given memory region to the global allocator.
-///
+
 /// Users should ensure that the region is valid and not being used by others,
 /// so that the allocated memory is also valid.
 ///

modules/axalloc/src/lib.rs

@@ -226,12 +226,14 @@ pub fn rust_main(cpu_id: usize, arg: usize) -> ! {
 
 #[cfg(feature = "alloc")]
 fn init_allocator() {
-    use axhal::mem::{MemRegionFlags, memory_regions, phys_to_virt};
+    use axhal::mem::{MemRegionFlags, VirtAddr, memory_regions, phys_to_virt, virt_to_phys};
     use memory_addr::MemoryAddr;
 
     info!("Initialize global memory allocator...");
     info!("  use {} allocator.", axalloc::global_allocator().name());
 
+    axalloc::configure_addr_translator(virt_to_phys);
+    
     let mut max_region_size = 0;
     let mut max_region_paddr = 0.into();
     let mut use_next_free = false;