LowLevelDevs/FoundryOS
1
1
Fork 1
Code Issues 2 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Megacommit to move some memory code into kernel crate

Browse Source
This commit is contained in:
Jacob Hinchliffe
2025-02-28 02:13:50 +00:00
parent 192100be7a
commit 92fe618a99
16 changed files with 106 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel/src/arch/x86_64/apic/mod.rs
+22 -24
View File
@@ -1,19 +1,14 @@
#![allow(unused)] // TODO: Remove this when ready.
use core::arch::x86_64::__cpuid;
use libk::drivers::memory::FoundryOSFrameAllocator;
use spin::Lazy;
use x86_64::{
PhysAddr, VirtAddr,
instructions::port::Port,
registers::model_specific::Msr,
structures::paging::{
FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB, Translate,
},
structures::paging::{Mapper, Size4KiB},
};
use crate::serial_print;
use super::{cpu::model_specific_registers::*, memmap::PHYSICAL_MEMORY_OFFSET};
use super::{cpu::model_specific_registers::*, mem::memmap::PHYSICAL_MEMORY_OFFSET};
const IA32_APIC_BASE_MSR: u32 = 0x1b;
const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
@@ -68,27 +63,30 @@ pub fn check_apic() -> bool {
#[inline(always)]
unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
let phys = phys.as_u64();
match phys.checked_add(*PHYSICAL_MEMORY_OFFSET) {
Some(virt) => {
serial_print!("map worked!");
VirtAddr::new(virt)
}
None => {
phys.checked_add(*PHYSICAL_MEMORY_OFFSET).map_or_else(
|| {
serial_print!("THIS IS A PROBLEM");
panic!("overflow")
}
}
},
|virt| {
serial_print!("map worked!");
VirtAddr::new(virt)
},
)
}
pub fn enable_apic(
mapper: &mut impl Mapper<Size4KiB>,
frame_allocator: &mut FoundryOSFrameAllocator,
_mapper: &mut impl Mapper<Size4KiB>,
// TODO: Fix this function.
// frame_allocator: &mut FoundryOSFrameAllocator,
) {
let apic_phys_addr = get_apic_base();
set_apic_base_enable(apic_phys_addr);
unimplemented!();
// let apic_phys_addr = get_apic_base();
// set_apic_base_enable(apic_phys_addr);
// map virt address of apic
let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
// let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
// let page: Page<Size4KiB> = Page::containing_address(apic_virt);
// let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
// let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
@@ -103,11 +101,11 @@ pub fn enable_apic(
// // FIXME: this causes a page fault
// // TODO: map to virtual memor
let reg = read_apic_register(&apic_virt, 0xF0);
// let reg = read_apic_register(&apic_virt, 0xF0);
serial_print!("ok2");
// serial_print!("ok2");
write_apic_register(&apic_virt, 0xF0, reg | 0x100);
// write_apic_register(&apic_virt, 0xF0, reg | 0x100);
}
pub struct Apic {}
kernel/src/arch/x86_64/cpu.rs
+4 -4
View File
@@ -3,11 +3,11 @@ pub mod model_specific_registers {
use spin::Lazy;
use x86_64::registers::model_specific::Msr;
const CPUID_FLAG_MSR: u32 = 1 << 5;
static EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
const _CPUID_FLAG_MSR: u32 = 1 << 5;
static _EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
pub fn cpu_has_msr() -> bool {
*EDX & CPUID_FLAG_MSR != 0
pub fn _cpu_has_msr() -> bool {
*_EDX & _CPUID_FLAG_MSR != 0
}
pub fn cpu_get_msr(msr: u32, value: &mut u64) {
kernel/src/arch/x86_64/interrupts.rs
+21 -23
View File
@@ -1,14 +1,10 @@
use libk::drivers::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
// use libk::drivers::mem::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
use libk::prelude::*;
use pic8259::ChainedPics;
use x86_64::registers::control::Cr2;
use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
use x86_64::structures::paging::mapper::MapperFlushAll;
use x86_64::structures::paging::{FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB};
use spin::{Lazy, Mutex};
use super::apic::enable_apic;
use super::gdt;
static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
@@ -64,6 +60,7 @@ pub fn enable_pic() {
}
}
#[expect(unused)]
pub fn disable_pic() {
unsafe {
PICS.lock().disable();
@@ -125,31 +122,32 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
}
extern "x86-interrupt" fn page_fault_handler(
stack_frame: InterruptStackFrame,
error_code: PageFaultErrorCode,
_stack_frame: InterruptStackFrame,
_error_code: PageFaultErrorCode,
) {
todo!("Get this working again.")
// serial_println!("Exception: Page Fault");
// serial_println!("Accessed Address: {:?}", Cr2::read());
// serial_println!("Error Code: {:?}", error_code);
// serial_println!("{:#?}", stack_frame);
if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
let mut f = frame_allocator.lock();
// if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
// let mut f = frame_allocator.lock();
let frame = f.allocate_frame().unwrap();
let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
let page: Page<Size4KiB> = Page::containing_address(Cr2::read().unwrap());
// let frame = f.allocate_frame().unwrap();
// let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
// let page: Page<Size4KiB> = Page::containing_address(Cr2::read().unwrap());
unsafe {
let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
// unsafe {
// let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
match mapper.map_to(page, frame, flags, &mut *f) {
Ok(_) => {}
Err(why) => panic!("failed to map page: {:?}", why),
}
}
MapperFlushAll::new().flush_all();
} else {
panic!("failed to get frame allocator");
}
// match mapper.map_to(page, frame, flags, &mut *f) {
// Ok(_) => {}
// Err(why) => panic!("failed to map page: {:?}", why),
// }
// }
// MapperFlushAll::new().flush_all();
// } else {
// panic!("failed to get frame allocator");
// }
}
kernel/src/arch/x86_64/memmap.rs → kernel/src/arch/x86_64/mem/memmap.rs
View File
kernel/src/arch/x86_64/mem/mod.rs
+2
View File
@@ -0,0 +1,2 @@
pub mod memmap;
pub mod pmm;
kernel/src/arch/x86_64/mem/pmm.rs
View File
kernel/src/arch/x86_64/mod.rs
+3 -7
View File
@@ -1,9 +1,5 @@
pub mod gdt;
pub mod interrupts;
pub mod memmap;
pub mod apic;
pub mod cpu;
pub mod gdt;
pub mod interrupts;
pub mod mem;
kernel/src/lib.rs
+12 -13
View File
@@ -13,16 +13,14 @@
extern crate alloc;
use arch::x86_64::apic::enable_apic;
// use arch::x86_64::apic::enable_apic;
use core::arch::asm;
use libk::drivers::memory;
// use libk::drivers::mem::pmm;
use limine::BaseRevision;
use libk::drivers::kalloc::allocator::init_heap;
// use libk::drivers::alloc::allocator::init_heap;
use libk::prelude::*;
use x86_64::VirtAddr;
mod arch;
/// Sets the base revision to the latest revision supported by the crate.
@@ -58,9 +56,9 @@ pub fn boot() -> Result<(), &'static str> {
return Err("base revision not supported");
}
use arch::x86_64::{gdt, interrupts, memmap};
use arch::x86_64::{gdt, interrupts, mem::memmap};
let memory_map = memmap::get_memory_map();
let _memory_map = memmap::get_memory_map();
print_log!(" Initialising Serial... ");
if libk::drivers::io::serial::init().is_err() {
@@ -78,18 +76,19 @@ pub fn boot() -> Result<(), &'static str> {
println_log!("[Success]");
print_log!(" Initialising Memory Subsystem... ");
let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
let mut l4_table = memory::init_page_table(physical_memory_offset);
// let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
// pmm::init_page_table(physical_memory_offset);
println_log!("[Success]");
print_log!(" Setting Up Page Table... ");
memory::init_frame_allocator(memory_map);
// pmm::init_frame_allocator(memory_map);
println_log!("[Success]");
print_log!(" Initialising Heap... ");
if init_heap().is_err() {
return Err("Failed to initialise heap: error");
}
// TODO: Reenable the heap.
// if init_heap().is_err() {
// return Err("Failed to initialise heap: error");
// }
println_log!("[Success]");
print_log!(" Enabling PICs... ");