1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
//! Abstractions for reading and modifying the mapping of pages. pub use self::mapped::MappedPageTable; #[cfg(target_arch = "x86_64")] pub use self::recursive::RecursivePageTable; use crate::structures::paging::{ frame_alloc::FrameAllocator, page_table::PageTableFlags, Page, PageSize, PhysFrame, Size4KiB, }; use crate::{PhysAddr, VirtAddr}; mod mapped; mod recursive; /// A trait for common page table operations. pub trait Mapper<S: PageSize> { /// Creates a new mapping in the page table. /// /// This function might need additional physical frames to create new page tables. These /// frames are allocated from the `allocator` argument. At most three frames are required. /// /// This function is unsafe because the caller must guarantee the following: /// /// - The passed `frame` must be unused, i.e. not used for any other mappings. /// - The passed `frame_allocator` must only yield unused frames. unsafe fn map_to<A>( &mut self, page: Page<S>, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError> where A: FrameAllocator<Size4KiB>; /// Removes a mapping from the page table and returns the frame that used to be mapped. /// /// Note that no page tables or pages are deallocated. fn unmap(&mut self, page: Page<S>) -> Result<(PhysFrame<S>, MapperFlush<S>), UnmapError>; /// Updates the flags of an existing mapping. fn update_flags( &mut self, page: Page<S>, flags: PageTableFlags, ) -> Result<MapperFlush<S>, FlagUpdateError>; /// Return the frame that the specified page is mapped to. fn translate_page(&self, page: Page<S>) -> Result<PhysFrame<S>, TranslateError>; /// Maps the given frame to the virtual page with the same address. /// /// This function is unsafe because the caller must guarantee the following: /// /// - The passed `frame` must be unused, i.e. not used for any other mappings. /// - The passed `frame_allocator` must only yield unused frames. unsafe fn identity_map<A>( &mut self, frame: PhysFrame<S>, flags: PageTableFlags, frame_allocator: &mut A, ) -> Result<MapperFlush<S>, MapToError> where A: FrameAllocator<Size4KiB>, S: PageSize, Self: Mapper<S>, { let page = Page::containing_address(VirtAddr::new(frame.start_address().as_u64())); self.map_to(page, frame, flags, frame_allocator) } } /// This type represents a page whose mapping has changed in the page table. /// /// The old mapping might be still cached in the translation lookaside buffer (TLB), so it needs /// to be flushed from the TLB before it's accessed. This type is returned from function that /// change the mapping of a page to ensure that the TLB flush is not forgotten. #[derive(Debug)] #[must_use = "Page Table changes must be flushed or ignored."] pub struct MapperFlush<S: PageSize>(Page<S>); impl<S: PageSize> MapperFlush<S> { /// Create a new flush promise fn new(page: Page<S>) -> Self { MapperFlush(page) } /// Flush the page from the TLB to ensure that the newest mapping is used. #[cfg(target_arch = "x86_64")] pub fn flush(self) { crate::instructions::tlb::flush(self.0.start_address()); } /// Don't flush the TLB and silence the “must be used” warning. pub fn ignore(self) {} } /// This error is returned from `map_to` and similar methods. #[derive(Debug)] pub enum MapToError { /// An additional frame was needed for the mapping process, but the frame allocator /// returned `None`. FrameAllocationFailed, /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the /// given page is part of an already mapped huge page. ParentEntryHugePage, /// The given page is already mapped to a physical frame. PageAlreadyMapped, } /// An error indicating that an `unmap` call failed. #[derive(Debug)] pub enum UnmapError { /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the /// given page is part of a huge page and can't be freed individually. ParentEntryHugePage, /// The given page is not mapped to a physical frame. PageNotMapped, /// The page table entry for the given page points to an invalid physical address. InvalidFrameAddress(PhysAddr), } /// An error indicating that an `update_flags` call failed. #[derive(Debug)] pub enum FlagUpdateError { /// The given page is not mapped to a physical frame. PageNotMapped, /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the /// given page is part of a huge page and can't be freed individually. ParentEntryHugePage, } /// An error indicating that an `translate` call failed. #[derive(Debug)] pub enum TranslateError { /// The given page is not mapped to a physical frame. PageNotMapped, /// An upper level page table entry has the `HUGE_PAGE` flag set, which means that the /// given page is part of a huge page and can't be freed individually. ParentEntryHugePage, /// The page table entry for the given page points to an invalid physical address. InvalidFrameAddress(PhysAddr), }