add a realtime scheduler class and priority-inheritance mutexes with timeouts and abandonment, add an HDA audio driver and a SYS_AUDIO_* syscall family, flesh out kernel32 with Win32 threads, events, mutexes, critical sections, and condition variables, add SYS_RESUME_THREAD for suspended thread creation, add KeInitializeMemoryTypes to reprogram MTRRs and install a canonical PAT for WB/WC/UC control, rework the display pipeline with a pitched present path and console output flush, bring back disk.vhd with mtools since vvfat fucking sucks, harden AHCI with serialized cache flush, USB mass storage with SCSI sense-data decoding, and xHCI with cleaner DMA teardown, fix the last stray for(;;) in HalStopProcessor to while(true), pile on smoke tests for audio, win32 sync primitives, and thread suspend, implement AHCI timeout, kill readahead since it was desperetaly trying to murder me, fix doom sound x2.

code/kernel/ke_system_root.c

@@ -7,10 +7,15 @@
 #include <kernel/ke_system_root.h>
 #include <kernel/ke_debug.h>
 #include <kernel/io_file.h>
+#include <kernel/ke_sched.h>
 
 static uint8_t gSystemRootDrive;
 static bool gSystemRootReady;
 
+#define KE_SYSTEM_ROOT_DISCOVERY_TIMEOUT_MS 30000ull
+#define KE_SYSTEM_ROOT_WAIT_SLICE_MS         1000ull
+#define KE_SYSTEM_ROOT_LOG_INTERVAL_MS       5000ull
+
 // Builds a drive-qualified path without depending on any process CWD.
 static bool KiBuildDrivePath(uint8_t drive, const char* relative, char* out, size_t outSize) {
     if (!relative || !out || drive >= KE_SYSTEM_ROOT_MAX_DRIVES)
@@ -50,23 +55,76 @@ static bool KiDriveLooksLikeSystemRoot(uint8_t drive) {
     return true;
 }
 
-// Selects the mounted volume that contains the kernel/system tree.
-KSTATUS KeInitializeSystemRootVolume(void) {
+// Returns the current scheduler time in milliseconds.
+static uint64_t KiSystemRootNowMilliseconds(void) {
+    KE_SCHED_STATS stats;
+    KeGetSchedulerStats(&stats);
+    return stats.Ticks * SCHED_TICK_MS;
+}
+
+// Scans the currently mounted volumes for the system tree.
+static KSTATUS KiTrySelectSystemRootVolume(uint32_t* mountedOut) {
+    uint32_t mounted = 0;
     for (uint8_t drive = 0; drive < KE_SYSTEM_ROOT_MAX_DRIVES; drive++) {
         if (!IoFilesystemPresent(drive))
             continue;
+        mounted++;
         if (!KiDriveLooksLikeSystemRoot(drive))
             continue;
 
         gSystemRootDrive = drive;
         gSystemRootReady = true;
+        if (mountedOut)
+            *mountedOut = mounted;
         DbgPrint("System root: drive=%u\n", drive);
         return NTLSTATUS_SUCCESS;
     }
 
+    if (mountedOut)
+        *mountedOut = mounted;
     return NTLSTATUS_NOT_FOUND;
 }
 
+// Waits for the mounted boot volume instead of racing asynchronous bus discovery.
+KSTATUS KeInitializeSystemRootVolume(void) {
+    uint64_t start = KiSystemRootNowMilliseconds();
+    uint64_t deadline = start + KE_SYSTEM_ROOT_DISCOVERY_TIMEOUT_MS;
+    uint64_t nextLog = start;
+
+    for (;;) {
+        uint64_t generation = IoGetVolumeNamespaceGeneration();
+        uint32_t mounted = 0;
+        KSTATUS status = KiTrySelectSystemRootVolume(&mounted);
+        if (KSUCCESS(status))
+            return status;
+
+        uint64_t now = KiSystemRootNowMilliseconds();
+        if (now >= deadline) {
+            DbgPrint("System root: discovery timed out after %llu ms; mounted=%u generation=%llu\n",
+                     (unsigned long long)KE_SYSTEM_ROOT_DISCOVERY_TIMEOUT_MS,
+                     mounted,
+                     (unsigned long long)generation);
+            return NTLSTATUS_TIMEOUT;
+        }
+
+        if (now >= nextLog) {
+            DbgPrint("System root: waiting for boot volume; mounted=%u generation=%llu remaining=%llu ms\n",
+                     mounted,
+                     (unsigned long long)generation,
+                     (unsigned long long)(deadline - now));
+            nextLog = now + KE_SYSTEM_ROOT_LOG_INTERVAL_MS;
+        }
+
+        uint64_t remaining = deadline - now;
+        uint64_t wait = remaining < KE_SYSTEM_ROOT_WAIT_SLICE_MS
+                      ? remaining
+                      : KE_SYSTEM_ROOT_WAIT_SLICE_MS;
+        KSTATUS waitStatus = IoWaitForVolumeNamespaceChange(generation, wait);
+        if (waitStatus != NTLSTATUS_SUCCESS && waitStatus != NTLSTATUS_TIMEOUT)
+            return waitStatus;
+    }
+}
+
 // Returns whether the system root volume has been selected.
 bool KeSystemRootReady(void) {
     return gSystemRootReady;