diff --git a/ostd/src/mm/page_table/cursor/mod.rs b/ostd/src/mm/page_table/cursor/mod.rs index 1637c0dbe..8edf6b2b5 100644 --- a/ostd/src/mm/page_table/cursor/mod.rs +++ b/ostd/src/mm/page_table/cursor/mod.rs @@ -233,7 +233,7 @@ impl<'rcu, C: PageTableConfig> Cursor<'rcu, C> { let split_child = cur_entry .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); continue; } @@ -296,7 +296,7 @@ impl<'rcu, C: PageTableConfig> Cursor<'rcu, C> { fn pop_level(&mut self) { let taken = self.path[self.level as usize - 1] .take() - .expect("Popping a level without a lock"); + .expect("popping a level without a lock"); let _ = ManuallyDrop::new(taken); 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); assert!(level <= C::HIGHEST_TRANSLATION_LEVEL); let size = page_size::(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; 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) { - 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))); @@ -550,7 +554,7 @@ impl<'rcu, C: PageTableConfig> CursorMut<'rcu, C> { if !C::TOP_LEVEL_CAN_UNMAP && level == C::NR_LEVELS { 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. diff --git a/ostd/src/mm/page_table/test.rs b/ostd/src/mm/page_table/test.rs index 9c8662e62..6ef5e9356 100644 --- a/ostd/src/mm/page_table/test.rs +++ b/ostd/src/mm/page_table/test.rs @@ -31,7 +31,7 @@ mod test_utils { unsafe { page_table .cursor_mut(&preempt_guard, &virt_range) - .unwrap() + .expect("failed to create the cursor") .map(VmItem::new_tracked(frame.into(), page_property)) }; @@ -218,12 +218,12 @@ mod create_page_table { let user_entry = user_root.entry(i); 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); 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); @@ -320,7 +320,7 @@ mod range_checks { } #[ktest] - #[should_panic] + #[should_panic = "failed to create the cursor"] fn overflow_boundary_mapping() { let virt_range = (MAX_USERSPACE_VADDR - (PAGE_SIZE / 2))..(MAX_USERSPACE_VADDR + (PAGE_SIZE / 2)); @@ -437,7 +437,7 @@ mod overlapping_mappings { use super::{test_utils::*, *}; #[ktest] - #[should_panic] + #[should_panic = "mapping over an already mapped page"] fn overlapping_mappings() { let page_table = PageTable::::empty(); let vrange1 = PAGE_SIZE..(PAGE_SIZE * 2); @@ -464,7 +464,7 @@ mod overlapping_mappings { } #[ktest] - #[should_panic] + #[should_panic = "cursor virtual address not aligned for mapping"] fn unaligned_map() { let page_table = PageTable::::empty(); let virt_range = (PAGE_SIZE + 512)..(PAGE_SIZE * 2 + 512); @@ -534,7 +534,7 @@ mod navigation { cursor.jump(FIRST_MAP_ADDR).unwrap(); assert_eq!(cursor.virt_addr(), FIRST_MAP_ADDR); 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); let TestPtItemRef((pa, _, prop), _) = queried_item; @@ -615,7 +615,7 @@ mod navigation { assert_eq!(cursor.virt_addr(), 0); 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!(cursor.virt_addr(), FIRST_MAP_ADDR); @@ -623,7 +623,7 @@ mod navigation { cursor.jump(FIRST_MAP_ADDR + PAGE_SIZE).unwrap(); 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!(cursor.virt_addr(), SECOND_MAP_ADDR); @@ -654,7 +654,7 @@ mod unmap { let Some(PageTableFrag::Mapped { va, item }) = (unsafe { cursor.take_next(virt_range.len()) }) else { - panic!("Expected to take a mapped item"); + panic!("expected to take a mapped item"); }; assert_eq!(va, virt_range.start); @@ -688,7 +688,7 @@ mod unmap { num_frames, }) = (unsafe { cursor.take_next(large_range.len()) }) 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. @@ -741,7 +741,7 @@ mod mapping { let Some(PageTableFrag::Mapped { va: frag_va, item }) = (unsafe { cursor.take_next(unmap_len) }) 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. @@ -799,7 +799,7 @@ mod mapping { let (va, item) = cursor.query().unwrap(); 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)); @@ -841,7 +841,7 @@ mod mapping { let va_low = protect_va_range.start - PAGE_SIZE; let (va_low_pa, prop_low) = pt .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!( prop_low, @@ -856,7 +856,7 @@ mod mapping { let (va, item) = cursor.query().unwrap(); 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)); @@ -875,7 +875,7 @@ mod mapping { let va_high = protect_va_range.end; let (va_high_pa, prop_high) = pt .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!( prop_high, @@ -910,7 +910,7 @@ mod protection_and_query { let va_to_check = PAGE_SIZE * i; let (_, prop) = page_table .page_walk(va_to_check) - .expect("Mapping should exist"); + .expect("mapping should exist"); assert_eq!(prop.flags, PageFlags::RW); assert_eq!(prop.cache, CachePolicy::Writeback); } @@ -926,7 +926,7 @@ mod protection_and_query { let va_to_check = PAGE_SIZE * i; let (_, prop) = page_table .page_walk(va_to_check) - .expect("Mapping should exist"); + .expect("mapping should exist"); assert_eq!(prop.flags, PageFlags::R); assert_eq!(prop.cache, CachePolicy::Writeback); } @@ -1011,7 +1011,7 @@ mod boot_pt { } #[ktest] - #[should_panic] + #[should_panic = "mapping an already mapped huge page in the boot page table"] fn map_base_page_already_mapped() { let root_frame = FrameAllocOptions::new().alloc_frame().unwrap(); let root_paddr = root_frame.paddr(); @@ -1029,7 +1029,7 @@ mod boot_pt { } #[ktest] - #[should_panic] + #[should_panic = "protecting an unmapped page in the boot page table"] fn protect_base_page_unmapped() { let root_frame = FrameAllocOptions::new().alloc_frame().unwrap(); let root_paddr = root_frame.paddr(); diff --git a/ostd/src/mm/test.rs b/ostd/src/mm/test.rs index 0b5930fde..d9577bcd8 100644 --- a/ostd/src/mm/test.rs +++ b/ostd/src/mm/test.rs @@ -523,7 +523,7 @@ mod vmspace { let preempt_guard = disable_preempt(); let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert!(matches!( cursor.query(), Ok((r, None)) if r == range @@ -542,7 +542,7 @@ mod vmspace { { let mut cursor_mut = vmspace .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. assert!(matches!( cursor_mut.query().unwrap(), @@ -556,7 +556,7 @@ mod vmspace { { let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_eq!(cursor.virt_addr(), range.start); assert_matches_mapped!(cursor, range.clone(), frame, prop); } @@ -564,7 +564,7 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); // Unmaps the frame. cursor_mut.unmap(range.start); } @@ -572,7 +572,7 @@ mod vmspace { // Queries to ensure it's unmapped. let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert!(matches!( cursor.query().unwrap(), (r, None) if r == range @@ -581,7 +581,7 @@ mod vmspace { /// Maps a page twice and unmaps twice using `CursorMut`. #[ktest] - #[should_panic = "Mapping over an already mapped page at 0x1000"] + #[should_panic = "mapping over an already mapped page"] fn vmspace_map_twice() { let vmspace = VmSpace::default(); let range = 0x1000..0x2000; @@ -592,21 +592,21 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.map(frame.clone(), prop); } { let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_matches_mapped!(cursor, range.clone(), frame, prop); } { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.map(frame.clone(), prop); } } @@ -623,27 +623,27 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.map(frame.clone(), prop); } { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.unmap(range.start); } { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.unmap(range.start); } let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert!(matches!( cursor.query().unwrap(), (r, None) if r == range @@ -677,7 +677,7 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.map(frame.clone(), prop); } @@ -685,7 +685,7 @@ mod vmspace { // Verifies that the mapping exists. let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_matches_mapped!(cursor, range.clone(), frame, prop); } @@ -693,7 +693,7 @@ mod vmspace { // Flushes the TLB using a mutable cursor. let mut cursor_mut = vmspace .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().dispatch_tlb_flush(); } @@ -702,7 +702,7 @@ mod vmspace { // Verifies that the mapping still exists. let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_matches_mapped!(cursor, range.clone(), frame, prop); } } @@ -716,7 +716,7 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); let frame = create_dummy_frame(); let prop = PageProperty::new_user(PageFlags::R, CachePolicy::Writeback); cursor_mut.map(frame, prop); @@ -763,7 +763,7 @@ mod vmspace { // Creates the first cursor. let _cursor1 = vmspace .cursor(&preempt_guard, &range1) - .expect("Failed to create first cursor"); + .expect("failed to create first cursor"); // Attempts to create the second overlapping cursor. let cursor2_result = vmspace.cursor(&preempt_guard, &range2); @@ -780,10 +780,10 @@ mod vmspace { { let mut cursor_mut = vmspace .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); 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| { *flags = PageFlags::R; }); @@ -793,7 +793,7 @@ mod vmspace { // Confirms that the property was updated. let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_matches_mapped!( cursor, range.clone(), @@ -811,7 +811,7 @@ mod vmspace { let preempt_guard = disable_preempt(); let mut cursor_mut = vmspace .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. } @@ -824,7 +824,7 @@ mod vmspace { let preempt_guard = disable_preempt(); let mut cursor_mut = vmspace .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. } @@ -843,7 +843,7 @@ mod vmspace { { let mut cursor_mut = vmspace .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. assert!(matches!( cursor_mut.query().unwrap(), @@ -857,7 +857,7 @@ mod vmspace { { let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); assert_eq!(cursor.virt_addr(), range.start); let (query_range, query_item) = cursor.query().unwrap(); assert_eq!(query_range, range); @@ -874,7 +874,7 @@ mod vmspace { { let cursor_mut = vmspace .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(); assert_eq!(found_iomem.paddr(), IOMEM_PADDR); assert_eq!(found_iomem.size(), 0x1000); @@ -907,7 +907,7 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); // Maps the `IoMem` with the offset. cursor_mut.map_iomem(iomem.clone(), prop, 0x1000, 0x1000); } @@ -916,7 +916,7 @@ mod vmspace { { let mut cursor = vmspace .cursor(&preempt_guard, &range) - .expect("Failed to create cursor"); + .expect("failed to create the cursor"); let (query_range, query_item) = cursor.query().unwrap(); assert_eq!(query_range, range); @@ -932,7 +932,7 @@ mod vmspace { { let cursor_mut = vmspace .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 + 0x2000) .unwrap(); @@ -954,7 +954,7 @@ mod vmspace { { let mut cursor_mut = vmspace .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); } @@ -962,7 +962,7 @@ mod vmspace { { let cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); assert!( cursor_mut .find_iomem_by_paddr(IOMEM_PADDR + 0x3000) @@ -974,7 +974,7 @@ mod vmspace { { let mut cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); cursor_mut.unmap(0x1000); } @@ -982,7 +982,7 @@ mod vmspace { { let cursor_mut = vmspace .cursor_mut(&preempt_guard, &range) - .expect("Failed to create mutable cursor"); + .expect("failed to create the mutable cursor"); assert!( cursor_mut .find_iomem_by_paddr(IOMEM_PADDR + 0x3000)