redo boot around an explicit system volume and fixed kernel/HAL images, redo volumes and filesystem paths around capabilities instead of drive numbers and kernel CWD state, add a capability/security model with derived and revocable handles and security contexts, add port IPC and rssrv to manage the userspace resource namespace and publish the system volume, move process, dll and path loading to userspace and add process builder syscalls, init now supervises rssrv and the session process, redo the syscall ABI around request structs and four arguments, add a volume manager and proper partition arrival/removal handling so FAT and NTFS mount dynamically, clean up the HAL/DDK boundary so drivers don't depend on HAL internals, save fpu state properly now, the serial driver doesn't hang on a missing port, fix AHCI startup races, fix timeout accounting, fix shared mmap writeback, more smoke tests

code/kernel/hal/hal_timer.c

@@ -2,8 +2,9 @@
 
 #include <stdint.h>
 #include <intrin.h>
-#include <ntlite/ddi/hal_api.h>
-#include <kernel/hal/hal_apic.h>
+#include <kernel/hal/hal_api.h>
+#include <kernel/hal/hal_timer.h>
+#include <kernel/hal/hal_internal.h>
 #include <kernel/hal/hal_debug.h>
 
 #define LAPIC_TIMER_LVT   0x320
@@ -19,27 +20,24 @@
 #define TIMER_PERIOD_MS   10
 #define PIT_HZ            1193182UL
 
-extern HAL_API gApi;
 static volatile uint32_t* gLapic = NULL;
 static uint32_t gApicTicksPerUs = 0;
 static uint32_t gApicTicksPerQuantum = 0;
 static uint64_t gHpetTicksPerUs = 0;
 static uint64_t gHpetHz = 0;
 static volatile uint64_t* gHpet = NULL;
-#define LAPIC_REG(off) (*(volatile uint32_t *)((uint8_t *)gLapic + (off)))
+#define LAPIC_REG(off) (*(volatile uint32_t*)((uint8_t*)gLapic + (off)))
 
 static volatile uint64_t gTicks = 0;
-void (* volatile gTimerCallback)(void) = NULL;
 
 // Implements the outb operation.
 static inline void outb(uint16_t port, uint8_t val) { __outbyte(port, val); }
 // Implements the inb operation.
 static inline uint8_t inb(uint16_t port)            { return __inbyte(port); }
 
-// Implements the timer Isr operation.
-static void TimerIsr(void) {
+// Records one local timer interrupt for HAL timekeeping fallback.
+static void TimerInterrupt(void) {
     gTicks++;
-    if (gTimerCallback) gTimerCallback();
     // EOI is sent by KeIrqDispatch after this returns.
 }
 
@@ -87,7 +85,7 @@ static uint64_t QueryTickFrequency(void) {
 }
 
 // Implements the stall operation.
-static void Stall(uint32_t us) {
+void HalTimerStall(uint32_t us) {
     // Priority 1: Use HPET (Highest Precision).
     if (gHpet && gHpetTicksPerUs > 0) {
         uint64_t start = gHpet[30]; // Offset 0xF0 is the Main Counter
@@ -128,7 +126,7 @@ static void Stall(uint32_t us) {
 // Returns HPET ticks/second, or 0 if HPET is unavailable.
 static uint64_t HpetInit(uintptr_t hpetPhys) {
     // HPET register block, accessed through physical window.
-    volatile uint64_t *hpet = (volatile uint64_t *)gApi.PhysToVirt(hpetPhys);
+    volatile uint64_t* hpet = (volatile uint64_t*)HalPhysicalToVirtual(hpetPhys);
 
     // General Capabilities register (offset 0):
     // Bits 63:32 = counter clock period in femtoseconds.
@@ -167,7 +165,7 @@ static uint32_t CalibrateApicTimerViaPit(void) {
 
 // Use HPET main counter to measure how many APIC ticks elapse in 10 ms, then return ticks/ms.
 static uint32_t CalibrateApicTimerViaHpet(uintptr_t hpetPhys) {
-    volatile uint64_t *hpet = (volatile uint64_t *)gApi.PhysToVirt(hpetPhys);
+    volatile uint64_t* hpet = (volatile uint64_t*)HalPhysicalToVirtual(hpetPhys);
     uint64_t hpetHz = HpetInit(hpetPhys);
     if (!hpetHz) return 0;
 
@@ -187,7 +185,7 @@ static uint32_t CalibrateApicTimerViaHpet(uintptr_t hpetPhys) {
 }
 
 // Implements the timer Configure Current Cpu operation.
-__declspec(dllexport) void HalTimerConfigureCurrentCpu(void) {
+void HalTimerConfigureCurrentProcessor(void) {
     if (!gLapic || !gApicTicksPerQuantum) return;
     LAPIC_REG(LAPIC_TIMER_DIV)  = TIMER_DIV16;
     LAPIC_REG(LAPIC_TIMER_LVT)  = TIMER_PERIODIC | TIMER_VECTOR;
@@ -195,8 +193,8 @@ __declspec(dllexport) void HalTimerConfigureCurrentCpu(void) {
 }
 
 // Implements the timer Initialize operation.
-KSTATUS HalTimerInitialize(uintptr_t lapicPhys, uintptr_t hpetPhys, HAL_TIMER *out) {
-    gLapic = (volatile uint32_t *)gApi.PhysToVirt(lapicPhys);
+KSTATUS HalTimerInitialize(uintptr_t lapicPhys, uintptr_t hpetPhys, HAL_TIMER* out) {
+    gLapic = (volatile uint32_t*)HalPhysicalToVirtual(lapicPhys);
     HalDbgPrint("HAL: lapicPhys=0x%016llX, lapicVirt=0x%016llX, hpetPhys=0x%016llX\n", lapicPhys, (uintptr_t)gLapic, hpetPhys);
 
     uint32_t ticksPerMs = 0;
@@ -217,7 +215,7 @@ KSTATUS HalTimerInitialize(uintptr_t lapicPhys, uintptr_t hpetPhys, HAL_TIMER *o
     gApicTicksPerQuantum = ticksPerMs * TIMER_PERIOD_MS;
 
     if (hpetPhys) {
-        gHpet = (volatile uint64_t*)gApi.PhysToVirt(hpetPhys);
+        gHpet = (volatile uint64_t*)HalPhysicalToVirtual(hpetPhys);
         uint64_t hpetHz = HpetInit(hpetPhys);
         gHpetHz = hpetHz;
         gHpetTicksPerUs = hpetHz / 1000000;
@@ -225,14 +223,14 @@ KSTATUS HalTimerInitialize(uintptr_t lapicPhys, uintptr_t hpetPhys, HAL_TIMER *o
 
     HalDbgPrint("HAL: APIC timer: %u ticks/ms\n", ticksPerMs);
 
-    // Configure this CPU's LAPIC timer; APs call HalTimerConfigureCurrentCpu()
-    // after enabling their local APIC.
-    HalTimerConfigureCurrentCpu();
+    // Leave the BSP timer masked until the kernel registers its scheduler
+    // callback and IRQ route. APs arm their local timer after per-CPU setup.
 
     out->QueryTicks         = QueryTicks;
     out->QueryTickFrequency = QueryTickFrequency;
-    out->Stall              = Stall;
-    out->Isr                = TimerIsr;
-    out->IrqNumber          = 0;
+    out->Stall              = HalTimerStall;
+    out->HandleInterrupt          = TimerInterrupt;
+    out->ConfigureCurrentProcessor = HalTimerConfigureCurrentProcessor;
+    out->IrqNumber                = 0;
     return NTLSTATUS_SUCCESS;
 }