diff --git a/Cargo.toml b/Cargo.toml index de8bc4c..8ee1e2c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -bootloader = "0.8.1" +bootloader = { version = "0.8.1", features = ["map_physical_memory"]} pc-keyboard = "0.3.1" pic8259_simple = "0.1.1" spin = "0.5.2" diff --git a/src/gdt.rs b/src/gdt.rs index f8146a9..e307574 100644 --- a/src/gdt.rs +++ b/src/gdt.rs @@ -1,11 +1,11 @@ use lazy_static::lazy_static; -use x86_64::VirtAddr; -use x86_64::structures::gdt::{GlobalDescriptorTable, Descriptor, SegmentSelector}; +use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector}; use x86_64::structures::tss::TaskStateSegment; +use x86_64::VirtAddr; pub const DOUBLE_FAULT_IST_INDEX: u16 = 0; -lazy_static!{ +lazy_static! { static ref TSS: TaskStateSegment = { let mut tss = TaskStateSegment::new(); tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = { @@ -20,12 +20,18 @@ lazy_static!{ }; } -lazy_static!{ +lazy_static! { static ref GDT: (GlobalDescriptorTable, Selectors) = { let mut gdt = GlobalDescriptorTable::new(); let code_selector = gdt.add_entry(Descriptor::kernel_code_segment()); let tss_selector = gdt.add_entry(Descriptor::tss_segment(&TSS)); - (gdt, Selectors { code_selector, tss_selector }) + ( + gdt, + Selectors { + code_selector, + tss_selector, + }, + ) }; } @@ -42,4 +48,4 @@ pub fn init() { set_cs(GDT.1.code_selector); load_tss(GDT.1.tss_selector); } -} \ No newline at end of file +} diff --git a/src/interrupts.rs b/src/interrupts.rs index 241ae77..fa3f25b 100644 --- a/src/interrupts.rs +++ b/src/interrupts.rs @@ -1,7 +1,7 @@ use lazy_static::lazy_static; use pic8259_simple::ChainedPics; use spin; -use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame}; +use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode}; use crate::gdt; use crate::hlt_loop; @@ -10,18 +10,19 @@ use crate::{print, println}; #[cfg(test)] use crate::{serial_print, serial_println}; -lazy_static!{ +lazy_static! { static ref IDT: InterruptDescriptorTable = { let mut idt = InterruptDescriptorTable::new(); idt.breakpoint.set_handler_fn(breakpoint_handler); unsafe { - idt.double_fault.set_handler_fn(double_fault_handler) + idt.double_fault + .set_handler_fn(double_fault_handler) .set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX); } - idt[InterruptIndex::Timer.as_usize()] - .set_handler_fn(timer_interrupt_handler); - idt[InterruptIndex::Keyboard.as_usize()] - .set_handler_fn(keyboard_interrupt_handler); + idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler); + idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler); + + idt.page_fault.set_handler_fn(page_fault_handler); idt }; @@ -31,42 +32,39 @@ pub fn init_idt() { IDT.load(); } -extern "x86-interrupt" fn breakpoint_handler( - stack_frame: &mut InterruptStackFrame -) { +extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut InterruptStackFrame) { println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame); } extern "x86-interrupt" fn double_fault_handler( - stack_frame: &mut InterruptStackFrame, _error_code: u64 + stack_frame: &mut InterruptStackFrame, + _error_code: u64, ) { println!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame); hlt_loop(); } -extern "x86-interrupt" fn timer_interrupt_handler( - _stack_frame: &mut InterruptStackFrame -) { +extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptStackFrame) { print!("."); unsafe { - PICS.lock().notify_end_of_interrupt(InterruptIndex::Timer.as_u8()); + PICS.lock() + .notify_end_of_interrupt(InterruptIndex::Timer.as_u8()); } } pub const PIC_1_OFFSET: u8 = 32; pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8; -pub static PICS: spin::Mutex = spin::Mutex::new(unsafe { - ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) -}); +pub static PICS: spin::Mutex = + spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) }); extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) { - use x86_64::instructions::port::Port; - use pc_keyboard::{Keyboard, ScancodeSet1, DecodedKey, layouts}; + use pc_keyboard::{layouts, DecodedKey, Keyboard, ScancodeSet1}; use spin::Mutex; + use x86_64::instructions::port::Port; - lazy_static!{ + lazy_static! { static ref KEYBOARD: Mutex> = Mutex::new(Keyboard::new(layouts::Us104Key, ScancodeSet1)); } @@ -90,6 +88,19 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut Interrup } } +extern "x86-interrupt" fn page_fault_handler( + stack_frame: &mut InterruptStackFrame, + error_code: PageFaultErrorCode, +) { + use x86_64::registers::control::Cr2; + + println!("EXCEPTION: PAGE FAULT"); + println!("Accessed Address: {:?}", Cr2::read()); + println!("Error Code: {:?}", error_code); + println!("{:#?}", stack_frame); + hlt_loop(); +} + #[derive(Debug, Clone, Copy)] #[repr(u8)] pub enum InterruptIndex { @@ -113,4 +124,4 @@ fn test_breakpoint_exception() { // invoke a breakpoint exception x86_64::instructions::interrupts::int3(); serial_println!("[ok]"); -} \ No newline at end of file +} diff --git a/src/lib.rs b/src/lib.rs index 98d1dd8..b7c96da 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,10 +7,17 @@ use core::panic::PanicInfo; +#[cfg(test)] +use bootloader::{entry_point, BootInfo}; + +#[cfg(test)] +entry_point!(test_kernel_main); + pub mod gdt; pub mod interrupts; -pub mod serial; pub mod macros; +pub mod memory; +pub mod serial; pub mod vga_buffer; pub fn test_runner(tests: &[&dyn Fn()]) { @@ -30,8 +37,7 @@ pub fn test_panic_handler(info: &PanicInfo) -> ! { /// Entry point for `cargo xtest` #[cfg(test)] -#[no_mangle] -pub extern "C" fn _start() -> ! { +fn test_kernel_main(_boot_info: &'static BootInfo) -> ! { init(); test_main(); hlt_loop(); @@ -70,4 +76,4 @@ pub fn init() { interrupts::init_idt(); unsafe { interrupts::PICS.lock().initialize() }; x86_64::instructions::interrupts::enable(); -} \ No newline at end of file +} diff --git a/src/main.rs b/src/main.rs index 038b33a..3d6760c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,6 +7,7 @@ use core::panic::PanicInfo; use blog_os::println; +use bootloader::{entry_point, BootInfo}; /// This function is called on panic. #[cfg(not(test))] @@ -22,12 +23,28 @@ fn panic(info: &PanicInfo) -> ! { blog_os::test_panic_handler(info) } -#[no_mangle] -pub extern "C" fn _start() -> ! { - println!("Hello World{}", "!"); +entry_point!(kernel_main); +fn kernel_main(boot_info: &'static BootInfo) -> ! { + use blog_os::memory; + use x86_64::{structures::paging::Page, VirtAddr}; + + println!("Hello World{}", "!"); blog_os::init(); + let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset); + let mut mapper = unsafe { memory::init(phys_mem_offset) }; + let mut frame_allocator = + unsafe { memory::BootInfoFrameAllocator::init(&boot_info.memory_map) }; + + let page = Page::containing_address(VirtAddr::new(0xdeadbeef000)); + memory::create_example_mapping(page, &mut mapper, &mut frame_allocator); + + let page_ptr: *mut u64 = page.start_address().as_mut_ptr(); + unsafe { + page_ptr.offset(400).write_volatile(0x_f021_f077_f065_f04e); + } + #[cfg(test)] test_main(); diff --git a/src/memory.rs b/src/memory.rs new file mode 100644 index 0000000..51b4d6e --- /dev/null +++ b/src/memory.rs @@ -0,0 +1,104 @@ +use bootloader::bootinfo::{MemoryMap, MemoryRegionType}; +use x86_64::{ + structures::paging::{ + FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB, + }, + PhysAddr, VirtAddr, +}; + +/// A FrameAllocator that always returns `None`. +pub struct EmptyFrameAllocator; + +unsafe impl FrameAllocator for EmptyFrameAllocator { + fn allocate_frame(&mut self) -> Option { + None + } +} + +pub struct BootInfoFrameAllocator { + memory_map: &'static MemoryMap, + next: usize, +} + +impl BootInfoFrameAllocator { + /// Create a FrameAllocator from the passed memory map. + /// + /// This function is unsafe because the caller must guarantee that the passed + /// meory map is valid. The main requirement is that all frame are marked + /// as `USABLE` in it are really unused. + pub unsafe fn init(memory_map: &'static MemoryMap) -> Self { + BootInfoFrameAllocator { + memory_map, + next: 0, + } + } + + /// Returns an iterator over the usable frames specified in the memory map. + fn usable_frames(&self) -> impl Iterator { + // get usable regions from memory map + let regions = self.memory_map.iter(); + let usable_regions = regions.filter(|r| r.region_type == MemoryRegionType::Usable); + + // map each region to its address range + let addr_ranges = usable_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.step_by(4096)); + + // create `PhysFrame` types from the start addresses + frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr))) + } +} + +unsafe impl FrameAllocator for BootInfoFrameAllocator { + fn allocate_frame(&mut self) -> Option { + let frame = self.usable_frames().nth(self.next); + self.next += 1; + frame + } +} + +/// Initialize a new OffsetPageTable +/// +/// This function is unsafe because the caller must guarantee that the +/// complete physical memory is mapped to virtual memory at the passed +/// `physical_memory_offset`. Also, this function must be only called once +/// to avoid aliasing `&mut` references (which is undefined behavior). +pub unsafe fn init(physical_memory_offset: VirtAddr) -> OffsetPageTable<'static> { + let level_4_table = active_level_4_table(physical_memory_offset); + OffsetPageTable::new(level_4_table, physical_memory_offset) +} + +/// Returns a mutable reference to the active level 4 table. +/// +/// This function is unsafe because the caller must guarantee that the +/// complete physical memory is mapped to virtual memory at the passed +/// `physical_memory_offset`. Also, this function must be only called once +/// to avoid aliasing `&mut` references (which is undefined behavior). +unsafe fn active_level_4_table(physical_memory_offset: VirtAddr) -> &'static mut PageTable { + use x86_64::registers::control::Cr3; + + let (level_4_table_frame, _) = Cr3::read(); + + let phys = level_4_table_frame.start_address(); + let virt = physical_memory_offset + phys.as_u64(); + let page_table_ptr: *mut PageTable = virt.as_mut_ptr(); + + &mut *page_table_ptr +} + +/// Creates an example maping for the given page to frame `0xb8000` +pub fn create_example_mapping( + page: Page, + mapper: &mut OffsetPageTable, + frame_allocator: &mut impl FrameAllocator, +) { + use x86_64::structures::paging::PageTableFlags as Flags; + + let frame = PhysFrame::containing_address(PhysAddr::new(0xb8000)); + let flags = Flags::PRESENT | Flags::WRITABLE; + + let map_to_result = unsafe { mapper.map_to(page, frame, flags, frame_allocator) }; + + map_to_result.expect("map_to failed").flush(); +} diff --git a/tests/basic_boot.rs b/tests/basic_boot.rs index 07dfac4..ef1e286 100644 --- a/tests/basic_boot.rs +++ b/tests/basic_boot.rs @@ -25,4 +25,4 @@ fn test_println() { serial_print!("test_println... "); println!("test_println output"); serial_println!("[ok]"); -} \ No newline at end of file +} diff --git a/tests/should_panic.rs b/tests/should_panic.rs index cdbf6f7..d624bcb 100644 --- a/tests/should_panic.rs +++ b/tests/should_panic.rs @@ -1,14 +1,14 @@ #![no_std] #![no_main] +use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode}; use core::panic::PanicInfo; -use blog_os::{QemuExitCode, exit_qemu, serial_print, serial_println}; #[no_mangle] pub extern "C" fn _start() -> ! { should_fail(); serial_println!("[test did not panic]"); - exit_qemu(QemuExitCode:: Failed); + exit_qemu(QemuExitCode::Failed); loop {} } @@ -22,4 +22,4 @@ fn panic(_info: &PanicInfo) -> ! { serial_println!("[ok]"); exit_qemu(QemuExitCode::Success); loop {} -} \ No newline at end of file +} diff --git a/tests/stack_overflow.rs b/tests/stack_overflow.rs index 638143a..50ddd5c 100644 --- a/tests/stack_overflow.rs +++ b/tests/stack_overflow.rs @@ -22,8 +22,7 @@ lazy_static! { }; } - -use blog_os::{exit_qemu, QemuExitCode, serial_print, serial_println}; +use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode}; #[no_mangle] pub extern "C" fn _start() -> ! {