[mm] support huge page alloc (oscomp#54)

1. Support hugepage mmap.
2. Modify the testcase to avoid panic when allocating multiple consecutive 1GB huge pages.

Author: Ticonderoga2017

Cargo.lock

@@ -44,7 +44,7 @@ axfs-ng-vfs = { git = "https://github.com/Mivik/axfs-ng-vfs", rev = "517cd09" }
 axerrno = "0.1"
 bitflags = "2.6"
 cfg-if = "1.0"
-linkme = "0.3"
+linkme = "0.3.33"
 linux-raw-sys = { version = "0.9.3", default-features = false, features = [
     "no_std",
     "general",

Cargo.toml

@@ -14,6 +14,7 @@ use linux_raw_sys::ctypes::{c_long, c_ushort};
 use linux_raw_sys::general::*;
 use memory_addr::{PAGE_SIZE_4K, VirtAddr, VirtAddrRange};
 use page_table_entry::MappingFlags;
+use page_table_multiarch::PageSize;
 
 use crate::imp::ipc::{BiBTreeMap, IPCID_ALLOCATOR};
 use crate::ptr::{UserPtr, nullable};
@@ -388,12 +389,14 @@ pub fn sys_shmat(shmid: i32, addr: usize, shmflg: u32) -> LinuxResult<isize> {
             VirtAddr::from(start_aligned),
             length,
             VirtAddrRange::new(aspace.base(), aspace.end()),
+            PageSize::Size4K,
         )
         .or_else(|| {
             aspace.find_free_area(
                 aspace.base(),
                 length,
                 VirtAddrRange::new(aspace.base(), aspace.end()),
+                PageSize::Size4K,
             )
         })
         .ok_or(LinuxError::ENOMEM)?;
@@ -413,10 +416,16 @@ pub fn sys_shmat(shmid: i32, addr: usize, shmflg: u32) -> LinuxResult<isize> {
     // map the virtual address range to the physical address
     if let Some(phys_pages) = shm_inner.phys_pages.clone() {
         // Another proccess has attached the shared memory
-        aspace.map_shared(start_addr, length, mapping_flags, Some(phys_pages))?;
+        aspace.map_shared(
+            start_addr,
+            length,
+            mapping_flags,
+            Some(phys_pages),
+            PageSize::Size4K,
+        )?;
     } else {
         // This is the first process to attach the shared memory
-        let result = aspace.map_shared(start_addr, length, mapping_flags, None);
+        let result = aspace.map_shared(start_addr, length, mapping_flags, None, PageSize::Size4K);
 
         match result {
             Ok(pages) => {

api/src/imp/ipc/shm.rs

@@ -1,12 +1,9 @@
 use alloc::vec;
 use axerrno::{LinuxError, LinuxResult};
-use axhal::paging::MappingFlags;
+use axhal::paging::{MappingFlags, PageSize};
 use axtask::{TaskExtRef, current};
-use linux_raw_sys::general::{
-    MAP_ANONYMOUS, MAP_FIXED, MAP_NORESERVE, MAP_PRIVATE, MAP_SHARED, MAP_STACK, PROT_EXEC,
-    PROT_GROWSDOWN, PROT_GROWSUP, PROT_READ, PROT_WRITE,
-};
-use memory_addr::{VirtAddr, VirtAddrRange};
+use linux_raw_sys::general::*;
+use memory_addr::{MemoryAddr, VirtAddr, VirtAddrRange, align_up_4k};
 
 use crate::file::{File, FileLike};
 
@@ -63,6 +60,10 @@ bitflags::bitflags! {
         const NORESERVE = MAP_NORESERVE;
         /// Allocation is for a stack.
         const STACK = MAP_STACK;
+        /// Huge page
+        const HUGE = MAP_HUGETLB;
+        /// Huge page 1g size
+        const HUGE_1GB = MAP_HUGETLB | MAP_HUGE_1GB;
     }
 }
 
@@ -81,14 +82,25 @@ pub fn sys_mmap(
     // TODO: check illegal flags for mmap
     // An example is the flags contained none of MAP_PRIVATE, MAP_SHARED, or MAP_SHARED_VALIDATE.
     let map_flags = MmapFlags::from_bits_truncate(flags);
+    if map_flags.contains(MmapFlags::PRIVATE | MmapFlags::SHARED) {
+        return Err(LinuxError::EINVAL);
+    }
 
     info!(
         "sys_mmap: addr: {:x?}, length: {:x?}, prot: {:?}, flags: {:?}, fd: {:?}, offset: {:?}",
         addr, length, permission_flags, map_flags, fd, offset
     );
 
-    let start = memory_addr::align_down_4k(addr);
-    let end = memory_addr::align_up_4k(addr + length);
+    let page_size = if map_flags.contains(MmapFlags::HUGE_1GB) {
+        PageSize::Size1G
+    } else if map_flags.contains(MmapFlags::HUGE) {
+        PageSize::Size2M
+    } else {
+        PageSize::Size4K
+    };
+
+    let start = addr.align_down(page_size);
+    let end = (addr + length).align_up(page_size);
     let aligned_length = end - start;
     debug!(
         "start: {:x?}, end: {:x?}, aligned_length: {:x?}",
@@ -108,11 +120,13 @@ pub fn sys_mmap(
                 VirtAddr::from(start),
                 aligned_length,
                 VirtAddrRange::new(aspace.base(), aspace.end()),
+                page_size,
             )
             .or(aspace.find_free_area(
                 aspace.base(),
                 aligned_length,
                 VirtAddrRange::new(aspace.base(), aspace.end()),
+                page_size,
             ))
             .ok_or(LinuxError::ENOMEM)?
     };
@@ -128,6 +142,7 @@ pub fn sys_mmap(
         aligned_length,
         permission_flags.into(),
         populate,
+        page_size,
     )?;
 
     if populate {
@@ -141,7 +156,7 @@ pub fn sys_mmap(
         let length = core::cmp::min(length, file_size - offset);
         let mut buf = vec![0u8; length];
         file.read_at(&mut buf, offset as u64)?;
-        aspace.write(start_addr, &buf)?;
+        aspace.write(start_addr, page_size, &buf)?;
     }
     Ok(start_addr.as_usize() as _)
 }
@@ -150,7 +165,7 @@ pub fn sys_munmap(addr: usize, length: usize) -> LinuxResult<isize> {
     let curr = current();
     let process_data = curr.task_ext().process_data();
     let mut aspace = process_data.aspace.lock();
-    let length = memory_addr::align_up_4k(length);
+    let length = align_up_4k(length);
     let start_addr = VirtAddr::from(addr);
     aspace.unmap(start_addr, length)?;
     axhal::arch::flush_tlb(None);
@@ -169,8 +184,9 @@ pub fn sys_mprotect(addr: usize, length: usize, prot: u32) -> LinuxResult<isize>
     let curr = current();
     let process_data = curr.task_ext().process_data();
     let mut aspace = process_data.aspace.lock();
-    let length = memory_addr::align_up_4k(length);
+    let length = align_up_4k(length);
     let start_addr = VirtAddr::from(addr);
+    // TODO: is 4k right here?
     aspace.protect(start_addr, length, permission_flags.into())?;
 
     Ok(0)

api/src/imp/mm/mmap.rs

@@ -153,7 +153,7 @@ pub fn sys_clone(
             curr.task_ext().process_data().aspace.clone()
         } else {
             let mut aspace = curr.task_ext().process_data().aspace.lock();
-            let mut aspace = aspace.clone_or_err()?;
+            let mut aspace = aspace.try_clone()?;
             copy_from_kernel(&mut aspace)?;
             Arc::new(Mutex::new(aspace))
         };

api/src/imp/task/clone.rs

@@ -24,7 +24,7 @@ fn check_region(start: VirtAddr, layout: Layout, access_flags: MappingFlags) ->
 
     let page_start = start.align_down_4k();
     let page_end = (start + layout.size()).align_up_4k();
-    aspace.populate_area(page_start, page_end - page_start)?;
+    aspace.populate_area(page_start, page_end - page_start, access_flags)?;
 
     Ok(())
 }