forked from AbleOS/ableos
111 lines
3.2 KiB
Rust
111 lines
3.2 KiB
Rust
use {
|
|
core::mem::MaybeUninit,
|
|
log::trace,
|
|
x2apic::lapic::{LocalApic, LocalApicBuilder},
|
|
x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode},
|
|
};
|
|
|
|
/// Safety: Using LAPIC or IDT before init() is UB
|
|
/// Using
|
|
static mut LAPIC: LocalApic = unsafe { MaybeUninit::zeroed().assume_init() };
|
|
static mut IDT: InterruptDescriptorTable = unsafe { MaybeUninit::zeroed().assume_init() };
|
|
|
|
#[repr(u8)]
|
|
#[derive(Debug, Eq, Hash, PartialEq)]
|
|
|
|
pub enum Interrupt {
|
|
Timer = 32,
|
|
ApicErr = u8::MAX - 1,
|
|
Spurious = u8::MAX,
|
|
}
|
|
|
|
pub unsafe fn init() {
|
|
trace!("Initializing IDT and LAPIC");
|
|
|
|
// Initialize and load the IDT
|
|
IDT = InterruptDescriptorTable::new();
|
|
IDT.double_fault
|
|
.set_handler_fn(double_fault)
|
|
.set_stack_index(super::gdt::DOUBLE_FAULT_IX);
|
|
IDT.page_fault.set_handler_fn(page_fault);
|
|
|
|
IDT[Interrupt::ApicErr as u8].set_handler_fn(apic_err);
|
|
IDT[Interrupt::Spurious as u8].set_handler_fn(spurious);
|
|
IDT[Interrupt::Timer as u8].set_handler_fn(timer);
|
|
|
|
IDT.load();
|
|
|
|
LAPIC = LocalApicBuilder::new()
|
|
.timer_vector(Interrupt::Timer as usize)
|
|
.error_vector(Interrupt::ApicErr as usize)
|
|
.spurious_vector(Interrupt::Spurious as usize)
|
|
.set_xapic_base(
|
|
x2apic::lapic::xapic_base()
|
|
+ super::memory::HHDM_OFFSET.load(core::sync::atomic::Ordering::Relaxed),
|
|
)
|
|
.build()
|
|
.expect("Failed to setup Local APIC");
|
|
LAPIC.enable();
|
|
|
|
x86_64::instructions::interrupts::enable();
|
|
}
|
|
|
|
extern "x86-interrupt" fn double_fault(stack_frame: InterruptStackFrame, error_code: u64) -> ! {
|
|
panic!("Double fault: error code {error_code} \n{stack_frame:#?}")
|
|
}
|
|
|
|
extern "x86-interrupt" fn page_fault(
|
|
stack_frame: InterruptStackFrame,
|
|
error_code: PageFaultErrorCode,
|
|
) {
|
|
panic!("Page fault ({error_code:?}): {stack_frame:?}")
|
|
}
|
|
|
|
extern "x86-interrupt" fn timer(_isf: InterruptStackFrame) {
|
|
// interrupt(Interrupt::Timer);
|
|
|
|
unsafe {
|
|
LAPIC.end_of_interrupt();
|
|
}
|
|
}
|
|
|
|
extern "x86-interrupt" fn apic_err(_: InterruptStackFrame) {
|
|
interrupt(Interrupt::ApicErr);
|
|
|
|
panic!("Internal APIC error");
|
|
}
|
|
|
|
extern "x86-interrupt" fn spurious(_: InterruptStackFrame) {
|
|
interrupt(Interrupt::Spurious);
|
|
|
|
unsafe {
|
|
LAPIC.end_of_interrupt();
|
|
}
|
|
}
|
|
|
|
fn interrupt(interrupt_type: Interrupt) {
|
|
use crate::arch::INTERRUPT_LIST;
|
|
let il = INTERRUPT_LIST.lock();
|
|
let val = il.list.get(&interrupt_type).unwrap();
|
|
|
|
use crate::holeybytes::kernel_services::service_definition_service::sds_search_service;
|
|
let buffer = sds_search_service(val);
|
|
if buffer != 0 {
|
|
use {crate::kmain::IPC_BUFFERS, alloc::vec::Vec};
|
|
let mut buffs = IPC_BUFFERS.lock();
|
|
match buffs.get_mut(&buffer) {
|
|
Some(buff) => {
|
|
let mut msg_vec = Vec::new();
|
|
msg_vec.push(0xFF);
|
|
buff.push(msg_vec.to_vec());
|
|
log::debug!("Sent Message {:?} to Buffer({})", msg_vec, buffer);
|
|
}
|
|
None => {
|
|
log::error!("Access of non-existent buffer {}", buffer)
|
|
}
|
|
}
|
|
|
|
// log::info!("{}", buffer);
|
|
}
|
|
}
|