True SMP Multitasking

Add syscall fields to `PerCoreData`. Why it matters: Per-core syscall save slots are the prerequisite for letting more than one core enter the syscall path safely at the same time. Focus on `PerCoreData` and `offsets::SYSCALL_STACK_TOP` in `kernel/src/smp/mod.rs` while you trace the snippet.

/// Per-core state block.
///
/// Each core has one of these, initialized during BSP init or AP bootstrap.
/// The `gs_base` MSR points to this struct so that `per_core()` can retrieve
/// it in O(1) without MMIO.
#[repr(C)]
pub struct PerCoreData {
    /// Self-pointer at offset 0 — reserved for future `gs:[0]` access.
    /// Currently unused: `per_core()` reads `IA32_GS_BASE` via `rdmsr`.
    self_ptr: *const PerCoreData,
    /// Logical core index (0 = BSP, 1..n = APs in MADT order).
    pub core_id: u8,
    /// LAPIC ID from the MADT.
    pub apic_id: u8,
    /// Set to `true` once this core has completed initialization.
    pub is_online: AtomicBool,
    /// Pointer to this core's TSS (for runtime RSP0 updates).
    tss_ptr: *mut TaskStateSegment,
    /// Pointer to this core's GDT (pre-allocated on BSP, loaded on AP).
    gdt_ptr: *const GlobalDescriptorTable,
    /// Segment selectors for this core's GDT.
    gdt_code: SegmentSelector,
    gdt_data: SegmentSelector,
    gdt_tss: SegmentSelector,

View on GitHub

Rewrite `syscall_entry` assembly to use `gs_base` offsets. Why it matters: This is the core replacement step that swaps the earlier shared syscall statics for per-core register save slots. Focus on `syscall_entry` and `gs_base` in `kernel/src/arch/x86_64/syscall.rs` while you trace the snippet.

        fn syscall_entry();

View on GitHub

Remove BSP-only dispatch guard. Why it matters: This is the Phase 35 scheduler pivot that replaces the earlier Phase 25 BSP-only dispatch rule with all cores participating in task selection. Focus on `pick_next` and `Ready` in `kernel/src/task/scheduler.rs` while you trace the snippet.

    /// Pick the next task to run on the given core.
    ///
    /// First checks the per-core run queue for an O(1) dequeue. Falls back
    /// to a global round-robin scan if the local queue is empty (handles
    /// tasks that haven't been assigned to a queue yet). Finally, falls back
    /// to this core's idle task.
    fn pick_next(&mut self, core_id: u8) -> Option<(u64, usize)> {
        let core_bit = 1u64 << core_id;

        // Scan local run queue: find the highest-priority (lowest numeric) Ready
        // task in a single pass, then remove only that entry. No heap allocation.
        if let Some(data) = crate::smp::get_core_data(core_id) {
            let mut q = data.run_queue.lock();
            let mut best_pos: Option<usize> = None;
            let mut best_prio: u8 = u8::MAX;

            // First pass: discard stale entries from the front while scanning.
            let mut i = 0;
            while i < q.len() {
                let idx = q[i];
                if idx >= self.tasks.len()
                    || self.tasks[idx].state != TaskState::Ready
                    || self.idle_tasks.contains(&Some(idx))
                    || self.tasks[idx].affinity_mask & core_bit == 0

View on GitHub