qiurui
/
asterinas
mirror of https://github.com/asterinas/asterinas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Unify some panic message and add `should_panic =` tests

This commit is contained in:
Zhang Junyang 2026-01-23 16:17:39 +08:00
parent 272f385cf6
commit 02a2cad397
No known key found for this signature in database
GPG Key ID: 33B8FA6260ABC047
3 changed files with 63 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -233,7 +233,7 @@ impl<'rcu, C: PageTableConfig> Cursor<'rcu, C> {
let split_child = cur_entry let split_child = cur_entry
.split_if_mapped_huge(rcu_guard) .split_if_mapped_huge(rcu_guard)
.expect("The entry must be a huge page"); .expect("the entry must be a huge page");
self.push_level(split_child); self.push_level(split_child);
continue; continue;
} }
@ -296,7 +296,7 @@ impl<'rcu, C: PageTableConfig> Cursor<'rcu, C> {
fn pop_level(&mut self) { fn pop_level(&mut self) {
let taken = self.path[self.level as usize - 1] let taken = self.path[self.level as usize - 1]
.take() .take()
.expect("Popping a level without a lock"); .expect("popping a level without a lock");
let _ = ManuallyDrop::new(taken); let _ = ManuallyDrop::new(taken);
debug_assert!(self.level < self.guard_level); debug_assert!(self.level < self.guard_level);
@ -413,7 +413,11 @@ impl<'rcu, C: PageTableConfig> CursorMut<'rcu, C> {
let (_, level, _) = C::item_raw_info(&item); let (_, level, _) = C::item_raw_info(&item);
assert!(level <= C::HIGHEST_TRANSLATION_LEVEL); assert!(level <= C::HIGHEST_TRANSLATION_LEVEL);
let size = page_size::<C>(level); let size = page_size::<C>(level);
assert_eq!(self.0.va % size, 0); assert_eq!(
self.0.va % size,
0,
"cursor virtual address not aligned for mapping"
);
let end = self.0.va + size; let end = self.0.va + size;
assert!(end <= self.0.barrier_va.end); assert!(end <= self.0.barrier_va.end);
@ -445,7 +449,7 @@ impl<'rcu, C: PageTableConfig> CursorMut<'rcu, C> {
} }
if !matches!(self.0.cur_entry().to_ref(), PteStateRef::Absent) { if !matches!(self.0.cur_entry().to_ref(), PteStateRef::Absent) {
panic!("Mapping over an already mapped page at {:#x}", self.0.va); panic!("mapping over an already mapped page");
} }
let _ = self.replace_cur_entry(PteState::Mapped(RcuDrop::new(item))); let _ = self.replace_cur_entry(PteState::Mapped(RcuDrop::new(item)));
@ -550,7 +554,7 @@ impl<'rcu, C: PageTableConfig> CursorMut<'rcu, C> {
if !C::TOP_LEVEL_CAN_UNMAP && level == C::NR_LEVELS { if !C::TOP_LEVEL_CAN_UNMAP && level == C::NR_LEVELS {
let _ = ManuallyDrop::new(pt); // leak it to make shared PTs stay `'static`. let _ = ManuallyDrop::new(pt); // leak it to make shared PTs stay `'static`.
panic!("Unmapping shared kernel page table nodes"); panic!("unmapping shared kernel page table nodes");
} }
// SAFETY: We must have locked this node. // SAFETY: We must have locked this node.

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

@ -31,7 +31,7 @@ mod test_utils {
unsafe { unsafe {
page_table page_table
.cursor_mut(&preempt_guard, &virt_range) .cursor_mut(&preempt_guard, &virt_range)
.unwrap() .expect("failed to create the cursor")
.map(VmItem::new_tracked(frame.into(), page_property)) .map(VmItem::new_tracked(frame.into(), page_property))
}; };
@ -218,12 +218,12 @@ mod create_page_table {
let user_entry = user_root.entry(i); let user_entry = user_root.entry(i);
let PteStateRef::PageTable(kernel_node) = kernel_entry.to_ref() else { let PteStateRef::PageTable(kernel_node) = kernel_entry.to_ref() else {
panic!("Expected a node reference at {} of kernel root PT", i); panic!("expected a node reference at {} of kernel root PT", i);
}; };
assert_eq!(kernel_node.level(), PagingConsts::NR_LEVELS - 1); assert_eq!(kernel_node.level(), PagingConsts::NR_LEVELS - 1);
let PteStateRef::PageTable(user_node) = user_entry.to_ref() else { let PteStateRef::PageTable(user_node) = user_entry.to_ref() else {
panic!("Expected a node reference at {} of user root PT", i); panic!("expected a node reference at {} of user root PT", i);
}; };
assert_eq!(user_node.level(), PagingConsts::NR_LEVELS - 1); assert_eq!(user_node.level(), PagingConsts::NR_LEVELS - 1);
@ -320,7 +320,7 @@ mod range_checks {
} }
#[ktest] #[ktest]
#[should_panic] #[should_panic = "failed to create the cursor"]
fn overflow_boundary_mapping() { fn overflow_boundary_mapping() {
let virt_range = let virt_range =
(MAX_USERSPACE_VADDR - (PAGE_SIZE / 2))..(MAX_USERSPACE_VADDR + (PAGE_SIZE / 2)); (MAX_USERSPACE_VADDR - (PAGE_SIZE / 2))..(MAX_USERSPACE_VADDR + (PAGE_SIZE / 2));
@ -437,7 +437,7 @@ mod overlapping_mappings {
use super::{test_utils::*, *}; use super::{test_utils::*, *};
#[ktest] #[ktest]
#[should_panic] #[should_panic = "mapping over an already mapped page"]
fn overlapping_mappings() { fn overlapping_mappings() {
let page_table = PageTable::<TestPtConfig>::empty(); let page_table = PageTable::<TestPtConfig>::empty();
let vrange1 = PAGE_SIZE..(PAGE_SIZE * 2); let vrange1 = PAGE_SIZE..(PAGE_SIZE * 2);
@ -464,7 +464,7 @@ mod overlapping_mappings {
} }
#[ktest] #[ktest]
#[should_panic] #[should_panic = "cursor virtual address not aligned for mapping"]
fn unaligned_map() { fn unaligned_map() {
let page_table = PageTable::<TestPtConfig>::empty(); let page_table = PageTable::<TestPtConfig>::empty();
let virt_range = (PAGE_SIZE + 512)..(PAGE_SIZE * 2 + 512); let virt_range = (PAGE_SIZE + 512)..(PAGE_SIZE * 2 + 512);
@ -534,7 +534,7 @@ mod navigation {
cursor.jump(FIRST_MAP_ADDR).unwrap(); cursor.jump(FIRST_MAP_ADDR).unwrap();
assert_eq!(cursor.virt_addr(), FIRST_MAP_ADDR); assert_eq!(cursor.virt_addr(), FIRST_MAP_ADDR);
let (queried_va, Some(queried_item)) = cursor.query().unwrap() else { let (queried_va, Some(queried_item)) = cursor.query().unwrap() else {
panic!("Expected a mapped item at the first address"); panic!("expected a mapped item at the first address");
}; };
assert_eq!(queried_va, FIRST_MAP_ADDR..FIRST_MAP_ADDR + PAGE_SIZE); assert_eq!(queried_va, FIRST_MAP_ADDR..FIRST_MAP_ADDR + PAGE_SIZE);
let TestPtItemRef((pa, _, prop), _) = queried_item; let TestPtItemRef((pa, _, prop), _) = queried_item;
@ -615,7 +615,7 @@ mod navigation {
assert_eq!(cursor.virt_addr(), 0); assert_eq!(cursor.virt_addr(), 0);
let Some(va) = cursor.find_next(FIRST_MAP_ADDR + PAGE_SIZE) else { let Some(va) = cursor.find_next(FIRST_MAP_ADDR + PAGE_SIZE) else {
panic!("Expected to find the next mapping"); panic!("expected to find the next mapping");
}; };
assert_eq!(va, FIRST_MAP_ADDR); assert_eq!(va, FIRST_MAP_ADDR);
assert_eq!(cursor.virt_addr(), FIRST_MAP_ADDR); assert_eq!(cursor.virt_addr(), FIRST_MAP_ADDR);
@ -623,7 +623,7 @@ mod navigation {
cursor.jump(FIRST_MAP_ADDR + PAGE_SIZE).unwrap(); cursor.jump(FIRST_MAP_ADDR + PAGE_SIZE).unwrap();
let Some(va) = cursor.find_next(SECOND_MAP_ADDR - FIRST_MAP_ADDR) else { let Some(va) = cursor.find_next(SECOND_MAP_ADDR - FIRST_MAP_ADDR) else {
panic!("Expected to find the next mapping"); panic!("expected to find the next mapping");
}; };
assert_eq!(va, SECOND_MAP_ADDR); assert_eq!(va, SECOND_MAP_ADDR);
assert_eq!(cursor.virt_addr(), SECOND_MAP_ADDR); assert_eq!(cursor.virt_addr(), SECOND_MAP_ADDR);
@ -654,7 +654,7 @@ mod unmap {
let Some(PageTableFrag::Mapped { va, item }) = let Some(PageTableFrag::Mapped { va, item }) =
(unsafe { cursor.take_next(virt_range.len()) }) (unsafe { cursor.take_next(virt_range.len()) })
else { else {
panic!("Expected to take a mapped item"); panic!("expected to take a mapped item");
}; };
assert_eq!(va, virt_range.start); assert_eq!(va, virt_range.start);
@ -688,7 +688,7 @@ mod unmap {
num_frames, num_frames,
}) = (unsafe { cursor.take_next(large_range.len()) }) }) = (unsafe { cursor.take_next(large_range.len()) })
else { else {
panic!("Expected to take a stray page table"); panic!("expected to take a stray page table");
}; };
// Should take a level-2 page table with 512 entries. // Should take a level-2 page table with 512 entries.
@ -741,7 +741,7 @@ mod mapping {
let Some(PageTableFrag::Mapped { va: frag_va, item }) = let Some(PageTableFrag::Mapped { va: frag_va, item }) =
(unsafe { cursor.take_next(unmap_len) }) (unsafe { cursor.take_next(unmap_len) })
else { else {
panic!("Expected to unmap a page, but got `None`"); panic!("expected to unmap a page, but got `None`");
}; };
// Calculates the expected PA for the unmapped item. // Calculates the expected PA for the unmapped item.
@ -799,7 +799,7 @@ mod mapping {
let (va, item) = cursor.query().unwrap(); let (va, item) = cursor.query().unwrap();
let Some(TestPtItemRef((pa, level, prop), _)) = item else { let Some(TestPtItemRef((pa, level, prop), _)) = item else {
panic!("Expected mapped untracked physical address, got `None`"); panic!("expected mapped untracked physical address, got `None`");
}; };
assert_eq!(pa, mapped_pa_of_va(va.start)); assert_eq!(pa, mapped_pa_of_va(va.start));
@ -841,7 +841,7 @@ mod mapping {
let va_low = protect_va_range.start - PAGE_SIZE; let va_low = protect_va_range.start - PAGE_SIZE;
let (va_low_pa, prop_low) = pt let (va_low_pa, prop_low) = pt
.page_walk(va_low) .page_walk(va_low)
.expect("Page should be mapped before protection"); .expect("page should be mapped before protection");
assert_eq!(va_low_pa, mapped_pa_of_va(va_low)); assert_eq!(va_low_pa, mapped_pa_of_va(va_low));
assert_eq!( assert_eq!(
prop_low, prop_low,
@ -856,7 +856,7 @@ mod mapping {
let (va, item) = cursor.query().unwrap(); let (va, item) = cursor.query().unwrap();
let Some(TestPtItemRef((pa, level, prop), _)) = item else { let Some(TestPtItemRef((pa, level, prop), _)) = item else {
panic!("Expected mapped untracked physical address, got `None`"); panic!("expected mapped untracked physical address, got `None`");
}; };
assert_eq!(pa, mapped_pa_of_va(va.start)); assert_eq!(pa, mapped_pa_of_va(va.start));
@ -875,7 +875,7 @@ mod mapping {
let va_high = protect_va_range.end; let va_high = protect_va_range.end;
let (va_high_pa, prop_high) = pt let (va_high_pa, prop_high) = pt
.page_walk(va_high) .page_walk(va_high)
.expect("Page should be mapped after protection"); .expect("page should be mapped after protection");
assert_eq!(va_high_pa, mapped_pa_of_va(va_high)); assert_eq!(va_high_pa, mapped_pa_of_va(va_high));
assert_eq!( assert_eq!(
prop_high, prop_high,
@ -910,7 +910,7 @@ mod protection_and_query {
let va_to_check = PAGE_SIZE * i; let va_to_check = PAGE_SIZE * i;
let (_, prop) = page_table let (_, prop) = page_table
.page_walk(va_to_check) .page_walk(va_to_check)
.expect("Mapping should exist"); .expect("mapping should exist");
assert_eq!(prop.flags, PageFlags::RW); assert_eq!(prop.flags, PageFlags::RW);
assert_eq!(prop.cache, CachePolicy::Writeback); assert_eq!(prop.cache, CachePolicy::Writeback);
} }
@ -926,7 +926,7 @@ mod protection_and_query {
let va_to_check = PAGE_SIZE * i; let va_to_check = PAGE_SIZE * i;
let (_, prop) = page_table let (_, prop) = page_table
.page_walk(va_to_check) .page_walk(va_to_check)
.expect("Mapping should exist"); .expect("mapping should exist");
assert_eq!(prop.flags, PageFlags::R); assert_eq!(prop.flags, PageFlags::R);
assert_eq!(prop.cache, CachePolicy::Writeback); assert_eq!(prop.cache, CachePolicy::Writeback);
} }
@ -1011,7 +1011,7 @@ mod boot_pt {
} }
#[ktest] #[ktest]
#[should_panic] #[should_panic = "mapping an already mapped huge page in the boot page table"]
fn map_base_page_already_mapped() { fn map_base_page_already_mapped() {
let root_frame = FrameAllocOptions::new().alloc_frame().unwrap(); let root_frame = FrameAllocOptions::new().alloc_frame().unwrap();
let root_paddr = root_frame.paddr(); let root_paddr = root_frame.paddr();
@ -1029,7 +1029,7 @@ mod boot_pt {
} }
#[ktest] #[ktest]
#[should_panic] #[should_panic = "protecting an unmapped page in the boot page table"]
fn protect_base_page_unmapped() { fn protect_base_page_unmapped() {
let root_frame = FrameAllocOptions::new().alloc_frame().unwrap(); let root_frame = FrameAllocOptions::new().alloc_frame().unwrap();
let root_paddr = root_frame.paddr(); let root_paddr = root_frame.paddr();

68
ostd/src/mm/test.rs
View File

@ -523,7 +523,7 @@ mod vmspace {
let preempt_guard = disable_preempt(); let preempt_guard = disable_preempt();
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert!(matches!( assert!(matches!(
cursor.query(), cursor.query(),
Ok((r, None)) if r == range Ok((r, None)) if r == range
@ -542,7 +542,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
// Initially, the page should not be mapped. // Initially, the page should not be mapped.
assert!(matches!( assert!(matches!(
cursor_mut.query().unwrap(), cursor_mut.query().unwrap(),
@ -556,7 +556,7 @@ mod vmspace {
{ {
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_eq!(cursor.virt_addr(), range.start); assert_eq!(cursor.virt_addr(), range.start);
assert_matches_mapped!(cursor, range.clone(), frame, prop); assert_matches_mapped!(cursor, range.clone(), frame, prop);
} }
@ -564,7 +564,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
// Unmaps the frame. // Unmaps the frame.
cursor_mut.unmap(range.start); cursor_mut.unmap(range.start);
} }
@ -572,7 +572,7 @@ mod vmspace {
// Queries to ensure it's unmapped. // Queries to ensure it's unmapped.
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert!(matches!( assert!(matches!(
cursor.query().unwrap(), cursor.query().unwrap(),
(r, None) if r == range (r, None) if r == range
@ -581,7 +581,7 @@ mod vmspace {
/// Maps a page twice and unmaps twice using `CursorMut`. /// Maps a page twice and unmaps twice using `CursorMut`.
#[ktest] #[ktest]
#[should_panic = "Mapping over an already mapped page at 0x1000"] #[should_panic = "mapping over an already mapped page"]
fn vmspace_map_twice() { fn vmspace_map_twice() {
let vmspace = VmSpace::default(); let vmspace = VmSpace::default();
let range = 0x1000..0x2000; let range = 0x1000..0x2000;
@ -592,21 +592,21 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.map(frame.clone(), prop); cursor_mut.map(frame.clone(), prop);
} }
{ {
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_matches_mapped!(cursor, range.clone(), frame, prop); assert_matches_mapped!(cursor, range.clone(), frame, prop);
} }
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.map(frame.clone(), prop); cursor_mut.map(frame.clone(), prop);
} }
} }
@ -623,27 +623,27 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.map(frame.clone(), prop); cursor_mut.map(frame.clone(), prop);
} }
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.unmap(range.start); cursor_mut.unmap(range.start);
} }
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.unmap(range.start); cursor_mut.unmap(range.start);
} }
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert!(matches!( assert!(matches!(
cursor.query().unwrap(), cursor.query().unwrap(),
(r, None) if r == range (r, None) if r == range
@ -677,7 +677,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.map(frame.clone(), prop); cursor_mut.map(frame.clone(), prop);
} }
@ -685,7 +685,7 @@ mod vmspace {
// Verifies that the mapping exists. // Verifies that the mapping exists.
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_matches_mapped!(cursor, range.clone(), frame, prop); assert_matches_mapped!(cursor, range.clone(), frame, prop);
} }
@ -693,7 +693,7 @@ mod vmspace {
// Flushes the TLB using a mutable cursor. // Flushes the TLB using a mutable cursor.
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.flusher().issue_tlb_flush(TlbFlushOp::for_all()); cursor_mut.flusher().issue_tlb_flush(TlbFlushOp::for_all());
cursor_mut.flusher().dispatch_tlb_flush(); cursor_mut.flusher().dispatch_tlb_flush();
} }
@ -702,7 +702,7 @@ mod vmspace {
// Verifies that the mapping still exists. // Verifies that the mapping still exists.
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_matches_mapped!(cursor, range.clone(), frame, prop); assert_matches_mapped!(cursor, range.clone(), frame, prop);
} }
} }
@ -716,7 +716,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
let frame = create_dummy_frame(); let frame = create_dummy_frame();
let prop = PageProperty::new_user(PageFlags::R, CachePolicy::Writeback); let prop = PageProperty::new_user(PageFlags::R, CachePolicy::Writeback);
cursor_mut.map(frame, prop); cursor_mut.map(frame, prop);
@ -763,7 +763,7 @@ mod vmspace {
// Creates the first cursor. // Creates the first cursor.
let _cursor1 = vmspace let _cursor1 = vmspace
.cursor(&preempt_guard, &range1) .cursor(&preempt_guard, &range1)
.expect("Failed to create first cursor"); .expect("failed to create first cursor");
// Attempts to create the second overlapping cursor. // Attempts to create the second overlapping cursor.
let cursor2_result = vmspace.cursor(&preempt_guard, &range2); let cursor2_result = vmspace.cursor(&preempt_guard, &range2);
@ -780,10 +780,10 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
let prop = PageProperty::new_user(PageFlags::RW, CachePolicy::Writeback); let prop = PageProperty::new_user(PageFlags::RW, CachePolicy::Writeback);
cursor_mut.map(frame.clone(), prop); cursor_mut.map(frame.clone(), prop);
cursor_mut.jump(range.start).expect("Failed to jump cursor"); cursor_mut.jump(range.start).expect("failed to jump cursor");
let protected_range = cursor_mut.protect_next(0x1000, |flags, _cache| { let protected_range = cursor_mut.protect_next(0x1000, |flags, _cache| {
*flags = PageFlags::R; *flags = PageFlags::R;
}); });
@ -793,7 +793,7 @@ mod vmspace {
// Confirms that the property was updated. // Confirms that the property was updated.
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_matches_mapped!( assert_matches_mapped!(
cursor, cursor,
range.clone(), range.clone(),
@ -811,7 +811,7 @@ mod vmspace {
let preempt_guard = disable_preempt(); let preempt_guard = disable_preempt();
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.unmap(0x800); // Not page-aligned. cursor_mut.unmap(0x800); // Not page-aligned.
} }
@ -824,7 +824,7 @@ mod vmspace {
let preempt_guard = disable_preempt(); let preempt_guard = disable_preempt();
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.protect_next(0x2000, |_flags, _cache| {}); // Not page-aligned. cursor_mut.protect_next(0x2000, |_flags, _cache| {}); // Not page-aligned.
} }
@ -843,7 +843,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
// Initially, the page should not be mapped. // Initially, the page should not be mapped.
assert!(matches!( assert!(matches!(
cursor_mut.query().unwrap(), cursor_mut.query().unwrap(),
@ -857,7 +857,7 @@ mod vmspace {
{ {
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
assert_eq!(cursor.virt_addr(), range.start); assert_eq!(cursor.virt_addr(), range.start);
let (query_range, query_item) = cursor.query().unwrap(); let (query_range, query_item) = cursor.query().unwrap();
assert_eq!(query_range, range); assert_eq!(query_range, range);
@ -874,7 +874,7 @@ mod vmspace {
{ {
let cursor_mut = vmspace let cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
let (found_iomem, offset) = cursor_mut.find_iomem_by_paddr(IOMEM_PADDR).unwrap(); let (found_iomem, offset) = cursor_mut.find_iomem_by_paddr(IOMEM_PADDR).unwrap();
assert_eq!(found_iomem.paddr(), IOMEM_PADDR); assert_eq!(found_iomem.paddr(), IOMEM_PADDR);
assert_eq!(found_iomem.size(), 0x1000); assert_eq!(found_iomem.size(), 0x1000);
@ -907,7 +907,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
// Maps the `IoMem` with the offset. // Maps the `IoMem` with the offset.
cursor_mut.map_iomem(iomem.clone(), prop, 0x1000, 0x1000); cursor_mut.map_iomem(iomem.clone(), prop, 0x1000, 0x1000);
} }
@ -916,7 +916,7 @@ mod vmspace {
{ {
let mut cursor = vmspace let mut cursor = vmspace
.cursor(&preempt_guard, &range) .cursor(&preempt_guard, &range)
.expect("Failed to create cursor"); .expect("failed to create the cursor");
let (query_range, query_item) = cursor.query().unwrap(); let (query_range, query_item) = cursor.query().unwrap();
assert_eq!(query_range, range); assert_eq!(query_range, range);
@ -932,7 +932,7 @@ mod vmspace {
{ {
let cursor_mut = vmspace let cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
let (found_iomem, offset) = cursor_mut let (found_iomem, offset) = cursor_mut
.find_iomem_by_paddr(IOMEM_PADDR + 0x2000) .find_iomem_by_paddr(IOMEM_PADDR + 0x2000)
.unwrap(); .unwrap();
@ -954,7 +954,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.map_iomem(iomem.clone(), prop, 0x1000, 0); cursor_mut.map_iomem(iomem.clone(), prop, 0x1000, 0);
} }
@ -962,7 +962,7 @@ mod vmspace {
{ {
let cursor_mut = vmspace let cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
assert!( assert!(
cursor_mut cursor_mut
.find_iomem_by_paddr(IOMEM_PADDR + 0x3000) .find_iomem_by_paddr(IOMEM_PADDR + 0x3000)
@ -974,7 +974,7 @@ mod vmspace {
{ {
let mut cursor_mut = vmspace let mut cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
cursor_mut.unmap(0x1000); cursor_mut.unmap(0x1000);
} }
@ -982,7 +982,7 @@ mod vmspace {
{ {
let cursor_mut = vmspace let cursor_mut = vmspace
.cursor_mut(&preempt_guard, &range) .cursor_mut(&preempt_guard, &range)
.expect("Failed to create mutable cursor"); .expect("failed to create the mutable cursor");
assert!( assert!(
cursor_mut cursor_mut
.find_iomem_by_paddr(IOMEM_PADDR + 0x3000) .find_iomem_by_paddr(IOMEM_PADDR + 0x3000)