parallel compile, SMP, swapgs, cleanup, remove useless Reserved fields

code/kernel/hal/hal_main.c

@@ -40,7 +40,7 @@ typedef struct {
     uint32_t Length;
     uint64_t XsdtAddress;
     uint8_t ExtendedChecksum;
-    uint8_t Reserved[3];
+    uint8_t Padding[3];
 } RSDP;
 
 // ACPI SDT Header
@@ -81,6 +81,7 @@ typedef struct {
 static uintptr_t gLapicPhys  = 0xFEE00000;
 static uintptr_t gIoapicPhys = 0xFEC00000;
 static uintptr_t gHpetPhys   = 0xFED00000;
+static HAL_CPU_TOPOLOGY gCpuTopology;
 
 // ACPI power-off state (filled in by ParseFadt / ScanDsdtForS5)
 static uint16_t gPm1aCntBlk = 0;
@@ -89,7 +90,7 @@ static uint8_t  gSlpTypA    = 5;   // S5 SLP_TYP for PM1a; 5 is correct for QEMU
 static uint8_t  gSlpTypB    = 5;   // S5 SLP_TYP for PM1b
 
 int debugEnabled = 0;
-int _fltused; // fuckass
+int _fltused; // MSVC floating-point helper anchor
 static void hal_putchar(char c) {
     gApi.Screen.PrintChar(c, 0x00FF00, 0x000000);
 }
@@ -114,7 +115,7 @@ typedef struct {
     ACPISDTHeader Header;         // 0  (36 bytes)
     uint32_t      FirmwareCtrl;   // 36
     uint32_t      Dsdt;           // 40 - physical addr of DSDT
-    uint8_t       Reserved1;      // 44
+    uint8_t       Ignored44;      // 44
     uint8_t       PreferredPmProfile; // 45
     uint16_t      SciInt;         // 46
     uint32_t      SmiCmd;         // 48
@@ -201,16 +202,51 @@ static void ParseFadt(const FADT* fadt) {
     }
 }
 
+
+static void HalAddCpuRecord(uint32_t uid, uint32_t lapicId, uint32_t flags) {
+    if (gCpuTopology.CpuCount >= HAL_MAX_CPUS)
+        return;
+
+    for (uint32_t i = 0; i < gCpuTopology.CpuCount; i++) {
+        if (gCpuTopology.Cpus[i].LapicId == lapicId)
+            return;
+    }
+
+    HAL_CPU_INFO* cpu = &gCpuTopology.Cpus[gCpuTopology.CpuCount++];
+    memset(cpu, 0, sizeof(*cpu));
+    cpu->ProcessorUid = uid;
+    cpu->LapicId = lapicId;
+    cpu->Flags = flags;
+    cpu->Enabled = (flags & 1u) ? 1u : 0u;
+}
+
 static void ParseMadt(MADT* madt) {
     gLapicPhys = madt->LocalAPICAddress;
     uint8_t* p   = (uint8_t *)(madt + 1);
     uint8_t* end = (uint8_t *)madt + madt->Header.Length;
-    while (p < end) {
+    while (p + 2 <= end) {
         uint8_t type = p[0], len = p[1];
-        if (type == 1) {  // I/O APIC entry
+        if (!len || p + len > end) break;
+
+        if (type == 0 && len >= 8) {  // Processor Local APIC
+            uint32_t uid = p[2];
+            uint32_t lapicId = p[3];
+            uint32_t flags = *(uint32_t *)(p + 4);
+            if (flags & 1u)
+                HalAddCpuRecord(uid, lapicId, flags);
+        } else if (type == 1 && len >= 12) {  // I/O APIC entry
             gIoapicPhys = *(uint32_t *)(p + 4);
+        } else if (type == 5 && len >= 12) {  // Local APIC Address Override
+            gLapicPhys = (uintptr_t)*(uint64_t *)(p + 4);
+        } else if (type == 9 && len >= 16) {  // Processor Local x2APIC
+            uint32_t lapicId = *(uint32_t *)(p + 4);
+            uint32_t flags = *(uint32_t *)(p + 8);
+            uint32_t uid = *(uint32_t *)(p + 12);
+            if ((flags & 1u) && lapicId < 256u)
+                HalAddCpuRecord(uid, lapicId, flags);
         }
-        p += len ? len : 1;
+
+        p += len;
     }
 }
 
@@ -313,6 +349,44 @@ static void HalShutdown(void) {
     while (true) __halt();
 }
 
+// ---------------------------------------------------------------------------
+__declspec(dllexport) KSTATUS HalGetProcessorTopology(HAL_CPU_TOPOLOGY* out) {
+    if (!out) return STATUS_INVALID_PARAMETER;
+
+    memset(out, 0, sizeof(*out));
+    *out = gCpuTopology;
+
+    if (!out->CpuCount) {
+        out->CpuCount = 1;
+        out->BspLapicId = HalGetBspLapicId();
+        out->Cpus[0].LapicId = out->BspLapicId;
+        out->Cpus[0].ProcessorUid = 0;
+        out->Cpus[0].Flags = 1;
+        out->Cpus[0].Enabled = 1;
+        out->Cpus[0].IsBsp = 1;
+        return STATUS_SUCCESS;
+    }
+
+    uint32_t bsp = HalGetBspLapicId();
+    out->BspLapicId = bsp;
+    int foundBsp = 0;
+    for (uint32_t i = 0; i < out->CpuCount; i++) {
+        out->Cpus[i].IsBsp = (out->Cpus[i].LapicId == bsp) ? 1u : 0u;
+        if (out->Cpus[i].IsBsp) foundBsp = 1;
+    }
+
+    if (!foundBsp && out->CpuCount < HAL_MAX_CPUS) {
+        HAL_CPU_INFO* cpu = &out->Cpus[out->CpuCount++];
+        memset(cpu, 0, sizeof(*cpu));
+        cpu->LapicId = bsp;
+        cpu->ProcessorUid = bsp;
+        cpu->Flags = 1;
+        cpu->Enabled = 1;
+        cpu->IsBsp = 1;
+    }
+    return STATUS_SUCCESS;
+}
+
 // ---------------------------------------------------------------------------
 __declspec(dllexport) KSTATUS HalInitialize(const HAL_INIT_PARAMS* initParams) {
     if (gInitialised) return STATUS_ALREADY_EXISTS;
@@ -357,12 +431,10 @@ __declspec(dllexport) KSTATUS HalInitialize(const HAL_INIT_PARAMS* initParams) {
     gApi.Version = HAL_API_VERSION;
     gInitialised = 1;
 
-    // This shouldn't be here but i have no other way.
-    // After i send 0xF4 and move the mouse the controller sends an interrupts that doesn't fire
-    // and because the CPU missed the IRQ 12 edge transition (cli) later when we expect it to fire, it doesn't
-    // leaving us with no mouse and no keyboard. The dreaded 8042 will hold the CLOCK line low forever.
-    // To combat this we just go about our day executing the rest of the init and just before the end
-    // of init we just iterate 256 times to grab whatever the controller left for us ("Drain and Pray").
+    // The 8042 can leave output bytes pending while the keyboard/mouse drivers
+    // are being brought up with interrupts temporarily disabled. Drain the
+    // controller before returning from HAL init so stale status/data bytes do
+    // not suppress the next keyboard or mouse interrupt edge.
     for (int i = 0; i < 256; i++) {
         if (__inbyte(0x64) & 0x01) {
             __inbyte(0x60); // Consume