support huge page alloc

Author: Ticonderoga2017

Cargo.lock

@@ -55,6 +55,8 @@ spin = "0.9"
 starry-core = { path = "./core" }
 starry-api = { path = "./api" }
 
+page_table_multiarch = { git = "https://github.com/Mivik/page_table_multiarch.git", rev = "19ededd" }
+
 [package]
 name = "starry"
 version.workspace = true

Cargo.toml

@@ -32,6 +32,8 @@ spin.workspace = true
 
 starry-core.workspace = true
 
+page_table_multiarch.workspace = true
+
 axio = "0.1.1"
 ctor_bare = "0.2.1"
 flatten_objects = "0.2.3"

api/Cargo.toml

@@ -3,10 +3,12 @@ use axerrno::{LinuxError, LinuxResult};
 use axhal::paging::MappingFlags;
 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,
+    MAP_ANONYMOUS, MAP_FIXED, MAP_HUGE_1GB, MAP_HUGE_MASK, MAP_HUGE_SHIFT, MAP_HUGETLB,
+    MAP_NORESERVE, MAP_PRIVATE, MAP_SHARED, MAP_STACK, PROT_EXEC, PROT_GROWSDOWN, PROT_GROWSUP,
+    PROT_READ, PROT_WRITE,
 };
-use memory_addr::{VirtAddr, VirtAddrRange};
+use memory_addr::{MemoryAddr, VirtAddr, VirtAddrRange};
+use page_table_multiarch::PageSize;
 
 use crate::file::{File, FileLike};
 
@@ -82,13 +84,25 @@ pub fn sys_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);
 
+    // The check uses bitwise operations to
+    // verify that exactly one of the two mutually exclusive mapping flags is set
+    if (map_flags.bits() & (MAP_PRIVATE | MAP_SHARED)).count_ones() != 1 {
+        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 = match (flags & MAP_HUGETLB, flags & MAP_HUGE_MASK << MAP_HUGE_SHIFT) {
+        (0, _) => PageSize::Size4K,
+        (_, MAP_HUGE_1GB) => PageSize::Size1G,
+        (_, _) => PageSize::Size2M,
+    };
+
+    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,13 +122,15 @@ 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)?
+            .ok_or(LinuxError::ENOMEM)?    
     };
 
     let populate = if fd == -1 {
@@ -128,6 +144,7 @@ pub fn sys_mmap(
         aligned_length,
         permission_flags.into(),
         populate,
+        page_size,
     )?;
 
     if populate {
@@ -141,7 +158,7 @@ pub fn sys_mmap(
         let length = core::cmp::min(length, file_size - offset);
         let mut buf = vec![0u8; length];
         file.read_at(offset as u64, &mut buf)?;
-        aspace.write(start_addr, &buf)?;
+        aspace.write(start_addr, page_size, &buf)?;
     }
     Ok(start_addr.as_usize() as _)
 }
@@ -150,7 +167,6 @@ 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 start_addr = VirtAddr::from(addr);
     aspace.unmap(start_addr, length)?;
     axhal::arch::flush_tlb(None);
@@ -171,7 +187,7 @@ pub fn sys_mprotect(addr: usize, length: usize, prot: u32) -> LinuxResult<isize>
     let mut aspace = process_data.aspace.lock();
     let length = memory_addr::align_up_4k(length);
     let start_addr = VirtAddr::from(addr);
-    aspace.protect(start_addr, length, permission_flags.into())?;
+    aspace.protect(start_addr, length, permission_flags.into(), PageSize::Size4K)?;
 
     Ok(0)
 }

api/src/imp/mm/mmap.rs

@@ -4,6 +4,7 @@ use axerrno::{LinuxError, LinuxResult};
 use axhal::paging::MappingFlags;
 use axtask::{TaskExtRef, current};
 use memory_addr::{MemoryAddr, PAGE_SIZE_4K, VirtAddr, VirtAddrRange};
+use page_table_multiarch::PageSize;
 use starry_core::mm::access_user_memory;
 
 fn check_region(start: VirtAddr, layout: Layout, access_flags: MappingFlags) -> LinuxResult<()> {
@@ -24,7 +25,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, PageSize::Size4K)?;
 
     Ok(())
 }