diff --git a/kernel/aster-nix/src/vm/vmar/vm_mapping.rs b/kernel/aster-nix/src/vm/vmar/vm_mapping.rs
index 46e83498c..04799ddec 100644
--- a/kernel/aster-nix/src/vm/vmar/vm_mapping.rs
+++ b/kernel/aster-nix/src/vm/vmar/vm_mapping.rs
@@ -5,9 +5,7 @@
 
 use core::ops::Range;
 
-use ostd::mm::{
-    vm_space::VmQueryResult, CachePolicy, Frame, PageFlags, PageProperty, VmIo, VmSpace,
-};
+use ostd::mm::{vm_space::VmItem, CachePolicy, Frame, PageFlags, PageProperty, VmIo, VmSpace};
 
 use super::{interval::Interval, is_intersected, Vmar, Vmar_};
 use crate::{
@@ -221,12 +219,12 @@ impl VmMapping {
                 drop(cursor);
 
                 match map_info {
-                    VmQueryResult::Mapped { va, prop, .. } => {
+                    VmItem::Mapped { va, prop, .. } => {
                         if !prop.flags.contains(PageFlags::W) {
                             self.handle_page_fault(va, false, true)?;
                         }
                     }
-                    VmQueryResult::NotMapped { va, .. } => {
+                    VmItem::NotMapped { va, .. } => {
                         self.handle_page_fault(va, true, true)?;
                     }
                 }
diff --git a/ostd/src/mm/page_table/cursor.rs b/ostd/src/mm/page_table/cursor.rs
index f19f7f928..ec1c03315 100644
--- a/ostd/src/mm/page_table/cursor.rs
+++ b/ostd/src/mm/page_table/cursor.rs
@@ -76,7 +76,7 @@ use super::{
 use crate::mm::{page::DynPage, Paddr, PageProperty, Vaddr};
 
 #[derive(Clone, Debug)]
-pub enum PageTableQueryResult {
+pub enum PageTableItem {
     NotMapped {
         va: Vaddr,
         len: usize,
@@ -195,7 +195,7 @@ where
     }
 
     /// Gets the information of the current slot.
-    pub fn query(&mut self) -> Result<PageTableQueryResult, PageTableError> {
+    pub fn query(&mut self) -> Result<PageTableItem, PageTableError> {
         if self.va >= self.barrier_va.end {
             return Err(PageTableError::InvalidVaddr(self.va));
         }
@@ -206,7 +206,7 @@ where
 
             let pte = self.read_cur_pte();
             if !pte.is_present() {
-                return Ok(PageTableQueryResult::NotMapped {
+                return Ok(PageTableItem::NotMapped {
                     va,
                     len: page_size::<C>(level),
                 });
@@ -218,14 +218,14 @@ where
 
             match self.cur_child() {
                 Child::Page(page) => {
-                    return Ok(PageTableQueryResult::Mapped {
+                    return Ok(PageTableItem::Mapped {
                         va,
                         page,
                         prop: pte.prop(),
                     });
                 }
                 Child::Untracked(pa) => {
-                    return Ok(PageTableQueryResult::MappedUntracked {
+                    return Ok(PageTableItem::MappedUntracked {
                         va,
                         pa,
                         len: page_size::<C>(level),
@@ -355,7 +355,7 @@ impl<'a, M: PageTableMode, E: PageTableEntryTrait, C: PagingConstsTrait> Iterato
 where
     [(); C::NR_LEVELS as usize]:,
 {
-    type Item = PageTableQueryResult;
+    type Item = PageTableItem;
 
     fn next(&mut self) -> Option<Self::Item> {
         let result = self.query();
@@ -415,7 +415,7 @@ where
     }
 
     /// Gets the information of the current slot.
-    pub fn query(&mut self) -> Result<PageTableQueryResult, PageTableError> {
+    pub fn query(&mut self) -> Result<PageTableItem, PageTableError> {
         self.0.query()
     }
 
diff --git a/ostd/src/mm/page_table/mod.rs b/ostd/src/mm/page_table/mod.rs
index 118f76de9..948ccefb8 100644
--- a/ostd/src/mm/page_table/mod.rs
+++ b/ostd/src/mm/page_table/mod.rs
@@ -15,7 +15,7 @@ use crate::{
 mod node;
 use node::*;
 pub mod cursor;
-pub use cursor::{Cursor, CursorMut, PageTableQueryResult};
+pub use cursor::{Cursor, CursorMut, PageTableItem};
 #[cfg(ktest)]
 mod test;
 
diff --git a/ostd/src/mm/page_table/test.rs b/ostd/src/mm/page_table/test.rs
index 3a71e0f69..db24aa6a8 100644
--- a/ostd/src/mm/page_table/test.rs
+++ b/ostd/src/mm/page_table/test.rs
@@ -114,8 +114,6 @@ fn test_user_copy_on_write() {
     assert!(child_pt.query(from.start + 10).is_none());
 }
 
-type Qr = PageTableQueryResult;
-
 #[derive(Clone, Debug, Default)]
 struct BasePagingConsts {}
 
@@ -141,9 +139,9 @@ fn test_base_protect_query() {
             cursor.map(page.clone().into(), prop);
         }
     }
-    for (qr, i) in pt.cursor(&from).unwrap().zip(from_ppn) {
-        let Qr::Mapped { va, page, prop } = qr else {
-            panic!("Expected Mapped, got {:#x?}", qr);
+    for (item, i) in pt.cursor(&from).unwrap().zip(from_ppn) {
+        let PageTableItem::Mapped { va, page, prop } = item else {
+            panic!("Expected Mapped, got {:#x?}", item);
         };
         assert_eq!(prop.flags, PageFlags::RW);
         assert_eq!(prop.cache, CachePolicy::Writeback);
@@ -151,9 +149,9 @@ fn test_base_protect_query() {
     }
     let prot = PAGE_SIZE * 18..PAGE_SIZE * 20;
     unsafe { pt.protect(&prot, |p| p.flags -= PageFlags::W).unwrap() };
-    for (qr, i) in pt.cursor(&prot).unwrap().zip(18..20) {
-        let Qr::Mapped { va, page, prop } = qr else {
-            panic!("Expected Mapped, got {:#x?}", qr);
+    for (item, i) in pt.cursor(&prot).unwrap().zip(18..20) {
+        let PageTableItem::Mapped { va, page, prop } = item else {
+            panic!("Expected Mapped, got {:#x?}", item);
         };
         assert_eq!(prop.flags, PageFlags::R);
         assert_eq!(va..va + page.size(), i * PAGE_SIZE..(i + 1) * PAGE_SIZE);
@@ -190,9 +188,9 @@ fn test_untracked_large_protect_query() {
     let mapped_pa_of_va = |va: Vaddr| va - (from.start - to.start);
     let prop = PageProperty::new(PageFlags::RW, CachePolicy::Writeback);
     unsafe { pt.map(&from, &to, prop).unwrap() };
-    for (qr, i) in pt.cursor(&from).unwrap().zip(0..512 + 2 + 2) {
-        let Qr::MappedUntracked { va, pa, len, prop } = qr else {
-            panic!("Expected MappedUntracked, got {:#x?}", qr);
+    for (item, i) in pt.cursor(&from).unwrap().zip(0..512 + 2 + 2) {
+        let PageTableItem::MappedUntracked { va, pa, len, prop } = item else {
+            panic!("Expected MappedUntracked, got {:#x?}", item);
         };
         assert_eq!(pa, mapped_pa_of_va(va));
         assert_eq!(prop.flags, PageFlags::RW);
@@ -214,35 +212,35 @@ fn test_untracked_large_protect_query() {
     let ppn = from_ppn.start + 18..from_ppn.start + 20;
     let va = UNTRACKED_OFFSET + PAGE_SIZE * ppn.start..UNTRACKED_OFFSET + PAGE_SIZE * ppn.end;
     unsafe { pt.protect(&va, |p| p.flags -= PageFlags::W).unwrap() };
-    for (qr, i) in pt
+    for (item, i) in pt
         .cursor(&(va.start - PAGE_SIZE..va.start))
         .unwrap()
         .zip(ppn.start - 1..ppn.start)
     {
-        let Qr::MappedUntracked { va, pa, len, prop } = qr else {
-            panic!("Expected MappedUntracked, got {:#x?}", qr);
+        let PageTableItem::MappedUntracked { va, pa, len, prop } = item else {
+            panic!("Expected MappedUntracked, got {:#x?}", item);
         };
         assert_eq!(pa, mapped_pa_of_va(va));
         assert_eq!(prop.flags, PageFlags::RW);
         let va = va - UNTRACKED_OFFSET;
         assert_eq!(va..va + len, i * PAGE_SIZE..(i + 1) * PAGE_SIZE);
     }
-    for (qr, i) in pt.cursor(&va).unwrap().zip(ppn.clone()) {
-        let Qr::MappedUntracked { va, pa, len, prop } = qr else {
-            panic!("Expected MappedUntracked, got {:#x?}", qr);
+    for (item, i) in pt.cursor(&va).unwrap().zip(ppn.clone()) {
+        let PageTableItem::MappedUntracked { va, pa, len, prop } = item else {
+            panic!("Expected MappedUntracked, got {:#x?}", item);
         };
         assert_eq!(pa, mapped_pa_of_va(va));
         assert_eq!(prop.flags, PageFlags::R);
         let va = va - UNTRACKED_OFFSET;
         assert_eq!(va..va + len, i * PAGE_SIZE..(i + 1) * PAGE_SIZE);
     }
-    for (qr, i) in pt
+    for (item, i) in pt
         .cursor(&(va.end..va.end + PAGE_SIZE))
         .unwrap()
         .zip(ppn.end..ppn.end + 1)
     {
-        let Qr::MappedUntracked { va, pa, len, prop } = qr else {
-            panic!("Expected MappedUntracked, got {:#x?}", qr);
+        let PageTableItem::MappedUntracked { va, pa, len, prop } = item else {
+            panic!("Expected MappedUntracked, got {:#x?}", item);
         };
         assert_eq!(pa, mapped_pa_of_va(va));
         assert_eq!(prop.flags, PageFlags::RW);
diff --git a/ostd/src/mm/vm_space.rs b/ostd/src/mm/vm_space.rs
index f9f556d65..7123bb40d 100644
--- a/ostd/src/mm/vm_space.rs
+++ b/ostd/src/mm/vm_space.rs
@@ -26,7 +26,7 @@ use crate::{
     },
     cpu::CpuExceptionInfo,
     mm::{
-        page_table::{self, PageTableQueryResult as PtQr},
+        page_table::{self, PageTableItem},
         Frame, MAX_USERSPACE_VADDR,
     },
     prelude::*,
@@ -211,7 +211,7 @@ impl Default for VmSpace {
 pub struct Cursor<'a>(page_table::Cursor<'a, UserMode, PageTableEntry, PagingConsts>);
 
 impl Iterator for Cursor<'_> {
-    type Item = VmQueryResult;
+    type Item = VmItem;
 
     fn next(&mut self) -> Option<Self::Item> {
         let result = self.query();
@@ -226,8 +226,8 @@ impl Cursor<'_> {
     /// Query about the current slot.
     ///
     /// This function won't bring the cursor to the next slot.
-    pub fn query(&mut self) -> Result<VmQueryResult> {
-        Ok(self.0.query().map(|ptqr| ptqr.try_into().unwrap())?)
+    pub fn query(&mut self) -> Result<VmItem> {
+        Ok(self.0.query().map(|item| item.try_into().unwrap())?)
     }
 
     /// Jump to the virtual address.
@@ -253,8 +253,8 @@ impl CursorMut<'_> {
     /// This is the same as [`Cursor::query`].
     ///
     /// This function won't bring the cursor to the next slot.
-    pub fn query(&mut self) -> Result<VmQueryResult> {
-        Ok(self.0.query().map(|ptqr| ptqr.try_into().unwrap())?)
+    pub fn query(&mut self) -> Result<VmItem> {
+        Ok(self.0.query().map(|item| item.try_into().unwrap())?)
     }
 
     /// Jump to the virtual address.
@@ -339,7 +339,7 @@ impl CursorMut<'_> {
 
 /// The result of a query over the VM space.
 #[derive(Debug)]
-pub enum VmQueryResult {
+pub enum VmItem {
     /// The current slot is not mapped.
     NotMapped {
         /// The virtual address of the slot.
@@ -358,20 +358,22 @@ pub enum VmQueryResult {
     },
 }
 
-impl TryFrom<PtQr> for VmQueryResult {
+impl TryFrom<PageTableItem> for VmItem {
     type Error = &'static str;
 
-    fn try_from(ptqr: PtQr) -> core::result::Result<Self, Self::Error> {
-        match ptqr {
-            PtQr::NotMapped { va, len } => Ok(VmQueryResult::NotMapped { va, len }),
-            PtQr::Mapped { va, page, prop } => Ok(VmQueryResult::Mapped {
+    fn try_from(item: PageTableItem) -> core::result::Result<Self, Self::Error> {
+        match item {
+            PageTableItem::NotMapped { va, len } => Ok(VmItem::NotMapped { va, len }),
+            PageTableItem::Mapped { va, page, prop } => Ok(VmItem::Mapped {
                 va,
                 frame: page
                     .try_into()
                     .map_err(|_| "found typed memory mapped into `VmSpace`")?,
                 prop,
             }),
-            PtQr::MappedUntracked { .. } => Err("found untracked memory mapped into `VmSpace`"),
+            PageTableItem::MappedUntracked { .. } => {
+                Err("found untracked memory mapped into `VmSpace`")
+            }
         }
     }
 }