yggdrasil/arch/x86_64/src/lib.rs

#![no_std]
#![feature(effects, strict_provenance, asm_const)]

extern crate alloc;

use alloc::vec::Vec;
use device_api::interrupt::{LocalInterruptController, MessageInterruptController};
use kernel_arch_interface::{cpu::IpiQueue, util::OneTimeInit, Architecture};
use libk_mm_interface::address::PhysicalAddress;
use registers::MSR_IA32_KERNEL_GS_BASE;
use tock_registers::interfaces::Writeable;

pub mod context;
pub mod mem;
pub mod registers;

pub use context::TaskContextImpl;
pub use mem::{process::ProcessAddressSpaceImpl, KernelTableManagerImpl};

pub struct ArchitectureImpl;

pub const KERNEL_VIRT_OFFSET: usize = 0xFFFFFF8000000000;

pub trait LocalApicInterface: LocalInterruptController + MessageInterruptController {
    /// Performs an application processor startup sequence.
    ///
    /// # Safety
    ///
    /// Unsafe: only meant to be called by the BSP during SMP init.
    unsafe fn wakeup_cpu(&self, apic_id: u32, bootstrap_code: PhysicalAddress);

    /// Signals local APIC that we've handled the IRQ
    fn clear_interrupt(&self);
}

#[repr(C, align(0x10))]
pub struct PerCpuData {
    // 0x00
    pub this: *mut Self,
    // 0x08, used in assembly
    pub tss_address: usize,
    // 0x10, used in assembly
    pub tmp_address: usize,

    pub local_apic: &'static dyn LocalApicInterface,
}

impl PerCpuData {
    pub fn local_apic(&self) -> &'static dyn LocalApicInterface {
        self.local_apic
    }
}

static IPI_QUEUES: OneTimeInit<Vec<IpiQueue<ArchitectureImpl>>> = OneTimeInit::new();

impl ArchitectureImpl {
    fn local_cpu_data() -> Option<&'static mut PerCpuData> {
        unsafe { (Self::local_cpu() as *mut PerCpuData).as_mut() }
    }
}

impl Architecture for ArchitectureImpl {
    type PerCpuData = PerCpuData;

    unsafe fn set_local_cpu(cpu: *mut ()) {
        MSR_IA32_KERNEL_GS_BASE.set(cpu as u64);
        core::arch::asm!("wbinvd; swapgs");
    }

    fn local_cpu() -> *mut () {
        let mut addr: u64;
        unsafe {
            core::arch::asm!("movq %gs:(0), {0}", out(reg) addr, options(att_syntax));
        }
        addr as _
    }

    unsafe fn init_ipi_queues(queues: Vec<IpiQueue<Self>>) {
        IPI_QUEUES.init(queues);
    }

    fn interrupt_mask() -> bool {
        let mut flags: u64;
        unsafe {
            core::arch::asm!("pushfq; pop {0}", out(reg) flags, options(att_syntax));
        }
        // If IF is zero, interrupts are disabled (masked)
        flags & (1 << 9) == 0
    }

    unsafe fn set_interrupt_mask(mask: bool) -> bool {
        let old = Self::interrupt_mask();
        if mask {
            core::arch::asm!("cli");
        } else {
            core::arch::asm!("sti");
        }
        old
    }

    #[inline]
    fn wait_for_interrupt() {
        unsafe {
            core::arch::asm!("hlt");
        }
    }

    fn local_interrupt_controller() -> &'static dyn LocalInterruptController {
        let local = Self::local_cpu_data().unwrap();
        local.local_apic
    }

    fn message_interrupt_controller() -> &'static dyn MessageInterruptController {
        let local = Self::local_cpu_data().unwrap();
        local.local_apic
    }
}