schedule tasks across all cores

Per-core GDT/TSS and AP scheduler entry; fix AP SSE + single_threaded.

src/kernel/scheduler.zig

@@ -112,6 +112,27 @@ pub fn prepareSecondary(index: usize, apic_id: u32) *PerCpu {
     return pc;
 }
 
+/// Entry for an application processor once the arch layer has set up its per-CPU
+/// tables, LAPIC, and timer. It turns this bring-up context into the core's idle task
+/// (as task 0 is for the BSP), marks the core online, and enters the run loop: with
+/// interrupts enabled the timer preempts this idle context into whatever the global
+/// ready queue offers, so the core runs real work in parallel with the others. The
+/// `.c` calling convention lets the arch trampoline path jump here. Never returns.
+pub fn secondaryMain() callconv(.c) noreturn {
+    const flags = sync.enter();
+    const pc = thisCpu();
+    const t = freeSlot() orelse @panic("sched: task table full (AP idle task)");
+    t.* = .{ .id = next_id, .state = .running, .priority = 0 };
+    next_id += 1;
+    pc.current = t;
+    pc.idle = t;
+    pc.online = true;
+    sync.leave(flags);
+
+    arch.enableInterrupts(); // the timer now preempts this idle context into work
+    while (true) asm volatile ("hlt"); // idle when this core has nothing ready
+}
+
 /// Number of cores that have finished bring-up (the BSP plus every online AP).
 pub fn onlineCount() usize {
     var n: usize = 0;
@@ -333,6 +354,13 @@ pub fn currentId() u32 {
     return cur().id;
 }
 
+/// The dense index of the core this task is currently running on (0 = BSP). Reads
+/// per-CPU state, so a task calling it on different cores sees different values —
+/// which is how a test can prove work is running in parallel.
+pub fn currentCpuIndex() u32 {
+    return thisCpu().index;
+}
+
 /// Change the running task's priority (takes effect next time it's enqueued).
 pub fn setPriority(p: Priority) void {
     cur().priority = p;