smp.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2026 Christian Spoo
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

 
#ifndef _MINIOS_ARCH_X86_64_SMP_H_
#define _MINIOS_ARCH_X86_64_SMP_H_
 
#include <miniOS/types.h>
 
/* Maximum CPUs this kernel supports. Override at compile time with
   -DMAX_CPUS=N. Sizes all per-CPU arrays. */
#ifndef MAX_CPUS
#define MAX_CPUS 8
#endif
 
/* Number of CPUs found by acpi_find_madt(). Includes BSP (cpu_id 0). */
extern uint32_t smp_cpu_count;
 
/* LAPIC IDs of all detected CPUs, indexed 0..smp_cpu_count-1.
   Index 0 is always the BSP (the CPU running kernel_main). */
extern uint8_t  smp_lapic_ids[MAX_CPUS];
 
/* ------------------------------------------------------------------ */
/*  Per-CPU state (cpu_t)                                              */
/* ------------------------------------------------------------------ */
 
/* Forward declare thread struct (defined in sched.h) */
struct thread;

typedef struct cpu_t {
    struct cpu_t   *self;        /* gs:0 — self pointer for cpu_local() */
    uint32_t        cpu_id;      /* logical CPU index (0 = BSP) */
    uint32_t        lapic_id;    /* hardware LAPIC ID from MADT */
    struct thread  *idle_thread; /* per-CPU idle thread */
    uint8_t        *kstack_base; /* base of this CPU's boot/idle kernel stack */
    /* Per-CPU run queue.
       Circular singly-linked list via thread->next.
       idle_thread is always in the queue as the sentinel node.
       queue_depth counts only non-idle RUNNABLE/BLOCKED threads. */
    struct thread  *run_queue_head;  /* first thread in round-robin queue */
    struct thread  *run_queue_tail;  /* last thread (tail->next == head) */
    uint32_t        queue_depth;     /* count of non-idle threads on this CPU */
    struct thread  *current_thread;  /* thread currently running on this CPU — gs:56 */
    uint64_t        kstack_top;      /* per-CPU kernel stack top for SYSCALL/TSS RSP0 — gs:64 */
    uint64_t        user_rsp_scratch;/* per-CPU scratch: user RSP at SYSCALL entry — gs:72 */
    /* PML4 physical address of an exited thread's address space, freed by
     * sched_schedule() right after THIS CPU's own CR3 has moved off of it —
     * never by sched_exit_current() itself, which runs with that same PML4
     * still loaded in CR3. Freeing it there would return its physical frames
     * (PML4 itself and everything beneath it) to the pool while this CPU is
     * still translating every memory access through them; another CPU's
     * concurrent pmm_alloc_frame() can then hand one of those frames out and
     * zero/overwrite it (e.g. vmm_new_address_space()'s memset for a new,
     * unrelated process), corrupting this CPU's live page tables out from
     * under it. 0 = nothing pending. */
    uint64_t        pending_free_pml4;
} cpu_t;
 
/* Global array of cpu_t, indexed 0..smp_cpu_count-1.
   Index 0 = BSP. Static allocation, sized by MAX_CPUS. */
extern cpu_t g_cpus[MAX_CPUS];
 
/* cpu_local() — return pointer to the current CPU's cpu_t.
   Reads gs:0 (the self-pointer installed by per_cpu_init).
   Works without explicit cpu_id because GS.base = &g_cpus[cpu_id].
   Usage: cpu_t *cpu = cpu_local(); */
static inline cpu_t *cpu_local(void) {
    cpu_t *p;
    __asm__ volatile("mov %%gs:0, %0" : "=r"(p) :: "memory");
    return p;
}

void cpu_enable_sse(void);

void per_cpu_init(uint32_t cpu_id);
 
/* ------------------------------------------------------------------ */
/*  ACPI / SMP boot API                                                */
/* ------------------------------------------------------------------ */

void acpi_find_madt(uint64_t mb_info_phys);

void smp_boot_aps(void);
 
/* ------------------------------------------------------------------ */
/*  SMP rendezvous barrier                                            */
/* ------------------------------------------------------------------ */
 
/* AP rendezvous barrier counter.
   Each AP atomically increments this when its per-CPU init is complete.
   BSP waits until smp_aps_ready == smp_cpu_count - 1 (all APs checked in). */
extern volatile uint32_t smp_aps_ready;

void per_cpu_update_rsp0(uint64_t rsp0);

void ap_barrier_checkin(void);

void smp_wait_for_aps(void);

void lapic_timer_init_ap(void);

 
#endif /* _MINIOS_ARCH_X86_64_SMP_H_ */