Samuka007/asterinas
1
0
Fork 0
mirror of https://github.com/asterinas/asterinas.git synced 2025-06-22 00:43:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename PageTableQueryResult to PageTableItem

Browse Source
This commit is contained in:
Zhang Junyang
2024-08-12 06:42:04 +00:00
committed by Tate, Hongliang Tian
parent 6df0a3073c
commit e597a10088
5 changed files with 44 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
kernel/aster-nix/src/vm/vmar/vm_mapping.rs
View File

@ -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)?;
}
}

14
ostd/src/mm/page_table/cursor.rs
View File

@ -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()
}

2
ostd/src/mm/page_table/mod.rs
View File

@ -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;

38
ostd/src/mm/page_table/test.rs
View File

@ -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);

28
ostd/src/mm/vm_space.rs
View File

@ -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`")
}
}
}
}