Kernel Completion And Roadmap Alignment

Add explicit regression coverage for exec-time signal reset. Why it matters: Phase 52a implemented the POSIX rule that caught signal handlers reset across exec, but the current signal-test binary does not exercise that behavior directly. Focus on `main` and `exec` in `userspace/signal-test/signal-test.c` while you trace the snippet.

    else if (reentry_count == 1)
        /* Acceptable: the second delivery happens after the first handler
           finishes and the mask is restored, but the main thread may have
           already checked. In our kernel, check_pending_signals runs on
           every syscall return, so the pending SIGUSR2 is delivered before
           the next userspace instruction after sigreturn. */
        pass("auto_masking (deferred delivery)");
    else
        fail("auto_masking", "unexpected reentry_count");

    sa.sa_handler = SIG_DFL;
    sigaction(SIGUSR2, &sa, NULL);

View on GitHub

Save user return state at syscall entry. Why it matters: The 52b design says user return state should be captured once at syscall entry before any blocking can occur. The current implementation still treats block/yield paths as the primary save points. Focus on `UserReturnState` and `syscall_handler` in `kernel/src/task/mod.rs` while you trace the snippet.

/// User-mode return state saved at syscall entry and restored by the
/// scheduler on re-dispatch.  Captures the complete per-task resume
/// contract in one place, eliminating split ownership between `Task`,
/// `Process`, and `PerCoreData`.
///
/// # Phase 52d invariant
///
/// `syscall_handler` snapshots this struct once before any blocking or
/// yield path.  The scheduler restores `user_rsp`, `kernel_stack_top`,
/// `fs_base`, and `cr3_phys` exclusively from this struct for userspace
/// tasks (pid != 0).
#[derive(Debug, Clone, Copy, Default)]
pub struct UserReturnState {
    /// User-mode RSP at syscall entry.
    pub user_rsp: u64,
    /// Kernel stack top for TSS.RSP0 / SYSCALL stack.
    pub kernel_stack_top: u64,
    /// FS.base MSR value (TLS pointer).
    pub fs_base: u64,
    /// Physical address of the PML4 (CR3).  0 means no dedicated address space.
    pub cr3_phys: u64,
    /// Address-space generation counter at the time of snapshot (Phase 52d B.3).
    /// Used by user-copy diagnostics to detect concurrent mapping mutations.
    pub addr_space_gen: u64,

View on GitHub

Make scheduler dispatch the authoritative restore path. Why it matters: The scheduler currently restores only part of the return state from Task.user_return and still sources kernel_stack_top / fs_base from Process. That split keeps the architecture in a half-migrated state. Focus on `run` and `PerCoreData` in `kernel/src/task/scheduler.rs` while you trace the snippet.

/// The main scheduler loop. Called once per core. Never returns.
///
/// Each core runs its own instance. The per-core reschedule flag gates
/// iteration; per-core run queues provide task selection locality. However,
/// the global `SCHEDULER` lock is acquired on each iteration for task state
/// reads, state transitions, and post-switch bookkeeping (see module doc).
pub fn run() -> ! {
    let core_id = crate::smp::per_core().core_id;

    loop {
        let reschedule = per_core_reschedule();

        interrupts::disable();
        if !reschedule.swap(false, Ordering::AcqRel) {
            interrupts::enable_and_hlt();
            continue;
        }
        interrupts::enable();

        debug_assert!(
            per_core_scheduler_rsp() != 0,
            "core {}: scheduler RSP is zero",
            core_id
        );

View on GitHub