wip

hal-x86_64/src/cpu/smp.rs

@@ -2,13 +2,16 @@ use crate::{
     control_regs::{Cr0, Cr4},
     cpu::{
         msr::{Efer, Msr},
-        topology, Ring,
+        topology::Topology,
+        Ring,
     },
     segment,
 };
 use core::arch::global_asm;
 use mycelium_util::bits;
-pub fn bringup() -> Result<(), ()> {
+
+#[tracing::instrument(name = "smp::bringup", skip(topology))]
+pub fn bringup(topology: &Topology) -> Result<(), &'static str> {
     unsafe {
         tracing::info!(
             "AP trampoline: {:p} .. {:p}",

hal-x86_64/src/cpu/topology.rs

@@ -8,8 +8,9 @@ pub type Id = usize;
 
 #[derive(Debug)]
 pub struct Topology {
-    pub(crate) boot_processor: Processor,
-    pub(crate) application_processors: Vec<Processor>,
+    pub boot_processor: Processor,
+    pub application_processors: Vec<Processor>,
+    _noconstruct: (),
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -124,6 +125,7 @@ impl Topology {
         Ok(Self {
             application_processors: aps,
             boot_processor: bsp,
+            _noconstruct: (),
         })
     }
 

hal-x86_64/src/interrupt.rs

@@ -143,7 +143,7 @@ impl Controller {
     }
 
     pub fn enable_hardware_interrupts(
-        acpi: Option<&acpi::InterruptModel>,
+        interrupt_model: Option<&acpi::InterruptModel>,
         frame_alloc: &impl hal_core::mem::page::Alloc<mm::size::Size4Kb>,
     ) -> &'static Self {
         let mut pics = pic::CascadedPic::new();
@@ -159,7 +159,7 @@ impl Controller {
             pics.set_irq_address(Idt::PIC_BIG_START as u8, Idt::PIC_LITTLE_START as u8);
         }
 
-        let model = match acpi {
+        let model = match interrupt_model {
             Some(acpi::InterruptModel::Apic(apic_info)) => {
                 tracing::info!("detected APIC interrupt model");
 

src/arch/x86_64.rs

@@ -8,6 +8,7 @@ pub use hal_x86_64::{
     cpu::{entropy::seed_rng, local::LocalKey, wait_for_interrupt},
     mm, NAME,
 };
+use mycelium_util::sync::spin::Mutex;
 
 mod acpi;
 mod boot;
@@ -60,6 +61,8 @@ pub fn arch_entry(info: &'static mut bootloader_api::BootInfo) -> ! {
     crate::kernel_start(boot_info, archinfo);
 }
 
+static TOPOLOGY: Mutex<Option<cpu::Topology>> = Mutex::new(None);
+
 pub fn init(_info: &impl BootInfo, archinfo: &ArchInfo) {
     pci::init_pci();
 
@@ -80,6 +83,15 @@ pub fn init(_info: &impl BootInfo, archinfo: &ArchInfo) {
 
     topo.init_boot_processor(&mut segmentation::GDT.lock());
     tracing::info!("initialized boot processor");
+
+    tracing::info!("starting application processors");
+    match hal_x86_64::cpu::smp::bringup(&topo) {
+        Ok(_) => tracing::info!("all application processors started"),
+        Err(error) => tracing::error!(%error, "failed to start application processors"),
+    }
+
+    // store the topology for later
+    *TOPOLOGY.lock() = Some(topo);
 }
 
 fn init_acpi(rsdp_addr: PAddr) -> Result<cpu::Topology, acpi::AcpiError> {
@@ -88,6 +100,8 @@ fn init_acpi(rsdp_addr: PAddr) -> Result<cpu::Topology, acpi::AcpiError> {
     let platform = tables.platform_info()?;
     tracing::debug!("found ACPI platform info");
 
+    tracing::info!(?platform.power_profile);
+
     // enable hardware interrupts
     interrupt::enable_hardware_interrupts(Some(&platform.interrupt_model));
 

src/arch/x86_64/acpi.rs

@@ -19,53 +19,6 @@ pub(super) fn acpi_tables(
     Ok(tables)
 }
 
-#[tracing::instrument(err, skip(platform))]
-pub fn bringup_smp(platform: &acpi::PlatformInfo) -> Result<(), Error> {
-    use acpi::platform::{self, interrupt::InterruptModel};
-
-    tracing::info!(?platform.power_profile);
-
-    let apic = match platform.interrupt_model {
-        acpi::InterruptModel::Apic(ref apic) => {
-            tracing::info!("APIC interrupt model detected");
-            apic
-        }
-        InterruptModel::Unknown => {
-            return Err(Error::Other(
-                "MADT does not indicate support for APIC interrupt model!",
-            ));
-        }
-        ref model => {
-            tracing::warn!(?model, "unknown interrupt model detected");
-            return Err(Error::Other(
-                "MADT does not indicate support for APIC interrupt model!",
-            ));
-        }
-    };
-
-    tracing::debug!(?apic);
-
-    let platform::ProcessorInfo {
-        ref application_processors,
-        ref boot_processor,
-    } = platform
-        .processor_info
-        .as_ref()
-        .ok_or(Error::Other("no processor information found in MADT!"))?;
-    tracing::info!("boot processor seems normalish");
-    tracing::debug!(?boot_processor);
-    tracing::info!(
-        "found {} application processors",
-        application_processors.len()
-    );
-    tracing::debug!(?application_processors);
-    hal_x86_64::cpu::smp::bringup().unwrap();
-
-    tracing::warn!("not starting app processors (SMP support isn't done yet)");
-
-    Ok(())
-}
-
 #[derive(Clone)]
 pub(super) struct IdentityMappedAcpiHandler;
 

src/arch/x86_64/interrupt.rs

@@ -13,9 +13,9 @@ pub fn enable_exceptions() {
     tracing::info!("IDT initialized!");
 }
 
-#[tracing::instrument(skip(acpi))]
-pub fn enable_hardware_interrupts(acpi: Option<&acpi::InterruptModel>) {
-    let controller = Controller::enable_hardware_interrupts(acpi, &crate::ALLOC);
+#[tracing::instrument(skip(interrupt_model))]
+pub fn enable_hardware_interrupts(interrupt_model: Option<&acpi::InterruptModel>) {
+    let controller = Controller::enable_hardware_interrupts(interrupt_model, &crate::ALLOC);
     controller
         .start_periodic_timer(TIMER_INTERVAL)
         .expect("10ms should be a reasonable interval for the PIT or local APIC timer...");