Update code to current post-10 branch

Latest commit on post-10 branch: e5dfbd4b23

src/bin/test-basic-boot.rs

@@ -1,6 +1,6 @@
-#![no_std] // don't link the Rust standard library
+#![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)] // disable all Rust-level entry points
-#![cfg_attr(test, allow(dead_code, unused_macros, unused_imports))]
+#![cfg_attr(test, allow(unused_imports))]
 
 use blog_os::{exit_qemu, serial_println};
 use core::panic::PanicInfo;

src/bin/test-exception-breakpoint.rs

@@ -2,8 +2,8 @@
 #![cfg_attr(not(test), no_main)]
 #![cfg_attr(test, allow(dead_code, unused_macros, unused_imports))]
 
-use core::panic::PanicInfo;
 use blog_os::{exit_qemu, serial_println};
+use core::panic::PanicInfo;
 
 #[cfg(not(test))]
 #[no_mangle]
@@ -14,11 +14,12 @@ pub extern "C" fn _start() -> ! {
 
     serial_println!("ok");
 
-    unsafe { exit_qemu(); }
+    unsafe {
+        exit_qemu();
+    }
     loop {}
 }
 
-
 #[cfg(not(test))]
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
@@ -26,6 +27,8 @@ fn panic(info: &PanicInfo) -> ! {
 
     serial_println!("{}", info);
 
-    unsafe { exit_qemu(); }
+    unsafe {
+        exit_qemu();
+    }
     loop {}
 }

src/bin/test-panic.rs

@@ -1,6 +1,6 @@
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 #![cfg_attr(not(test), no_main)]
-#![cfg_attr(test, allow(dead_code, unused_macros, unused_imports))]
+#![cfg_attr(test, allow(unused_imports))]
 
 use blog_os::{exit_qemu, serial_println};
 use core::panic::PanicInfo;

src/gdt.rs

@@ -18,6 +18,9 @@ lazy_static! {
         };
         tss
     };
