Create example mapping for page 0x1000

src/main.rs

@@ -9,7 +9,7 @@ use core::panic::PanicInfo;
 #[no_mangle]
 pub extern "C" fn _start() -> ! {
     use blog_os::interrupts::PICS;
-    use blog_os::memory::{self, translate_addr};
+    use blog_os::memory::{self, create_example_mapping, EmptyFrameAllocator};
 
     println!("Hello World{}", "!");
 
@@ -19,16 +19,10 @@ pub extern "C" fn _start() -> ! {
     x86_64::instructions::interrupts::enable();
 
     const LEVEL_4_TABLE_ADDR: usize = 0o_177777_777_777_777_777_0000;
-    let recursive_page_table = unsafe { memory::init(LEVEL_4_TABLE_ADDR) };
-
-    // the identity-mapped vga buffer page
-    println!("0xb8000 -> {:?}", translate_addr(0xb8000, &recursive_page_table));
-    // some code page
-    println!("0x20010a -> {:?}", translate_addr(0x20010a, &recursive_page_table));
-    // some stack page
-    println!("0x57ac001ffe48 -> {:?}", translate_addr(0x57ac001ffe48,
-        &recursive_page_table));
+    let mut recursive_page_table = unsafe { memory::init(LEVEL_4_TABLE_ADDR) };
 
+    create_example_mapping(&mut recursive_page_table, &mut EmptyFrameAllocator);
+    unsafe { (0x1900 as *mut u64).write_volatile(0xf021f077f065f04e) };
 
     println!("It did not crash!");
     blog_os::hlt_loop();

src/memory.rs

@@ -1,5 +1,7 @@
-use x86_64::structures::paging::{Mapper, Page, PageTable, RecursivePageTable};
-use x86_64::{VirtAddr, PhysAddr};
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, Page, PageTable, PhysFrame, RecursivePageTable, Size4KiB,
+};
+use x86_64::{PhysAddr, VirtAddr};
 
 /// Creates a RecursivePageTable instance from the level 4 address.
 ///
@@ -28,3 +30,26 @@ pub fn translate_addr(addr: u64, recursive_page_table: &RecursivePageTable) -> O
     let frame = recursive_page_table.translate_page(page);
     frame.map(|frame| frame.start_address() + u64::from(addr.page_offset()))
 }
+
+pub fn create_example_mapping(
+    recursive_page_table: &mut RecursivePageTable,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+) {
+    use x86_64::structures::paging::PageTableFlags as Flags;
+
+    let page: Page = Page::containing_address(VirtAddr::new(0x1000));
+    let frame = PhysFrame::containing_address(PhysAddr::new(0xb8000));
+    let flags = Flags::PRESENT | Flags::WRITABLE;
+
+    let map_to_result = unsafe { recursive_page_table.map_to(page, frame, flags, frame_allocator) };
+    map_to_result.expect("map_to failed").flush();
+}
+
+/// A FrameAllocator that always returns `None`.
+pub struct EmptyFrameAllocator;
+
+impl FrameAllocator<Size4KiB> for EmptyFrameAllocator {
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+        None
+    }
+}