michaelkuc6/blog_os
1
0
Fork 0
mirror of https://github.com/phil-opp/blog_os.git synced 2025-12-16 22:37:49 +00:00
Code Issues Projects Releases Wiki Activity

Make translate and map_to safe by making them methods of a new ActivePageTable struct

Browse Source
This commit is contained in:
Philipp Oppermann
2017-04-13 19:22:21 +02:00
parent dedf6e8959
commit bb473c7907
1 changed files with 73 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
src/memory/paging/mod.rs
View File

@@ -1,5 +1,7 @@
use memory::{PAGE_SIZE, Frame, FrameAllocator};
pub use self::entry::*; pub use self::entry::*;
use core::ptr::Unique;
use memory::{PAGE_SIZE, Frame, FrameAllocator};
use self::table::{Table, Level4};
mod entry; mod entry;
mod table; mod table;
@@ -37,66 +39,85 @@ impl Page {
fn p1_index(&self) -> usize { fn p1_index(&self) -> usize {
(self.number >> 0) & 0o777 (self.number >> 0) & 0o777
} }
} }
pub fn translate(virtual_address: VirtualAddress) -> Option<PhysicalAddress> { pub struct ActivePageTable {
let offset = virtual_address % PAGE_SIZE; p4: Unique<Table<Level4>>,
translate_page(Page::containing_address(virtual_address))
.map(|frame| frame.number * PAGE_SIZE + offset)
} }
fn translate_page(page: Page) -> Option<Frame> { impl ActivePageTable {
use self::entry::HUGE_PAGE; pub unsafe fn new() -> ActivePageTable {
ActivePageTable {
p4: Unique::new_unchecked(table::P4),
}
}
let p3 = unsafe { &*table::P4 }.next_table(page.p4_index()); fn p4(&self) -> &Table<Level4> {
unsafe { self.p4.as_ref() }
}
let huge_page = || { fn p4_mut(&mut self) -> &mut Table<Level4> {
p3.and_then(|p3| { unsafe { self.p4.as_mut() }
let p3_entry = &p3[page.p3_index()]; }
// 1GiB page?
if let Some(start_frame) = p3_entry.pointed_frame() { pub fn translate(&self, virtual_address: VirtualAddress) -> Option<PhysicalAddress> {
if p3_entry.flags().contains(HUGE_PAGE) { let offset = virtual_address % PAGE_SIZE;
// address must be 1GiB aligned self.translate_page(Page::containing_address(virtual_address))
assert!(start_frame.number % (ENTRY_COUNT * ENTRY_COUNT) == 0); .map(|frame| frame.number * PAGE_SIZE + offset)
return Some(Frame { }
number: start_frame.number + page.p2_index() *
ENTRY_COUNT + page.p1_index(), fn translate_page(&self, page: Page) -> Option<Frame> {
}); use self::entry::HUGE_PAGE;
}
} let p3 = self.p4().next_table(page.p4_index());
if let Some(p2) = p3.next_table(page.p3_index()) {
let p2_entry = &p2[page.p2_index()]; let huge_page = || {
// 2MiB page? p3.and_then(|p3| {
if let Some(start_frame) = p2_entry.pointed_frame() { let p3_entry = &p3[page.p3_index()];
if p2_entry.flags().contains(HUGE_PAGE) { // 1GiB page?
// address must be 2MiB aligned if let Some(start_frame) = p3_entry.pointed_frame() {
assert!(start_frame.number % ENTRY_COUNT == 0); if p3_entry.flags().contains(HUGE_PAGE) {
// address must be 1GiB aligned
assert!(start_frame.number % (ENTRY_COUNT * ENTRY_COUNT) == 0);
return Some(Frame { return Some(Frame {
number: start_frame.number + page.p1_index() number: start_frame.number + page.p2_index() *
ENTRY_COUNT + page.p1_index(),
}); });
} }
} }
} if let Some(p2) = p3.next_table(page.p3_index()) {
None let p2_entry = &p2[page.p2_index()];
}) // 2MiB page?
}; if let Some(start_frame) = p2_entry.pointed_frame() {
if p2_entry.flags().contains(HUGE_PAGE) {
// address must be 2MiB aligned
assert!(start_frame.number % ENTRY_COUNT == 0);
return Some(Frame {
number: start_frame.number + page.p1_index()
});
}
}
}
None
})
};
p3.and_then(|p3| p3.next_table(page.p3_index())) p3.and_then(|p3| p3.next_table(page.p3_index()))
.and_then(|p2| p2.next_table(page.p2_index())) .and_then(|p2| p2.next_table(page.p2_index()))
.and_then(|p1| p1[page.p1_index()].pointed_frame()) .and_then(|p1| p1[page.p1_index()].pointed_frame())
.or_else(huge_page) .or_else(huge_page)
} }
pub fn map_to<A>(page: Page, frame: Frame, flags: EntryFlags, pub fn map_to<A>(&mut self, page: Page, frame: Frame, flags: EntryFlags,
allocator: &mut A) allocator: &mut A)
where A: FrameAllocator where A: FrameAllocator
{ {
let p4 = unsafe { &mut *table::P4 }; let p4 = self.p4_mut();
let mut p3 = p4.next_table_create(page.p4_index(), allocator); let mut p3 = p4.next_table_create(page.p4_index(), allocator);
let mut p2 = p3.next_table_create(page.p3_index(), allocator); let mut p2 = p3.next_table_create(page.p3_index(), allocator);
let mut p1 = p2.next_table_create(page.p2_index(), allocator); let mut p1 = p2.next_table_create(page.p2_index(), allocator);
assert!(p1[page.p1_index()].is_unused()); assert!(p1[page.p1_index()].is_unused());
p1[page.p1_index()].set(frame, flags | PRESENT); p1[page.p1_index()].set(frame, flags | PRESENT);
}
} }