+}
+
+lazy_static! {
     static ref GDT: (GlobalDescriptorTable, Selectors) = {
         let mut gdt = GlobalDescriptorTable::new();
         let code_selector = gdt.add_entry(Descriptor::kernel_code_segment());

src/interrupts.rs

@@ -4,22 +4,21 @@
 // problem we skip compilation of this module on Windows.
 #![cfg(not(windows))]
 
-use crate::{gdt, print, println};
+use crate::{gdt, hlt_loop, print, println};
 use lazy_static::lazy_static;
 use pic8259_simple::ChainedPics;
 use spin;
 use x86_64::structures::idt::{ExceptionStackFrame, InterruptDescriptorTable, PageFaultErrorCode};
 
-
 pub const PIC_1_OFFSET: u8 = 32;
 pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
 
-pub static PICS: spin::Mutex<ChainedPics> =
-    spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
-
 pub const TIMER_INTERRUPT_ID: u8 = PIC_1_OFFSET;
 pub const KEYBOARD_INTERRUPT_ID: u8 = PIC_1_OFFSET + 1;
 
+pub static PICS: spin::Mutex<ChainedPics> =
+    spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
+
 lazy_static! {
     static ref IDT: InterruptDescriptorTable = {
         let mut idt = InterruptDescriptorTable::new();
@@ -30,10 +29,8 @@ lazy_static! {
                 .set_handler_fn(double_fault_handler)
                 .set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX);
         }
-
         idt[usize::from(TIMER_INTERRUPT_ID)].set_handler_fn(timer_interrupt_handler);
         idt[usize::from(KEYBOARD_INTERRUPT_ID)].set_handler_fn(keyboard_interrupt_handler);
-
         idt
     };
 }
@@ -59,25 +56,10 @@ extern "x86-interrupt" fn page_fault_handler(
     hlt_loop();
 }
 
-extern "x86-interrupt" fn page_fault_handler(
-    stack_frame: &mut ExceptionStackFrame,
-    _error_code: PageFaultErrorCode,
-) {
-    use crate::hlt_loop;
-    use x86_64::registers::control::Cr2;
-
-    println!("EXCEPTION: PAGE FAULT");
-    println!("Accessed Address: {:?}", Cr2::read());
-    println!("{:#?}", stack_frame);
-    hlt_loop();
-}
-
 extern "x86-interrupt" fn double_fault_handler(
     stack_frame: &mut ExceptionStackFrame,
     _error_code: u64,
 ) {
-    use crate::hlt_loop;
-
     println!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
     hlt_loop();
 }

src/lib.rs

@@ -1,8 +1,9 @@
-#![cfg_attr(not(test), no_std)] // don't link the Rust standard library
+#![cfg_attr(not(test), no_std)]
 #![feature(abi_x86_interrupt)]
 
 pub mod gdt;
 pub mod interrupts;
+pub mod memory;
 pub mod serial;
 pub mod vga_buffer;
 

src/main.rs

@@ -1,34 +1,31 @@
-#![no_std] // don't link the Rust standard library
-#![cfg_attr(not(test), no_main)] // disable all Rust-level entry points
+#![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(test), no_main)]
 #![cfg_attr(test, allow(unused_imports))]
 
+use blog_os::println;
+use bootloader::{bootinfo::BootInfo, entry_point};
 use core::panic::PanicInfo;
 
-use blog_os::println;
-use bootloader::bootinfo::BootInfo;
+entry_point!(kernel_main);
 
-
-/// This function is the entry point, since the linker looks for a function
-/// named `_start` by default.
 #[cfg(not(test))]
-#[no_mangle] // don't mangle the name of this function
-pub extern "C" fn _start(boot_info: &BootInfo) -> ! {
+fn kernel_main(boot_info: &'static BootInfo) -> ! {
     use blog_os::interrupts::PICS;
-    use x86_64::structures::paging::PageTable;
+    use blog_os::memory::{self, create_example_mapping};
 
     println!("Hello World{}", "!");
 
-    let level_4_table_ptr = 0xffff_ffff_ffff_f000 as *const PageTable;
-    let level_4_table = unsafe { &*level_4_table_ptr };
-    for i in 0..10 {
-        println!("Entry {}: {:?}", i, level_4_table[i]);
-    }
-
     blog_os::gdt::init();
     blog_os::interrupts::init_idt();
     unsafe { PICS.lock().initialize() };
     x86_64::instructions::interrupts::enable();
 
+    let mut recursive_page_table = unsafe { memory::init(boot_info.p4_table_addr as usize) };
+    let mut frame_allocator = memory::init_frame_allocator(&boot_info.memory_map);
+
+    create_example_mapping(&mut recursive_page_table, &mut frame_allocator);
+    unsafe { (0xdeadbeaf900 as *mut u64).write_volatile(0xf021f077f065f04e) };
+
     println!("It did not crash!");
     blog_os::hlt_loop();
 }

src/memory.rs

@@ -0,0 +1,90 @@
+use bootloader::bootinfo::{MemoryMap, MemoryRegionType};
+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.
+///
+/// This function is unsafe because it can break memory safety if an invalid
+/// address is passed.
+pub unsafe fn init(level_4_table_addr: usize) -> RecursivePageTable<'static> {
+    /// Rust currently treats the whole body of unsafe functions as an unsafe
+    /// block, which makes it difficult to see which operations are unsafe. To
+    /// limit the scope of unsafe we use a safe inner function.
+    fn init_inner(level_4_table_addr: usize) -> RecursivePageTable<'static> {
+        let level_4_table_ptr = level_4_table_addr as *mut PageTable;
+        let level_4_table = unsafe { &mut *level_4_table_ptr };
+        RecursivePageTable::new(level_4_table).unwrap()
+    }
+
+    init_inner(level_4_table_addr)
+}
+
+/// Create a FrameAllocator from the passed memory map
+pub fn init_frame_allocator(
+    memory_map: &'static MemoryMap,
+) -> BootInfoFrameAllocator<impl Iterator<Item = PhysFrame>> {
+    // get usable regions from memory map
+    let regions = memory_map
+        .iter()
+        .filter(|r| r.region_type == MemoryRegionType::Usable);
+    // map each region to its address range
+    let addr_ranges = regions.map(|r| r.range.start_addr()..r.range.end_addr());
+    // transform to an iterator of frame start addresses
+    let frame_addresses = addr_ranges.flat_map(|r| r.into_iter().step_by(4096));
+    // create `PhysFrame` types from the start addresses
+    let frames = frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr)));
+
+    BootInfoFrameAllocator { frames }
+}
+
+/// Returns the physical address for the given virtual address, or `None` if
+/// the virtual address is not mapped.
+pub fn translate_addr(addr: u64, recursive_page_table: &RecursivePageTable) -> Option<PhysAddr> {
+    let addr = VirtAddr::new(addr);
+    let page: Page = Page::containing_address(addr);
+
+    // perform the translation
+    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(0xdeadbeaf000));
+    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
+    }
+}
+
+pub struct BootInfoFrameAllocator<I>
+where
+    I: Iterator<Item = PhysFrame>,
+{
+    frames: I,
+}
+
+impl<I> FrameAllocator<Size4KiB> for BootInfoFrameAllocator<I>
+where
+    I: Iterator<Item = PhysFrame>,
+{
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+        self.frames.next()
+    }
+}

src/vga_buffer.rs

@@ -161,7 +161,8 @@ macro_rules! println {
     ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
 }
 
-/// Prints the given formatted string to the VGA text buffer through the global `WRITER` instance.
+/// Prints the given formatted string to the VGA text buffer
+/// through the global `WRITER` instance.
 #[doc(hidden)]
 pub fn _print(args: fmt::Arguments) {
     use core::fmt::Write;