schedule tasks across all cores

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

src/kernel/arch/x86_64/tss.zig

@@ -4,6 +4,10 @@
 //! interrupted stack was. We use IST1 for the double-fault handler, so a fault
 //! that happens *because* the current stack is unusable still lands on solid
 //! ground instead of triple-faulting.
+//!
+//! Each core needs **its own TSS** (its own IST stack): two cores taking a fault at
+//! once can't share one fault stack. So the TSS and its IST stack are per-core,
+//! indexed by CPU number; slot 0 is the BSP.
 
 const gdt = @import("gdt.zig");
 
@@ -30,19 +34,30 @@ const Tss = packed struct {
 /// The IST slot (1-based, as the IDT gate encodes it) used for critical faults.
 pub const double_fault_ist = 1;
 
-var tss: Tss align(16) = .{};
+const max_cpus = 64; // matches gdt.zig / the scheduler
+const ist_stack_size = 16 * 1024;
 
-/// Dedicated stack for IST1. Static so it needs no allocator and is always valid.
-var ist1_stack: [16 * 1024]u8 align(16) = undefined;
+/// One TSS per core, and one IST1 stack per core. Static, so they need no allocator
+/// and are always valid. (max_cpus × 16 KiB of BSS for the IST stacks.)
+var tss_table = [_]Tss{.{}} ** max_cpus;
+var ist_stacks: [max_cpus][ist_stack_size]u8 align(16) = undefined;
 
 /// Loads the task register with the TSS selector. Defined in isr.s.
 extern fn load_tr(selector: u16) callconv(.c) void;
 
-/// Point IST1 at its stack, publish the TSS through the GDT, and load it into the
-/// task register. Requires the GDT to already be loaded (gdt.init first).
-pub fn init() void {
-    tss.ist1 = @intFromPtr(&ist1_stack) + ist1_stack.len; // stacks grow down
-    tss.iomap_base = @sizeOf(Tss); // == limit: no I/O permission bitmap
-    gdt.setTss(@intFromPtr(&tss), @sizeOf(Tss) - 1);
+/// Set up core `cpu`'s TSS: point IST1 at that core's stack, install the TSS
+/// descriptor into that core's GDT, and load it into the task register. Requires the
+/// core's GDT to already be loaded (gdt.loadOnThisCpu first).
+pub fn setupThisCpu(cpu: usize) void {
+    const t = &tss_table[cpu];
+    t.* = .{};
+    t.ist1 = @intFromPtr(&ist_stacks[cpu]) + ist_stack_size; // stacks grow down
+    t.iomap_base = @sizeOf(Tss); // == limit: no I/O permission bitmap
+    gdt.setTssFor(cpu, @intFromPtr(t), @sizeOf(Tss) - 1);
     load_tr(gdt.tss_selector);
 }
+
+/// Set up the bootstrap processor's TSS (slot 0). Requires gdt.init first.
+pub fn init() void {
+    setupThisCpu(0);
+}