Refactor the source structure in aster_frame::mm

docs/src/framework/a-100-line-kernel.md

@@ -56,7 +56,7 @@ use aster_frame::cpu::UserContext;
 use aster_frame::prelude::*;
 use aster_frame::task::{Task, TaskOptions};
 use aster_frame::user::{ReturnReason, UserMode, UserSpace};
-use aster_frame::mm::{PageFlags, PAGE_SIZE, Vaddr, VmAllocOptions, VmIo, VmMapOptions, VmSpace};
+use aster_frame::mm::{PageFlags, PAGE_SIZE, Vaddr, FrameAllocOptions, VmIo, VmMapOptions, VmSpace};
 
 /// The kernel's boot and initialization process is managed by Asterinas Framework.
 /// After the process is done, the kernel's execution environment
@@ -73,7 +73,7 @@ pub fn main() {
 fn create_user_space(program: &[u8]) -> UserSpace {
     let user_pages = {
         let nframes = program.len().align_up(PAGE_SIZE) / PAGE_SIZE;
-        let vm_frames = VmAllocOptions::new(nframes).alloc().unwrap();
+        let vm_frames = FrameAllocOptions::new(nframes).alloc().unwrap();
         // Phyiscal memory pages can be only accessed
         // via the Frame abstraction.
         vm_frames.write_bytes(0, program).unwrap();

framework/aster-frame/src/arch/x86/iommu/context_table.rs

@@ -13,7 +13,7 @@ use crate::{
         dma::Daddr,
         page_prop::{CachePolicy, PageProperty, PrivilegedPageFlags as PrivFlags},
         page_table::PageTableError,
-        Frame, Paddr, PageFlags, PageTable, VmAllocOptions, VmIo, PAGE_SIZE,
+        Frame, FrameAllocOptions, Paddr, PageFlags, PageTable, VmIo, PAGE_SIZE,
     },
 };
 
@@ -51,7 +51,7 @@ pub enum ContextTableError {
 impl RootTable {
     pub fn new() -> Self {
         Self {
-            root_frame: VmAllocOptions::new(1).alloc_single().unwrap(),
+            root_frame: FrameAllocOptions::new(1).alloc_single().unwrap(),
             context_tables: BTreeMap::new(),
         }
     }
@@ -240,7 +240,7 @@ pub struct ContextTable {
 impl ContextTable {
     fn new() -> Self {
         Self {
-            entries_frame: VmAllocOptions::new(1).alloc_single().unwrap(),
+            entries_frame: FrameAllocOptions::new(1).alloc_single().unwrap(),
             page_tables: BTreeMap::new(),
         }
     }

framework/aster-frame/src/lib.rs

@@ -51,6 +51,14 @@ use tdx_guest::init_tdx;
 
 pub use self::{cpu::CpuLocal, error::Error, prelude::Result};
 
+/// Initialize the framework.
+///
+/// This function represents the first phase booting up the system. It makes
+/// all functionalities of the framework available after the call.
+///
+/// TODO: We need to refactor this function to make it more modular and
+/// make inter-initialization-dependencies more clear and reduce usages of
+/// boot stage only global variables.
 pub fn init() {
     arch::before_all_init();
     logger::init();

framework/aster-frame/src/mm/dma/dma_coherent.rs

@@ -190,11 +190,11 @@ mod test {
     use alloc::vec;
 
     use super::*;
-    use crate::mm::VmAllocOptions;
+    use crate::mm::FrameAllocOptions;
 
     #[ktest]
     fn map_with_coherent_device() {
-        let vm_segment = VmAllocOptions::new(1)
+        let vm_segment = FrameAllocOptions::new(1)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -204,7 +204,7 @@ mod test {
 
     #[ktest]
     fn map_with_incoherent_device() {
-        let vm_segment = VmAllocOptions::new(1)
+        let vm_segment = FrameAllocOptions::new(1)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -217,7 +217,7 @@ mod test {
 
     #[ktest]
     fn duplicate_map() {
-        let vm_segment_parent = VmAllocOptions::new(2)
+        let vm_segment_parent = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -229,7 +229,7 @@ mod test {
 
     #[ktest]
     fn read_and_write() {
-        let vm_segment = VmAllocOptions::new(2)
+        let vm_segment = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -244,7 +244,7 @@ mod test {
 
     #[ktest]
     fn reader_and_wirter() {
-        let vm_segment = VmAllocOptions::new(2)
+        let vm_segment = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();

framework/aster-frame/src/mm/dma/dma_stream.rs

@@ -294,11 +294,11 @@ mod test {
     use alloc::vec;
 
     use super::*;
-    use crate::mm::VmAllocOptions;
+    use crate::mm::FrameAllocOptions;
 
     #[ktest]
     fn streaming_map() {
-        let vm_segment = VmAllocOptions::new(1)
+        let vm_segment = FrameAllocOptions::new(1)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -309,7 +309,7 @@ mod test {
 
     #[ktest]
     fn duplicate_map() {
-        let vm_segment_parent = VmAllocOptions::new(2)
+        let vm_segment_parent = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -322,7 +322,7 @@ mod test {
 
     #[ktest]
     fn read_and_write() {
-        let vm_segment = VmAllocOptions::new(2)
+        let vm_segment = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();
@@ -338,7 +338,7 @@ mod test {
 
     #[ktest]
     fn reader_and_wirter() {
-        let vm_segment = VmAllocOptions::new(2)
+        let vm_segment = FrameAllocOptions::new(2)
             .is_contiguous(true)
             .alloc_contiguous()
             .unwrap();

framework/aster-frame/src/mm/frame/frame_vec.rs

@@ -9,15 +9,15 @@ use crate::{
 
 /// A collection of base page frames (regular physical memory pages).
 ///
-/// For the most parts, `VmFrameVec` is like `Vec<Frame>`. But the
+/// For the most parts, `FrameVec` is like `Vec<Frame>`. But the
 /// implementation may or may not be based on `Vec`. Having a dedicated
 /// type to represent a series of page frames is convenient because,
 /// more often than not, one needs to operate on a batch of frames rather
 /// a single frame.
 #[derive(Debug, Clone)]
-pub struct VmFrameVec(pub(crate) Vec<Frame>);
+pub struct FrameVec(pub(crate) Vec<Frame>);
 
-impl VmFrameVec {
+impl FrameVec {
     pub fn get(&self, index: usize) -> Option<&Frame> {
         self.0.get(index)
     }
@@ -47,7 +47,7 @@ impl VmFrameVec {
     }
 
     /// Append some frames.
-    pub fn append(&mut self, more: &mut VmFrameVec) -> Result<()> {
+    pub fn append(&mut self, more: &mut FrameVec) -> Result<()> {
         self.0.append(&mut more.0);
         Ok(())
     }
@@ -89,7 +89,7 @@ impl VmFrameVec {
     }
 }
 
-impl IntoIterator for VmFrameVec {
+impl IntoIterator for FrameVec {
     type Item = Frame;
 
     type IntoIter = alloc::vec::IntoIter<Self::Item>;
@@ -99,7 +99,7 @@ impl IntoIterator for VmFrameVec {
     }
 }
 
-impl VmIo for VmFrameVec {
+impl VmIo for FrameVec {
     fn read_bytes(&self, offset: usize, buf: &mut [u8]) -> Result<()> {
         // Do bound check with potential integer overflow in mind
         let max_offset = offset.checked_add(buf.len()).ok_or(Error::Overflow)?;
@@ -143,12 +143,12 @@ impl VmIo for VmFrameVec {
 
 /// An iterator for frames.
 pub struct FrameVecIter<'a> {
-    frames: &'a VmFrameVec,
+    frames: &'a FrameVec,
     current: usize,
 }
 
 impl<'a> FrameVecIter<'a> {
-    pub fn new(frames: &'a VmFrameVec) -> Self {
+    pub fn new(frames: &'a FrameVec) -> Self {
         Self { frames, current: 0 }
     }
 }

framework/aster-frame/src/mm/frame/mod.rs

@@ -1,8 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
 
+//! Untyped physical memory management.
+//!
+//! A frame is a special page (defined in [`super::page`]) that is _untyped_
+//! memory. It is used to store data irrelevant to the integrity of the kernel.
+//! All pages mapped to the virtual address space of the users are backed by
+//! frames. Frames, with all the properties of pages, can additionally be safely
+//! read and written by the kernel or the user.
+
+pub mod frame_vec;
+pub mod options;
+pub mod segment;
+
 use core::mem::ManuallyDrop;
 
-use super::{
+pub use frame_vec::{FrameVec, FrameVecIter};
+pub use segment::Segment;
+
+use super::page::{
     allocator,
     meta::{FrameMeta, MetaSlot, PageMeta, PageUsage},
     Page,

framework/aster-frame/src/mm/frame/options.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use super::{page::allocator, Frame, Segment, VmFrameVec};
+use super::{Frame, FrameVec, Segment};
-use crate::{prelude::*, Error};
+use crate::{mm::page::allocator, prelude::*, Error};
 
 /// Options for allocating physical memory pages (or frames).
 ///
@@ -10,13 +10,13 @@ use crate::{prelude::*, Error};
 /// may store Rust objects or affect Rust memory safety, e.g.,
 /// the code and data segments of the OS kernel, the stack and heap
 /// allocated for the OS kernel.
-pub struct VmAllocOptions {
+pub struct FrameAllocOptions {
     nframes: usize,
     is_contiguous: bool,
     uninit: bool,
 }
 
-impl VmAllocOptions {
+impl FrameAllocOptions {
     /// Creates new options for allocating the specified number of frames.
     pub fn new(nframes: usize) -> Self {
         Self {
@@ -46,7 +46,7 @@ impl VmAllocOptions {
     }
 
     /// Allocate a collection of page frames according to the given options.
-    pub fn alloc(&self) -> Result<VmFrameVec> {
+    pub fn alloc(&self) -> Result<FrameVec> {
         let frames = if self.is_contiguous {
             allocator::alloc(self.nframes).ok_or(Error::NoMemory)?
         } else {
@@ -54,7 +54,7 @@ impl VmAllocOptions {
             for _ in 0..self.nframes {
                 frame_list.push(allocator::alloc_single().ok_or(Error::NoMemory)?);
             }
-            VmFrameVec(frame_list)
+            FrameVec(frame_list)
         };
         if !self.uninit {
             for frame in frames.iter() {
@@ -102,9 +102,9 @@ impl VmAllocOptions {
 fn test_alloc_dealloc() {
     // Here we allocate and deallocate frames in random orders to test the allocator.
     // We expect the test to fail if the underlying implementation panics.
-    let single_options = VmAllocOptions::new(1);
+    let single_options = FrameAllocOptions::new(1);
-    let multi_options = VmAllocOptions::new(10);
+    let multi_options = FrameAllocOptions::new(10);
-    let mut contiguous_options = VmAllocOptions::new(10);
+    let mut contiguous_options = FrameAllocOptions::new(10);
     contiguous_options.is_contiguous(true);
     let mut remember_vec = Vec::new();
     for i in 0..10 {

framework/aster-frame/src/mm/frame/segment.rs

@@ -2,19 +2,22 @@
 
 use core::ops::Range;
 
-use super::{
+use super::Frame;
-    allocator,
-    meta::{PageMeta, PageUsage, SegmentHeadMeta},
-    Frame, Page,
-};
 use crate::{
-    mm::{HasPaddr, Paddr, VmIo, VmReader, VmWriter, PAGE_SIZE},
+    mm::{
+        page::{
+            allocator,
+            meta::{PageMeta, PageUsage, SegmentHeadMeta},
+            Page,
+        },
+        HasPaddr, Paddr, VmIo, VmReader, VmWriter, PAGE_SIZE,
+    },
     Error, Result,
 };
 
 /// A handle to a contiguous range of page frames (physical memory pages).
 ///
-/// The biggest difference between `Segment` and `VmFrameVec` is that
+/// The biggest difference between `Segment` and `FrameVec` is that
 /// the page frames must be contiguous for `Segment`.
 ///
 /// A cloned `Segment` refers to the same page frames as the original.
@@ -24,7 +27,7 @@ use crate::{
 /// #Example
 ///
 /// ```rust
-/// let vm_segment = VmAllocOptions::new(2)
+/// let vm_segment = FrameAllocOptions::new(2)
 ///     .is_contiguous(true)
 ///     .alloc_contiguous()?;
 /// vm_segment.write_bytes(0, buf)?;

framework/aster-frame/src/mm/io.rs

@@ -9,7 +9,7 @@ use pod::Pod;
 use crate::prelude::*;
 
 /// A trait that enables reading/writing data from/to a VM object,
-/// e.g., `VmSpace`, `VmFrameVec`, and `Frame`.
+/// e.g., `VmSpace`, `FrameVec`, and `Frame`.
 ///
 /// # Concurrency
 ///

framework/aster-frame/src/mm/mod.rs

@@ -9,11 +9,11 @@ pub type Vaddr = usize;
 pub type Paddr = usize;
 
 pub(crate) mod dma;
+pub mod frame;
 pub(crate) mod heap_allocator;
 mod io;
 pub(crate) mod kspace;
 mod offset;
-mod options;
 pub(crate) mod page;
 pub(crate) mod page_prop;
 pub(crate) mod page_table;
@@ -26,9 +26,8 @@ use spin::Once;
 
 pub use self::{
     dma::{Daddr, DmaCoherent, DmaDirection, DmaStream, DmaStreamSlice, HasDaddr},
+    frame::{options::FrameAllocOptions, Frame, FrameVec, FrameVecIter, Segment},
     io::{VmIo, VmReader, VmWriter},
-    options::VmAllocOptions,
-    page::{Frame, FrameVecIter, Segment, VmFrameVec},
     page_prop::{CachePolicy, PageFlags, PageProperty},
     space::{VmMapOptions, VmSpace},
 };

framework/aster-frame/src/mm/page/allocator.rs

@@ -1,5 +1,10 @@
 // SPDX-License-Identifier: MPL-2.0
 
+//! The physical page memory allocator.
+//!
+//! TODO: Decouple it with the frame allocator in [`crate::mm::frame::options`] by
+//! allocating pages rather untyped memory from this module.
+
 use alloc::vec::Vec;
 
 use align_ext::AlignExt;
@@ -7,12 +12,16 @@ use buddy_system_allocator::FrameAllocator;
 use log::info;
 use spin::Once;
 
-use super::{meta::FrameMeta, Frame, Page, Segment, VmFrameVec};
+use super::{meta::FrameMeta, Page};
-use crate::{boot::memory_region::MemoryRegionType, mm::PAGE_SIZE, sync::SpinLock};
+use crate::{
+    boot::memory_region::MemoryRegionType,
+    mm::{Frame, FrameVec, Segment, PAGE_SIZE},
+    sync::SpinLock,
+};
 
 pub(in crate::mm) static FRAME_ALLOCATOR: Once<SpinLock<FrameAllocator>> = Once::new();
 
-pub(crate) fn alloc(nframes: usize) -> Option<VmFrameVec> {
+pub(crate) fn alloc(nframes: usize) -> Option<FrameVec> {
     FRAME_ALLOCATOR
         .get()
         .unwrap()
@@ -27,7 +36,7 @@ pub(crate) fn alloc(nframes: usize) -> Option<VmFrameVec> {
                 };
                 vector.push(frame);
             }
-            VmFrameVec(vector)
+            FrameVec(vector)
         })
 }
 

framework/aster-frame/src/mm/page/meta.rs

@@ -82,7 +82,7 @@ pub enum PageUsage {
 }
 
 #[repr(C)]
-pub(super) struct MetaSlot {
+pub(in crate::mm) struct MetaSlot {
     /// The metadata of the page.
     ///
     /// The implementation may cast a `*const MetaSlot` to a `*const PageMeta`.
@@ -139,7 +139,7 @@ impl Sealed for FrameMeta {}
 #[repr(C)]
 pub struct SegmentHeadMeta {
     /// Length of the segment in bytes.
-    pub(super) seg_len: u64,
+    pub(in crate::mm) seg_len: u64,
 }
 
 impl Sealed for SegmentHeadMeta {}

framework/aster-frame/src/mm/page/mod.rs

@@ -1,33 +1,31 @@
 // SPDX-License-Identifier: MPL-2.0
 
-//! Managing pages or frames.
+//! Physical memory page management.
 //!
 //! A page is an aligned, contiguous range of bytes in physical memory. The sizes
 //! of base pages and huge pages are architecture-dependent. A page can be mapped
 //! to a virtual address using the page table.
 //!
-//! A frame is a special page that is _untyped_ memory. It is used to store data
+//! Pages can be accessed through page handles, namely, [`Page`]. A page handle
-//! irrelevant to the integrity of the kernel. All pages mapped to the virtual
+//! is a reference-counted handle to a page. When all handles to a page are dropped,
-//! address space of the users are backed by frames.
+//! the page is released and can be reused.
+//!
+//! Pages can have dedicated metadata, which is implemented in the [`meta`] module.
+//! The reference count and usage of a page are stored in the metadata as well, leaving
+//! the handle only a pointer to the metadata.
 
 pub(crate) mod allocator;
-mod frame;
 pub(in crate::mm) mod meta;
-mod segment;
-mod vm_frame_vec;
 
 use core::{
     marker::PhantomData,
     sync::atomic::{AtomicU32, AtomicUsize, Ordering},
 };
 
-pub use frame::Frame;
 use meta::{mapping, MetaSlot, PageMeta};
-pub use segment::Segment;
-pub use vm_frame_vec::{FrameVecIter, VmFrameVec};
 
 use super::PAGE_SIZE;
-use crate::mm::{paddr_to_vaddr, Paddr, PagingConsts, Vaddr};
+use crate::mm::{Paddr, PagingConsts, Vaddr};
 
 static MAX_PADDR: AtomicUsize = AtomicUsize::new(0);
 
@@ -35,8 +33,8 @@ static MAX_PADDR: AtomicUsize = AtomicUsize::new(0);
 /// whose metadata is represented by `M`.
 #[derive(Debug)]
 pub struct Page<M: PageMeta> {
-    ptr: *const MetaSlot,
+    pub(super) ptr: *const MetaSlot,
-    _marker: PhantomData<M>,
+    pub(super) _marker: PhantomData<M>,
 }
 
 unsafe impl<M: PageMeta> Send for Page<M> {}

framework/aster-frame/src/mm/page_table/boot_pt.rs

@@ -101,10 +101,10 @@ fn test_boot_pt() {
     use super::page_walk;
     use crate::{
         arch::mm::{PageTableEntry, PagingConsts},
-        mm::{CachePolicy, PageFlags, VmAllocOptions},
+        mm::{CachePolicy, FrameAllocOptions, PageFlags},
     };
 
-    let root_frame = VmAllocOptions::new(1).alloc_single().unwrap();
+    let root_frame = FrameAllocOptions::new(1).alloc_single().unwrap();
     let root_paddr = root_frame.start_paddr();
 
     let mut boot_pt = BootPageTable::<PageTableEntry, PagingConsts> {

framework/aster-frame/src/mm/page_table/cursor.rs

@@ -122,7 +122,7 @@ where
         // Create a guard array that only hold the root node lock.
         let guards = core::array::from_fn(|i| {
             if i == 0 {
-                Some(pt.root.copy_handle().lock())
+                Some(pt.root.clone_shallow().lock())
             } else {
                 None
             }
@@ -313,7 +313,7 @@ where
         // Drop the lock on the guard level.
         self.guards[C::NR_LEVELS - self.guard_level] = None;
         // Re-walk the page table to retreive the locks.
-        self.guards[0] = Some(self.pt.root.copy_handle().lock());
+        self.guards[0] = Some(self.pt.root.clone_shallow().lock());
         self.level = C::NR_LEVELS;
         let cur_pte = self.read_cur_pte();
         let cur_child_is_pt = cur_pte.is_present() && !cur_pte.is_last(self.level);

framework/aster-frame/src/mm/page_table/mod.rs

@@ -135,7 +135,7 @@ impl PageTable<KernelMode> {
     /// Then, one can use a user page table to call [`fork_copy_on_write`], creating
     /// other child page tables.
     pub(crate) fn create_user_page_table(&self) -> PageTable<UserMode> {
-        let root_frame = self.root.copy_handle().lock();
+        let root_frame = self.root.clone_shallow().lock();
         const NR_PTES_PER_NODE: usize = nr_subpage_per_huge::<PagingConsts>();
         let new_root_frame =
             unsafe { root_frame.make_copy(0..0, NR_PTES_PER_NODE / 2..NR_PTES_PER_NODE) };
@@ -157,7 +157,7 @@ impl PageTable<KernelMode> {
         debug_assert!(start < NR_PTES_PER_NODE);
         let end = root_index.end;
         debug_assert!(end <= NR_PTES_PER_NODE);
-        let mut root_frame = self.root.copy_handle().lock();
+        let mut root_frame = self.root.clone_shallow().lock();
         for i in start..end {
             if !root_frame.read_pte(i).is_present() {
                 let frame = PageTableNode::alloc(PagingConsts::NR_LEVELS - 1);
@@ -254,7 +254,7 @@ where
     /// This is only useful for IOMMU page tables. Think twice before using it in other cases.
     pub(crate) unsafe fn shallow_copy(&self) -> Self {
         PageTable {
-            root: self.root.copy_handle(),
+            root: self.root.clone_shallow(),
             _phantom: PhantomData,
         }
     }

framework/aster-frame/src/mm/page_table/node.rs

@@ -89,7 +89,7 @@ where
     }
 
     /// Create a copy of the handle.
-    pub(super) fn copy_handle(&self) -> Self {
+    pub(super) fn clone_shallow(&self) -> Self {
         self.inc_ref();
         Self {
             raw: self.raw,
@@ -321,7 +321,7 @@ where
         for i in deep {
             match self.child(i, /*meaningless*/ true) {
                 Child::PageTable(pt) => {
-                    let guard = pt.copy_handle().lock();
+                    let guard = pt.clone_shallow().lock();
                     let new_child = guard.make_copy(0..nr_subpage_per_huge::<C>(), 0..0);
                     new_frame.set_child_pt(i, new_child.into_raw(), /*meaningless*/ true);
                 }
@@ -339,7 +339,7 @@ where
             debug_assert_eq!(self.level(), C::NR_LEVELS);
             match self.child(i, /*meaningless*/ true) {
                 Child::PageTable(pt) => {
-                    new_frame.set_child_pt(i, pt.copy_handle(), /*meaningless*/ true);
+                    new_frame.set_child_pt(i, pt.clone_shallow(), /*meaningless*/ true);
                 }
                 Child::None => {}
                 Child::Frame(_) | Child::Untracked(_) => {

framework/aster-frame/src/mm/page_table/test.rs

@@ -6,7 +6,7 @@ use super::*;
 use crate::mm::{
     kspace::LINEAR_MAPPING_BASE_VADDR,
     page_prop::{CachePolicy, PageFlags},
-    VmAllocOptions,
+    FrameAllocOptions,
 };
 
 const PAGE_SIZE: usize = 4096;
@@ -17,7 +17,7 @@ fn test_range_check() {
     let good_va = 0..PAGE_SIZE;
     let bad_va = 0..PAGE_SIZE + 1;
     let bad_va2 = LINEAR_MAPPING_BASE_VADDR..LINEAR_MAPPING_BASE_VADDR + PAGE_SIZE;
-    let to = VmAllocOptions::new(1).alloc().unwrap();
+    let to = FrameAllocOptions::new(1).alloc().unwrap();
     assert!(pt.cursor_mut(&good_va).is_ok());
     assert!(pt.cursor_mut(&bad_va).is_err());
     assert!(pt.cursor_mut(&bad_va2).is_err());
@@ -31,7 +31,7 @@ fn test_tracked_map_unmap() {
     let pt = PageTable::<UserMode>::empty();
 
     let from = PAGE_SIZE..PAGE_SIZE * 2;
-    let frame = VmAllocOptions::new(1).alloc_single().unwrap();
+    let frame = FrameAllocOptions::new(1).alloc_single().unwrap();
     let start_paddr = frame.start_paddr();
     let prop = PageProperty::new(PageFlags::RW, CachePolicy::Writeback);
     unsafe { pt.cursor_mut(&from).unwrap().map(frame.clone(), prop) };
@@ -75,7 +75,7 @@ fn test_untracked_map_unmap() {
 fn test_user_copy_on_write() {
     let pt = PageTable::<UserMode>::empty();
     let from = PAGE_SIZE..PAGE_SIZE * 2;
-    let frame = VmAllocOptions::new(1).alloc_single().unwrap();
+    let frame = FrameAllocOptions::new(1).alloc_single().unwrap();
     let start_paddr = frame.start_paddr();
     let prop = PageProperty::new(PageFlags::RW, CachePolicy::Writeback);
     unsafe { pt.cursor_mut(&from).unwrap().map(frame.clone(), prop) };
@@ -131,7 +131,7 @@ fn test_base_protect_query() {
 
     let from_ppn = 1..1000;
     let from = PAGE_SIZE * from_ppn.start..PAGE_SIZE * from_ppn.end;
-    let to = VmAllocOptions::new(999).alloc().unwrap();
+    let to = FrameAllocOptions::new(999).alloc().unwrap();
     let prop = PageProperty::new(PageFlags::RW, CachePolicy::Writeback);
     unsafe {
         let mut cursor = pt.cursor_mut(&from).unwrap();

framework/aster-frame/src/mm/space.rs

@@ -6,7 +6,7 @@ use super::{
     is_page_aligned,
     kspace::KERNEL_PAGE_TABLE,
     page_table::{PageTable, PageTableMode, UserMode},
-    CachePolicy, PageFlags, PageProperty, PagingConstsTrait, PrivilegedPageFlags, VmFrameVec,
+    CachePolicy, FrameVec, PageFlags, PageProperty, PagingConstsTrait, PrivilegedPageFlags,
     PAGE_SIZE,
 };
 use crate::{
@@ -65,7 +65,7 @@ impl VmSpace {
     /// The ownership of the frames will be transferred to the `VmSpace`.
     ///
     /// For more information, see `VmMapOptions`.
-    pub fn map(&self, frames: VmFrameVec, options: &VmMapOptions) -> Result<Vaddr> {
+    pub fn map(&self, frames: FrameVec, options: &VmMapOptions) -> Result<Vaddr> {
         if options.addr.is_none() {
             return Err(Error::InvalidArgs);
         }

framework/aster-frame/src/task/task.rs

@@ -12,7 +12,7 @@ use super::{
 pub(crate) use crate::arch::task::{context_switch, TaskContext};
 use crate::{
     cpu::CpuSet,
-    mm::{kspace::KERNEL_PAGE_TABLE, PageFlags, Segment, VmAllocOptions, PAGE_SIZE},
+    mm::{kspace::KERNEL_PAGE_TABLE, FrameAllocOptions, PageFlags, Segment, PAGE_SIZE},
     prelude::*,
     sync::{SpinLock, SpinLockGuard},
     user::UserSpace,
@@ -42,7 +42,7 @@ pub struct KernelStack {
 impl KernelStack {
     pub fn new() -> Result<Self> {
         Ok(Self {
-            segment: VmAllocOptions::new(KERNEL_STACK_SIZE / PAGE_SIZE).alloc_contiguous()?,
+            segment: FrameAllocOptions::new(KERNEL_STACK_SIZE / PAGE_SIZE).alloc_contiguous()?,
             has_guard_page: false,
         })
     }
@@ -51,7 +51,7 @@ impl KernelStack {
     /// An additional page is allocated and be regarded as a guard page, which should not be accessed.  
     pub fn new_with_guard_page() -> Result<Self> {
         let stack_segment =
-            VmAllocOptions::new(KERNEL_STACK_SIZE / PAGE_SIZE + 1).alloc_contiguous()?;
+            FrameAllocOptions::new(KERNEL_STACK_SIZE / PAGE_SIZE + 1).alloc_contiguous()?;
         // FIXME: modifying the the linear mapping is bad.
         let page_table = KERNEL_PAGE_TABLE.get().unwrap();
         let guard_page_vaddr = {

kernel/aster-nix/src/fs/exfat/inode.rs

@@ -9,7 +9,7 @@ use aster_block::{
     id::{Bid, BlockId},
     BLOCK_SIZE,
 };
-use aster_frame::mm::{Frame, VmAllocOptions, VmIo};
+use aster_frame::mm::{Frame, FrameAllocOptions, VmIo};
 use aster_rights::Full;
 
 use super::{
@@ -1242,7 +1242,10 @@ impl Inode for ExfatInode {
             .discard_range(read_off..read_off + read_len);
 
         let mut buf_offset = 0;
-        let frame = VmAllocOptions::new(1).uninit(true).alloc_single().unwrap();
+        let frame = FrameAllocOptions::new(1)
+            .uninit(true)
+            .alloc_single()
+            .unwrap();
 
         let start_pos = inner.start_chain.walk_to_cluster_at_offset(read_off)?;
         let cluster_size = inner.fs().cluster_size();
@@ -1355,7 +1358,10 @@ impl Inode for ExfatInode {
         let mut cur_offset = start_pos.1;
         for _ in Bid::from_offset(offset)..Bid::from_offset(end_offset) {
             let frame = {
-                let frame = VmAllocOptions::new(1).uninit(true).alloc_single().unwrap();
+                let frame = FrameAllocOptions::new(1)
+                    .uninit(true)
+                    .alloc_single()
+                    .unwrap();
                 frame.write_bytes(0, &buf[buf_offset..buf_offset + BLOCK_SIZE])?;
                 frame
             };

kernel/aster-nix/src/fs/exfat/mod.rs

@@ -21,7 +21,7 @@ mod test {
         bio::{BioEnqueueError, BioStatus, BioType, SubmittedBio},
         BlockDevice,
     };
-    use aster_frame::mm::{Segment, VmAllocOptions, VmIo};
+    use aster_frame::mm::{FrameAllocOptions, Segment, VmIo};
     use rand::{rngs::SmallRng, RngCore, SeedableRng};
 
     use crate::{
@@ -102,7 +102,7 @@ mod test {
     /// Read exfat disk image
     fn new_vm_segment_from_image() -> Segment {
         let vm_segment = {
-            VmAllocOptions::new(EXFAT_IMAGE.len() / PAGE_SIZE)
+            FrameAllocOptions::new(EXFAT_IMAGE.len() / PAGE_SIZE)
                 .is_contiguous(true)
                 .uninit(true)
                 .alloc_contiguous()

kernel/aster-nix/src/fs/ext2/fs.rs

@@ -40,7 +40,7 @@ impl Ext2 {
             let npages = ((super_block.block_groups_count() as usize)
                 * core::mem::size_of::<RawGroupDescriptor>())
             .div_ceil(BLOCK_SIZE);
-            let segment = VmAllocOptions::new(npages)
+            let segment = FrameAllocOptions::new(npages)
                 .uninit(true)
                 .alloc_contiguous()?;
             match block_device.read_blocks_sync(super_block.group_descriptors_bid(0), &segment)? {

kernel/aster-nix/src/fs/ext2/indirect_block_cache.rs

@@ -132,7 +132,7 @@ impl IndirectBlock {
     /// Allocates an uninitialized block whose bytes are to be populated with
     /// data loaded from the disk.
     fn alloc_uninit() -> Result<Self> {
-        let frame = VmAllocOptions::new(1).uninit(true).alloc_single()?;
+        let frame = FrameAllocOptions::new(1).uninit(true).alloc_single()?;
         Ok(Self {
             frame,
             state: State::Uninit,
@@ -141,7 +141,7 @@ impl IndirectBlock {
 
     /// Allocates a new block with its bytes initialized to zero.
     pub fn alloc() -> Result<Self> {
-        let frame = VmAllocOptions::new(1).alloc_single()?;
+        let frame = FrameAllocOptions::new(1).alloc_single()?;
         Ok(Self {
             frame,
             state: State::Dirty,

kernel/aster-nix/src/fs/ext2/inode.rs

@@ -653,7 +653,10 @@ impl Inner {
 
         let mut buf_offset = 0;
         for bid in Bid::from_offset(offset)..Bid::from_offset(offset + read_len) {
-            let frame = VmAllocOptions::new(1).uninit(true).alloc_single().unwrap();
+            let frame = FrameAllocOptions::new(1)
+                .uninit(true)
+                .alloc_single()
+                .unwrap();
             self.inode_impl
                 .read_block_sync(bid.to_raw() as Ext2Bid, &frame)?;
             frame.read_bytes(0, &mut buf[buf_offset..buf_offset + BLOCK_SIZE])?;
@@ -691,7 +694,10 @@ impl Inner {
         let mut buf_offset = 0;
         for bid in Bid::from_offset(offset)..Bid::from_offset(end_offset) {
             let frame = {
-                let frame = VmAllocOptions::new(1).uninit(true).alloc_single().unwrap();
+                let frame = FrameAllocOptions::new(1)
+                    .uninit(true)
+                    .alloc_single()
+                    .unwrap();
                 frame.write_bytes(0, &buf[buf_offset..buf_offset + BLOCK_SIZE])?;
                 frame
             };
@@ -1572,7 +1578,7 @@ impl InodeImpl {
 
     pub fn sync_data_holes(&self) -> Result<()> {
         let inner = self.0.read();
-        let zero_frame = VmAllocOptions::new(1).alloc_single().unwrap();
+        let zero_frame = FrameAllocOptions::new(1).alloc_single().unwrap();
         for bid in 0..inner.desc.blocks_count() {
             let is_data_hole = inner.blocks_hole_desc.read().is_hole(bid as usize);
             if is_data_hole {

kernel/aster-nix/src/fs/ext2/prelude.rs

@@ -12,7 +12,7 @@ pub(super) use aster_block::{
     BlockDevice, BLOCK_SIZE,
 };
 pub(super) use aster_frame::{
-    mm::{Frame, Segment, VmAllocOptions, VmIo},
+    mm::{Frame, FrameAllocOptions, Segment, VmIo},
     sync::{RwMutex, RwMutexReadGuard, RwMutexWriteGuard},
 };
 pub(super) use aster_rights::Full;

kernel/aster-nix/src/fs/utils/page_cache.rs

@@ -3,7 +3,7 @@
 use core::ops::Range;
 
 use aster_block::bio::{BioStatus, BioWaiter};
-use aster_frame::mm::{Frame, VmAllocOptions};
+use aster_frame::mm::{Frame, FrameAllocOptions};
 use aster_rights::Full;
 use lru::LruCache;
 
@@ -208,7 +208,7 @@ struct Page {
 
 impl Page {
     pub fn alloc() -> Result<Self> {
-        let frame = VmAllocOptions::new(1).uninit(true).alloc_single()?;
+        let frame = FrameAllocOptions::new(1).uninit(true).alloc_single()?;
         Ok(Self {
             frame,
             state: PageState::Uninit,
@@ -216,7 +216,7 @@ impl Page {
     }
 
     pub fn alloc_zero() -> Result<Self> {
-        let frame = VmAllocOptions::new(1).alloc_single()?;
+        let frame = FrameAllocOptions::new(1).alloc_single()?;
         Ok(Self {
             frame,
             state: PageState::Dirty,

kernel/aster-nix/src/vm/vmar/vm_mapping.rs

@@ -2,7 +2,7 @@
 
 use core::ops::Range;
 
-use aster_frame::mm::{Frame, PageFlags, VmFrameVec, VmIo, VmMapOptions, VmSpace};
+use aster_frame::mm::{Frame, FrameVec, PageFlags, VmIo, VmMapOptions, VmSpace};
 
 use super::{interval::Interval, is_intersected, Vmar, Vmar_};
 use crate::{
@@ -484,7 +484,7 @@ impl VmMappingInner {
             vm_space.unmap(&(map_addr..(map_addr + PAGE_SIZE))).unwrap();
         }
 
-        vm_space.map(VmFrameVec::from_one_frame(frame), &vm_map_options)?;
+        vm_space.map(FrameVec::from_one_frame(frame), &vm_map_options)?;
         self.mapped_pages.insert(page_idx);
         Ok(())
     }

kernel/aster-nix/src/vm/vmo/mod.rs

@@ -7,7 +7,7 @@ use core::ops::Range;
 use align_ext::AlignExt;
 use aster_frame::{
     collections::xarray::{CursorMut, XArray, XMark},
-    mm::{Frame, VmAllocOptions, VmReader, VmWriter},
+    mm::{Frame, FrameAllocOptions, VmReader, VmWriter},
 };
 use aster_rights::Rights;
 
@@ -195,7 +195,7 @@ pub(super) struct Vmo_ {
 }
 
 fn clone_page(page: &Frame) -> Result<Frame> {
-    let new_page = VmAllocOptions::new(1).alloc_single()?;
+    let new_page = FrameAllocOptions::new(1).alloc_single()?;
     new_page.copy_from(page);
     Ok(new_page)
 }
@@ -221,7 +221,7 @@ impl Vmo_ {
             None => {
                 // Condition 1. The new anonymous page only need to be marked as `ExclusivePage`
                 // when current VMO is a cow VMO, otherwise this mark is meaningless.
-                (VmAllocOptions::new(1).alloc_single()?, is_cow_vmo)
+                (FrameAllocOptions::new(1).alloc_single()?, is_cow_vmo)
             }
             Some(pager) => {
                 let page = pager.commit_page(page_idx)?;

kernel/aster-nix/src/vm/vmo/options.rs

@@ -7,7 +7,7 @@ use core::{marker::PhantomData, ops::Range};
 use align_ext::AlignExt;
 use aster_frame::{
     collections::xarray::XArray,
-    mm::{Frame, VmAllocOptions},
+    mm::{Frame, FrameAllocOptions},
 };
 use aster_rights::{Dup, Rights, TRightSet, TRights, Write};
 use aster_rights_proc::require;
@@ -144,7 +144,7 @@ fn committed_pages_if_continuous(flags: VmoFlags, size: usize) -> Result<XArray<
     if flags.contains(VmoFlags::CONTIGUOUS) {
         // if the vmo is continuous, we need to allocate frames for the vmo
         let frames_num = size / PAGE_SIZE;
-        let frames = VmAllocOptions::new(frames_num)
+        let frames = FrameAllocOptions::new(frames_num)
             .is_contiguous(true)
             .alloc()?;
         let mut committed_pages = XArray::new();

kernel/comps/block/src/impl_block_device.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use aster_frame::mm::{Frame, Segment, VmAllocOptions, VmIo};
+use aster_frame::mm::{Frame, FrameAllocOptions, Segment, VmIo};
 
 use super::{
     bio::{Bio, BioEnqueueError, BioSegment, BioStatus, BioType, BioWaiter, SubmittedBio},
@@ -89,7 +89,7 @@ impl VmIo for dyn BlockDevice {
                 let last = Bid::from_offset(offset + buf.len() - 1).to_raw();
                 last - first + 1
             };
-            let segment = VmAllocOptions::new(num_blocks as usize)
+            let segment = FrameAllocOptions::new(num_blocks as usize)
                 .uninit(true)
                 .alloc_contiguous()?;
             let bio_segment = BioSegment::from_segment(segment, offset % BLOCK_SIZE, buf.len());
@@ -130,7 +130,7 @@ impl VmIo for dyn BlockDevice {
                 let last = Bid::from_offset(offset + buf.len() - 1).to_raw();
                 last - first + 1
             };
-            let segment = VmAllocOptions::new(num_blocks as usize)
+            let segment = FrameAllocOptions::new(num_blocks as usize)
                 .uninit(true)
                 .alloc_contiguous()?;
             segment.write_bytes(offset % BLOCK_SIZE, buf)?;
@@ -171,7 +171,7 @@ impl dyn BlockDevice {
                 let last = Bid::from_offset(offset + buf.len() - 1).to_raw();
                 last - first + 1
             };
-            let segment = VmAllocOptions::new(num_blocks as usize)
+            let segment = FrameAllocOptions::new(num_blocks as usize)
                 .uninit(true)
                 .alloc_contiguous()?;
             segment.write_bytes(offset % BLOCK_SIZE, buf)?;

kernel/comps/network/src/buffer.rs

@@ -4,7 +4,9 @@ use alloc::{collections::LinkedList, sync::Arc};
 
 use align_ext::AlignExt;
 use aster_frame::{
-    mm::{Daddr, DmaDirection, DmaStream, HasDaddr, VmAllocOptions, VmReader, VmWriter, PAGE_SIZE},
+    mm::{
+        Daddr, DmaDirection, DmaStream, FrameAllocOptions, HasDaddr, VmReader, VmWriter, PAGE_SIZE,
+    },
     sync::SpinLock,
 };
 use pod::Pod;
@@ -27,7 +29,7 @@ impl TxBuffer {
         } else {
             let segment = {
                 let nframes = (nbytes.align_up(PAGE_SIZE)) / PAGE_SIZE;
-                VmAllocOptions::new(nframes).alloc_contiguous().unwrap()
+                FrameAllocOptions::new(nframes).alloc_contiguous().unwrap()
             };
             DmaStream::map(segment, DmaDirection::ToDevice, false).unwrap()
         };

kernel/comps/network/src/dma_pool.rs

@@ -9,7 +9,9 @@ use alloc::{
 use core::ops::Range;
 
 use aster_frame::{
-    mm::{Daddr, DmaDirection, DmaStream, HasDaddr, VmAllocOptions, VmReader, VmWriter, PAGE_SIZE},
+    mm::{
+        Daddr, DmaDirection, DmaStream, FrameAllocOptions, HasDaddr, VmReader, VmWriter, PAGE_SIZE,
+    },
     sync::{RwLock, SpinLock},
 };
 use bitvec::{array::BitArray, prelude::Lsb0};
@@ -145,7 +147,7 @@ impl DmaPage {
         pool: Weak<DmaPool>,
     ) -> Result<Self, aster_frame::Error> {
         let dma_stream = {
-            let vm_segment = VmAllocOptions::new(1).alloc_contiguous()?;
+            let vm_segment = FrameAllocOptions::new(1).alloc_contiguous()?;
 
             DmaStream::map(vm_segment, direction, is_cache_coherent)
                 .map_err(|_| aster_frame::Error::AccessDenied)?

kernel/comps/virtio/src/device/block/device.rs

@@ -9,7 +9,7 @@ use aster_block::{
 };
 use aster_frame::{
     io_mem::IoMem,
-    mm::{DmaDirection, DmaStream, DmaStreamSlice, VmAllocOptions, VmIo},
+    mm::{DmaDirection, DmaStream, DmaStreamSlice, FrameAllocOptions, VmIo},
     sync::SpinLock,
     trap::TrapFrame,
 };
@@ -100,12 +100,12 @@ impl DeviceInner {
         let queue = VirtQueue::new(0, Self::QUEUE_SIZE, transport.as_mut())
             .expect("create virtqueue failed");
         let block_requests = {
-            let vm_segment = VmAllocOptions::new(1).alloc_contiguous().unwrap();
+            let vm_segment = FrameAllocOptions::new(1).alloc_contiguous().unwrap();
             DmaStream::map(vm_segment, DmaDirection::Bidirectional, false).unwrap()
         };
         assert!(Self::QUEUE_SIZE as usize * REQ_SIZE <= block_requests.nbytes());
         let block_responses = {
-            let vm_segment = VmAllocOptions::new(1).alloc_contiguous().unwrap();
+            let vm_segment = FrameAllocOptions::new(1).alloc_contiguous().unwrap();
             DmaStream::map(vm_segment, DmaDirection::Bidirectional, false).unwrap()
         };
         assert!(Self::QUEUE_SIZE as usize * RESP_SIZE <= block_responses.nbytes());
@@ -216,7 +216,7 @@ impl DeviceInner {
         };
         const MAX_ID_LENGTH: usize = 20;
         let device_id_stream = {
-            let segment = VmAllocOptions::new(1)
+            let segment = FrameAllocOptions::new(1)
                 .uninit(true)
                 .alloc_contiguous()
                 .unwrap();

kernel/comps/virtio/src/device/console/device.rs

@@ -6,7 +6,7 @@ use core::hint::spin_loop;
 use aster_console::{AnyConsoleDevice, ConsoleCallback};
 use aster_frame::{
     io_mem::IoMem,
-    mm::{DmaDirection, DmaStream, DmaStreamSlice, VmAllocOptions, VmReader},
+    mm::{DmaDirection, DmaStream, DmaStreamSlice, FrameAllocOptions, VmReader},
     sync::{RwLock, SpinLock},
     trap::TrapFrame,
 };
@@ -87,12 +87,12 @@ impl ConsoleDevice {
             SpinLock::new(VirtQueue::new(TRANSMIT0_QUEUE_INDEX, 2, transport.as_mut()).unwrap());
 
         let send_buffer = {
-            let vm_segment = VmAllocOptions::new(1).alloc_contiguous().unwrap();
+            let vm_segment = FrameAllocOptions::new(1).alloc_contiguous().unwrap();
             DmaStream::map(vm_segment, DmaDirection::ToDevice, false).unwrap()
         };
 
         let receive_buffer = {
-            let vm_segment = VmAllocOptions::new(1).alloc_contiguous().unwrap();
+            let vm_segment = FrameAllocOptions::new(1).alloc_contiguous().unwrap();
             DmaStream::map(vm_segment, DmaDirection::FromDevice, false).unwrap()
         };
 

kernel/comps/virtio/src/device/input/device.rs

@@ -10,7 +10,7 @@ use core::{fmt::Debug, iter, mem};
 
 use aster_frame::{
     io_mem::IoMem,
-    mm::{DmaDirection, DmaStream, HasDaddr, VmAllocOptions, VmIo, PAGE_SIZE},
+    mm::{DmaDirection, DmaStream, FrameAllocOptions, HasDaddr, VmIo, PAGE_SIZE},
     offset_of,
     sync::{RwLock, SpinLock},
     trap::TrapFrame,
@@ -239,7 +239,7 @@ impl EventTable {
     fn new(num_events: usize) -> Self {
         assert!(num_events * mem::size_of::<VirtioInputEvent>() <= PAGE_SIZE);
 
-        let vm_segment = VmAllocOptions::new(1).alloc_contiguous().unwrap();
+        let vm_segment = FrameAllocOptions::new(1).alloc_contiguous().unwrap();
 
         let default_event = VirtioInputEvent::default();
         let iter = iter::repeat(&default_event).take(EVENT_SIZE);

kernel/comps/virtio/src/queue.rs

@@ -10,7 +10,7 @@ use core::{
 
 use aster_frame::{
     io_mem::IoMem,
-    mm::{DmaCoherent, VmAllocOptions},
+    mm::{DmaCoherent, FrameAllocOptions},
     offset_of,
 };
 use aster_rights::{Dup, TRightSet, TRights, Write};
@@ -82,7 +82,7 @@ impl VirtQueue {
             let desc_size = size_of::<Descriptor>() * size as usize;
 
             let (seg1, seg2) = {
-                let continue_segment = VmAllocOptions::new(2).alloc_contiguous().unwrap();
+                let continue_segment = FrameAllocOptions::new(2).alloc_contiguous().unwrap();
                 let seg1 = continue_segment.range(0..1);
                 let seg2 = continue_segment.range(1..2);
                 (seg1, seg2)
@@ -101,17 +101,17 @@ impl VirtQueue {
             }
             (
                 SafePtr::new(
-                    DmaCoherent::map(VmAllocOptions::new(1).alloc_contiguous().unwrap(), true)
+                    DmaCoherent::map(FrameAllocOptions::new(1).alloc_contiguous().unwrap(), true)
                         .unwrap(),
                     0,
                 ),
                 SafePtr::new(
-                    DmaCoherent::map(VmAllocOptions::new(1).alloc_contiguous().unwrap(), true)
+                    DmaCoherent::map(FrameAllocOptions::new(1).alloc_contiguous().unwrap(), true)
                         .unwrap(),
                     0,
                 ),
                 SafePtr::new(
-                    DmaCoherent::map(VmAllocOptions::new(1).alloc_contiguous().unwrap(), true)
+                    DmaCoherent::map(FrameAllocOptions::new(1).alloc_contiguous().unwrap(), true)
                         .unwrap(),
                     0,
                 ),