[style] format the code style for axmm

Author: Azure-stars

Cargo.lock

@@ -364,7 +364,7 @@ fn handle_relative_path(dir_fd: isize, path: &str) -> AxResult<String> {
 fn prepend_cwd(path: &str) -> AxResult<String> {
     let cwd = current_dir().map_err(|_| AxError::NotFound)?;
     debug_assert!(cwd.ends_with('/'), "当前工作目录路径应以 '/' 结尾");
-    Ok(format!("{}{}", cwd, path))
+    Ok(format!("{cwd}{path}"))
 }
 
 /// 根据 `force_dir` 和路径结尾调整路径

api/arceos_posix_api/src/imp/path_link.rs

@@ -429,7 +429,7 @@ impl TaskContext {
             self.ext_state.save();
             next_ctx.ext_state.restore();
         }
-        #[cfg(any(feature = "tls"))]
+        #[cfg(feature = "tls")]
         unsafe {
             self.fs_base = super::read_thread_pointer();
             super::write_thread_pointer(next_ctx.fs_base);

modules/axhal/src/arch/x86_64/context.rs

@@ -11,18 +11,17 @@ documentation = "https://arceos-org.github.io/arceos/axmm/index.html"
 
 [features]
 default = []
-cow = []
+cow = ["dep:lazy_static"]
 
 [dependencies]
 axhal = { workspace = true, features = ["paging"] }
 axalloc = { workspace = true }
 axconfig = { workspace = true }
 
-lazy_static = { version = "1.5", features = ["spin_no_std"] }
+lazy_static = { version = "1.5", features = ["spin_no_std"], optional = true }
 log = "=0.4.21"
 axerrno = "0.1"
 lazyinit = "0.2"
 memory_addr = "0.3"
 kspin = "0.1"
 memory_set = "0.3"
-page_table_multiarch = "0.5.3"

modules/axmm/Cargo.toml

@@ -2,14 +2,13 @@ use core::fmt;
 
 use axerrno::{AxError, AxResult, ax_err};
 use axhal::mem::phys_to_virt;
-use axhal::paging::{MappingFlags, PageTable, PagingError};
-use memory_addr::{MemoryAddr, PAGE_SIZE_4K, PhysAddr, VirtAddr, VirtAddrRange, is_aligned};
+use axhal::paging::{MappingFlags, PageSize, PageTable, PagingError};
+use memory_addr::{MemoryAddr, PhysAddr, VirtAddr, VirtAddrRange, is_aligned};
 use memory_set::{MemoryArea, MemorySet};
-use page_table_multiarch::PageSize;
 
 use crate::backend::Backend;
 use crate::mapping_err_to_ax_err;
-use crate::page_iter_wrapper::PageIterWrapper;
+use crate::page_iter_wrapper::{PAGE_SIZE_4K, PageIterWrapper};
 
 #[cfg(feature = "cow")]
 use crate::backend::{alloc_frame, dealloc_frame};
@@ -235,8 +234,8 @@ impl AddrSpace {
     ///
     /// # Parameters
     ///
-    /// - `start`: The starting virtual address of the region to map.
-    /// - `size`: The size (in bytes) of the region.
+    /// - `start`: The starting virtual address of the region to map, which must be page-aligned.
+    /// - `size`: The size (in bytes) of the region, which must also be page-aligned.
     /// - `access_flags` indicates the access type
     ///
     /// # Returns
@@ -269,7 +268,13 @@ impl AddrSpace {
 
             let backend = area.backend();
             if let Backend::Alloc { populate, align } = *backend {
-                for addr in PageIterWrapper::new(start, area.end().min(end), align).unwrap() {
+                for addr in PageIterWrapper::new(
+                    start.align_down(align),
+                    end.align_up(align).min(area.end()),
+                    align,
+                )
+                .unwrap()
+                {
                     match self.pt.query(addr) {
                         #[allow(unused_variables)]
                         Ok((paddr, flags, page_size)) => {
@@ -550,8 +555,8 @@ impl AddrSpace {
     /// ### Behavior without `cow` Feature
     /// - Each mapped page in the original address space is copied into the
     ///   corresponding address in the new address space.
-    /// - If the target address in the new space is not mapped, a page fault is
-    ///   handled via [`Backend::handle_page_fault`], and memory is allocated before copying.
+    /// - If the target address in the new space is not mapped, a page fault will be
+    ///   handled, and memory is allocated before copying.
     /// - The actual copying is done using [`core::ptr::copy_nonoverlapping`] at the
     ///   physical address level.
     pub fn try_clone(&mut self) -> AxResult<Self> {

modules/axmm/src/aspace.rs

@@ -1,8 +1,8 @@
-use crate::page_iter_wrapper::PageIterWrapper;
+use crate::page_iter_wrapper::{PAGE_SIZE_4K, PageIterWrapper};
 use axalloc::global_allocator;
 use axhal::mem::{phys_to_virt, virt_to_phys};
 use axhal::paging::{MappingFlags, PageSize, PageTable};
-use memory_addr::{PAGE_SIZE_4K, PhysAddr, VirtAddr};
+use memory_addr::{PhysAddr, VirtAddr};
 
 #[cfg(feature = "cow")]
 use crate::frameinfo::frame_table;
@@ -28,7 +28,7 @@ use super::Backend;
 /// - If `zeroed` is `true`, the function uses `unsafe` operations to zero out the memory.
 /// - The allocated memory must be accessed via its physical address, which requires
 ///   conversion using `virt_to_phys`.
-pub fn alloc_frame(zeroed: bool, align: PageSize) -> Option<PhysAddr> {
+pub(crate) fn alloc_frame(zeroed: bool, align: PageSize) -> Option<PhysAddr> {
     let page_size: usize = align.into();
     let num_pages = page_size / PAGE_SIZE_4K;
     let vaddr = VirtAddr::from(global_allocator().alloc_pages(num_pages, page_size).ok()?);
@@ -62,7 +62,7 @@ pub fn alloc_frame(zeroed: bool, align: PageSize) -> Option<PhysAddr> {
 ///   otherwise undefined behavior may occur.
 /// - If the deallocation fails, the function will call `panic!`. Details about
 ///   the failure can be obtained from the global memory allocator’s error messages.
-pub fn dealloc_frame(frame: PhysAddr, align: PageSize) {
+pub(crate) fn dealloc_frame(frame: PhysAddr, align: PageSize) {
     #[cfg(feature = "cow")]
     if frame_table().dec_ref(frame) > 1 {
         return;

modules/axmm/src/backend/alloc.rs

@@ -1,6 +1,5 @@
-use axhal::paging::{MappingFlags, PageTable};
+use axhal::paging::{MappingFlags, PageSize, PageTable};
 use memory_addr::{PhysAddr, VirtAddr};
-use page_table_multiarch::PageSize;
 
 use super::Backend;
 

modules/axmm/src/backend/linear.rs

@@ -1,14 +1,13 @@
 //! Memory mapping backends.
 
-use axhal::paging::{MappingFlags, PageTable};
+use axhal::paging::{MappingFlags, PageSize, PageTable};
 use memory_addr::VirtAddr;
 use memory_set::MappingBackend;
-use page_table_multiarch::PageSize;
-
 mod alloc;
 mod linear;
 
-pub use alloc::{alloc_frame, dealloc_frame};
+#[allow(unused_imports)]
+pub(crate) use alloc::{alloc_frame, dealloc_frame};
 
 /// A unified enum type for different memory mapping backends.
 ///

modules/axmm/src/backend/mod.rs

@@ -1,5 +1,3 @@
-//! FrameInfo
-//!
 //! A simple physical FrameInfo manager is provided to track and manage
 //! the reference count for every 4KB memory page frame in the system.
 //!

modules/axmm/src/frameinfo.rs

@@ -10,18 +10,18 @@ mod aspace;
 mod backend;
 #[cfg(feature = "cow")]
 mod frameinfo;
-mod page_iter_wrapper;
 
+pub mod page_iter_wrapper;
 pub use self::aspace::AddrSpace;
 pub use self::backend::Backend;
 
 use axerrno::{AxError, AxResult};
 use axhal::mem::phys_to_virt;
+use axhal::paging::PageSize;
 use kspin::SpinNoIrq;
 use lazyinit::LazyInit;
 use memory_addr::{PhysAddr, va};
 use memory_set::MappingError;
-use page_table_multiarch::PageSize;
 
 static KERNEL_ASPACE: LazyInit<SpinNoIrq<AddrSpace>> = LazyInit::new();