This commit is contained in:
Timothy Warren 2019-10-01 13:53:03 -04:00
parent 29dab9efff
commit 2c3728734e
9 changed files with 185 additions and 42 deletions

View File

@ -7,7 +7,7 @@ edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
bootloader = "0.8.1" bootloader = { version = "0.8.1", features = ["map_physical_memory"]}
pc-keyboard = "0.3.1" pc-keyboard = "0.3.1"
pic8259_simple = "0.1.1" pic8259_simple = "0.1.1"
spin = "0.5.2" spin = "0.5.2"

View File

@ -1,11 +1,11 @@
use lazy_static::lazy_static; use lazy_static::lazy_static;
use x86_64::VirtAddr; use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector};
use x86_64::structures::gdt::{GlobalDescriptorTable, Descriptor, SegmentSelector};
use x86_64::structures::tss::TaskStateSegment; use x86_64::structures::tss::TaskStateSegment;
use x86_64::VirtAddr;
pub const DOUBLE_FAULT_IST_INDEX: u16 = 0; pub const DOUBLE_FAULT_IST_INDEX: u16 = 0;
lazy_static!{ lazy_static! {
static ref TSS: TaskStateSegment = { static ref TSS: TaskStateSegment = {
let mut tss = TaskStateSegment::new(); let mut tss = TaskStateSegment::new();
tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = { 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) = { static ref GDT: (GlobalDescriptorTable, Selectors) = {
let mut gdt = GlobalDescriptorTable::new(); let mut gdt = GlobalDescriptorTable::new();
let code_selector = gdt.add_entry(Descriptor::kernel_code_segment()); let code_selector = gdt.add_entry(Descriptor::kernel_code_segment());
let tss_selector = gdt.add_entry(Descriptor::tss_segment(&TSS)); 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); set_cs(GDT.1.code_selector);
load_tss(GDT.1.tss_selector); load_tss(GDT.1.tss_selector);
} }
} }

View File

@ -1,7 +1,7 @@
use lazy_static::lazy_static; use lazy_static::lazy_static;
use pic8259_simple::ChainedPics; use pic8259_simple::ChainedPics;
use spin; use spin;
use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame}; use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
use crate::gdt; use crate::gdt;
use crate::hlt_loop; use crate::hlt_loop;
@ -10,18 +10,19 @@ use crate::{print, println};
#[cfg(test)] #[cfg(test)]
use crate::{serial_print, serial_println}; use crate::{serial_print, serial_println};
lazy_static!{ lazy_static! {
static ref IDT: InterruptDescriptorTable = { static ref IDT: InterruptDescriptorTable = {
let mut idt = InterruptDescriptorTable::new(); let mut idt = InterruptDescriptorTable::new();
idt.breakpoint.set_handler_fn(breakpoint_handler); idt.breakpoint.set_handler_fn(breakpoint_handler);
unsafe { 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); .set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX);
} }
idt[InterruptIndex::Timer.as_usize()] idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
.set_handler_fn(timer_interrupt_handler); idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
idt[InterruptIndex::Keyboard.as_usize()]
.set_handler_fn(keyboard_interrupt_handler); idt.page_fault.set_handler_fn(page_fault_handler);
idt idt
}; };
@ -31,42 +32,39 @@ pub fn init_idt() {
IDT.load(); IDT.load();
} }
extern "x86-interrupt" fn breakpoint_handler( extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut InterruptStackFrame) {
stack_frame: &mut InterruptStackFrame
) {
println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame); println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame);
} }
extern "x86-interrupt" fn double_fault_handler( 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); println!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
hlt_loop(); hlt_loop();
} }
extern "x86-interrupt" fn timer_interrupt_handler( extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
_stack_frame: &mut InterruptStackFrame
) {
print!("."); print!(".");
unsafe { 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_1_OFFSET: u8 = 32;
pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8; pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
pub static PICS: spin::Mutex<ChainedPics> = spin::Mutex::new(unsafe { pub static PICS: spin::Mutex<ChainedPics> =
ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
});
extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) { extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
use x86_64::instructions::port::Port; use pc_keyboard::{layouts, DecodedKey, Keyboard, ScancodeSet1};
use pc_keyboard::{Keyboard, ScancodeSet1, DecodedKey, layouts};
use spin::Mutex; use spin::Mutex;
use x86_64::instructions::port::Port;
lazy_static!{ lazy_static! {
static ref KEYBOARD: Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>> = static ref KEYBOARD: Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>> =
Mutex::new(Keyboard::new(layouts::Us104Key, ScancodeSet1)); 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)] #[derive(Debug, Clone, Copy)]
#[repr(u8)] #[repr(u8)]
pub enum InterruptIndex { pub enum InterruptIndex {
@ -113,4 +124,4 @@ fn test_breakpoint_exception() {
// invoke a breakpoint exception // invoke a breakpoint exception
x86_64::instructions::interrupts::int3(); x86_64::instructions::interrupts::int3();
serial_println!("[ok]"); serial_println!("[ok]");
} }

View File

@ -7,10 +7,17 @@
use core::panic::PanicInfo; use core::panic::PanicInfo;
#[cfg(test)]
use bootloader::{entry_point, BootInfo};
#[cfg(test)]
entry_point!(test_kernel_main);
pub mod gdt; pub mod gdt;
pub mod interrupts; pub mod interrupts;
pub mod serial;
pub mod macros; pub mod macros;
pub mod memory;
pub mod serial;
pub mod vga_buffer; pub mod vga_buffer;
pub fn test_runner(tests: &[&dyn Fn()]) { pub fn test_runner(tests: &[&dyn Fn()]) {
@ -30,8 +37,7 @@ pub fn test_panic_handler(info: &PanicInfo) -> ! {
/// Entry point for `cargo xtest` /// Entry point for `cargo xtest`
#[cfg(test)] #[cfg(test)]
#[no_mangle] fn test_kernel_main(_boot_info: &'static BootInfo) -> ! {
pub extern "C" fn _start() -> ! {
init(); init();
test_main(); test_main();
hlt_loop(); hlt_loop();
@ -70,4 +76,4 @@ pub fn init() {
interrupts::init_idt(); interrupts::init_idt();
unsafe { interrupts::PICS.lock().initialize() }; unsafe { interrupts::PICS.lock().initialize() };
x86_64::instructions::interrupts::enable(); x86_64::instructions::interrupts::enable();
} }

View File

@ -7,6 +7,7 @@
use core::panic::PanicInfo; use core::panic::PanicInfo;
use blog_os::println; use blog_os::println;
use bootloader::{entry_point, BootInfo};
/// This function is called on panic. /// This function is called on panic.
#[cfg(not(test))] #[cfg(not(test))]
@ -22,12 +23,28 @@ fn panic(info: &PanicInfo) -> ! {
blog_os::test_panic_handler(info) blog_os::test_panic_handler(info)
} }
#[no_mangle] entry_point!(kernel_main);
pub extern "C" fn _start() -> ! {
println!("Hello World{}", "!");
fn kernel_main(boot_info: &'static BootInfo) -> ! {
use blog_os::memory;
use x86_64::{structures::paging::Page, VirtAddr};
println!("Hello World{}", "!");
blog_os::init(); 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)] #[cfg(test)]
test_main(); test_main();

104
src/memory.rs Normal file
View File

@ -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<Size4KiB> for EmptyFrameAllocator {
fn allocate_frame(&mut self) -> Option<PhysFrame> {
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<Item = PhysFrame> {
// 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<Size4KiB> for BootInfoFrameAllocator {
fn allocate_frame(&mut self) -> Option<PhysFrame> {
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<Size4KiB>,
) {
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();
}

View File

@ -25,4 +25,4 @@ fn test_println() {
serial_print!("test_println... "); serial_print!("test_println... ");
println!("test_println output"); println!("test_println output");
serial_println!("[ok]"); serial_println!("[ok]");
} }

View File

@ -1,14 +1,14 @@
#![no_std] #![no_std]
#![no_main] #![no_main]
use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode};
use core::panic::PanicInfo; use core::panic::PanicInfo;
use blog_os::{QemuExitCode, exit_qemu, serial_print, serial_println};
#[no_mangle] #[no_mangle]
pub extern "C" fn _start() -> ! { pub extern "C" fn _start() -> ! {
should_fail(); should_fail();
serial_println!("[test did not panic]"); serial_println!("[test did not panic]");
exit_qemu(QemuExitCode:: Failed); exit_qemu(QemuExitCode::Failed);
loop {} loop {}
} }
@ -22,4 +22,4 @@ fn panic(_info: &PanicInfo) -> ! {
serial_println!("[ok]"); serial_println!("[ok]");
exit_qemu(QemuExitCode::Success); exit_qemu(QemuExitCode::Success);
loop {} loop {}
} }

View File

@ -22,8 +22,7 @@ lazy_static! {
}; };
} }
use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode};
use blog_os::{exit_qemu, QemuExitCode, serial_print, serial_println};
#[no_mangle] #[no_mangle]
pub extern "C" fn _start() -> ! { pub extern "C" fn _start() -> ! {