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/drivers/fs/fat/fat.c

@@ -80,6 +80,11 @@ static void FatCacheEnsureMutex(void) {
         gFatCacheMutex.Lock = (SPINLOCK)SPINLOCK_INIT;
         gFatCacheMutex.Owner = (struct THREAD*)0;
         LIST_INIT(&gFatCacheMutex.WaitList);
+        LIST_INIT(&gFatCacheMutex.OwnerLink);
+        gFatCacheMutex.DonationClass = KeSchedulingNormal;
+        gFatCacheMutex.DonationPriority = PriorityLow;
+        gFatCacheMutex.HasDonation = 0;
+        gFatCacheMutex.Abandoned = 0;
         gFatCacheMutexReady = 1;
     }
     KeReleaseSpinlock(&gFatCacheMutexInitLock, flags);
@@ -89,7 +94,7 @@ static int FatCacheAcquire(void) {
     if (!KeCanWait())
         return 0;
     FatCacheEnsureMutex();
-    return KSUCCESS(KeAcquireMutex(&gFatCacheMutex));
+    return KE_MUTEX_ACQUIRE_SUCCEEDED(KeAcquireMutex(&gFatCacheMutex, KE_WAIT_INFINITE));
 }
 
 static void FatCacheRelease(int held) {
@@ -1913,6 +1918,17 @@ KSTATUS FatOpen(IO_FILESYSTEM *fs, SYS_STRING_VIEW path, void **fileCtx) {
     return NTLSTATUS_SUCCESS;
 }
 
+// Flushes FAT metadata and the backing device write cache.
+KSTATUS FatFlush(IO_FILESYSTEM* fs, void* fileCtx) {
+    (void)fs;
+    FAT_FILE* f = (FAT_FILE*)fileCtx;
+    if (!f || !f->Vol)
+        return NTLSTATUS_INVALID_PARAMETER;
+
+    FlushFatCache(f->Vol);
+    return IoFlushDisk(f->Vol->DriveIndex);
+}
+
 // Releases the requested object.
 void FatClose(IO_FILESYSTEM *fs, void *fileCtx) {
     (void)fs;
@@ -2304,11 +2320,14 @@ KSTATUS FatDelete(IO_FILESYSTEM *fs, SYS_STRING_VIEW path) {
     if (!KSUCCESS(s)) return s;
     if (!direntLba) return NTLSTATUS_ACCESS_DENIED;
 
-    uint8_t *sec = (uint8_t *)MmAllocatePool(v->BytesPerSector);
-    if (!sec) return NTLSTATUS_NO_MEMORY;
-    s = ReadSectors(v, direntLba, 1, sec);
-    if (KSUCCESS(s)) { sec[direntOffset] = 0xE5; s = WriteSectors(v, direntLba, 1, sec); }
-    MmFreePool(sec);
+    uint32_t parentCluster = 0;
+    SYS_STRING_VIEW filenameView;
+    s = FatResolveParentForMutation(v, path, &parentCluster, &filenameView);
+    if (!KSUCCESS(s)) return s;
+
+    // Delete the complete entry run so long-name metadata cannot survive the
+    // short entry and keep writable vvfat mirrors visibly present.
+    s = FatDeleteDirentRunV(v, parentCluster, filenameView);
     if (!KSUCCESS(s)) return s;
 
     if (cluster >= 2) FreeClusterChain(v, cluster);
@@ -2583,7 +2602,7 @@ KSTATUS FatReadDir(IO_FILESYSTEM *fs, void *dirCtx, KDIR_ENTRY *out) {
     FAT_DIR_CTX *ctx = (FAT_DIR_CTX *)dirCtx;
     FAT_VOL     *v   = ctx->Vol;
 
-    for (;;) {
+    while (true) {
         if (ctx->Cursor != ctx->LoadedCursor) {
             if (!KSUCCESS(ReadSectors(v, ctx->LoadedLba, ctx->LoadedSectors, ctx->ClusterBuf)))
                 return NTLSTATUS_NO_MORE_FILES;
@@ -2918,8 +2937,8 @@ static void FatAsyncWriteSubmitNext(FAT_ASYNC_RW* ctx);
 static void FatAsyncWorker(void* arg) {
     (void)arg;
 
-    for (;;) {
-        KSTATUS s = KeWaitSemaphore(gFatAsyncSemaphore);
+    while (true) {
+        KSTATUS s = KeWaitSemaphore(gFatAsyncSemaphore, KE_WAIT_INFINITE);
         if (!KSUCCESS(s)) {
             KeYield();
             continue;
@@ -2959,8 +2978,9 @@ static KSTATUS FatEnsureAsyncWorkerStarted(void) {
     KSTATUS s = KeSemaphoreCreate(0, 0x7fffffff, &gFatAsyncSemaphore);
     if (KSUCCESS(s)) {
         THREAD* worker = (THREAD*)0;
+        const KE_THREAD_CREATE_PARAMETERS parameters = KE_THREAD_CREATE_NORMAL(PriorityNormal);
         s = KeCreateKernelThread((uintptr_t)FatAsyncWorker, 0,
-                                 PriorityNormal, &worker);
+                                 &parameters, &worker);
         (void)worker;
     }
 
@@ -3355,6 +3375,11 @@ static void FatMountEnsureMutex(void) {
         gFatMountMutex.Lock = (SPINLOCK)SPINLOCK_INIT;
         gFatMountMutex.Owner = (struct THREAD*)0;
         LIST_INIT(&gFatMountMutex.WaitList);
+        LIST_INIT(&gFatMountMutex.OwnerLink);
+        gFatMountMutex.DonationClass = KeSchedulingNormal;
+        gFatMountMutex.DonationPriority = PriorityLow;
+        gFatMountMutex.HasDonation = 0;
+        gFatMountMutex.Abandoned = 0;
         gFatMountMutexReady = 1;
     }
     KeReleaseSpinlock(&gFatMountMutexInitLock, flags);
@@ -3375,7 +3400,7 @@ static uint32_t FatTryMountDisk(uint8_t disk) {
         return 0;
 
     FatMountEnsureMutex();
-    if (!KSUCCESS(KeAcquireMutex(&gFatMountMutex)))
+    if (!KE_MUTEX_ACQUIRE_SUCCEEDED(KeAcquireMutex(&gFatMountMutex, KE_WAIT_INFINITE)))
         return 0;
 
     if (gDiskScanned[disk]) {
@@ -3509,7 +3534,7 @@ static void FatUnmountDisk(uint8_t diskIndex, IO_DEVICE_CHANGE change) {
     uint32_t removed = 0;
 
     FatMountEnsureMutex();
-    if (!KSUCCESS(KeAcquireMutex(&gFatMountMutex)))
+    if (!KE_MUTEX_ACQUIRE_SUCCEEDED(KeAcquireMutex(&gFatMountMutex, KE_WAIT_INFINITE)))
         return;
 
     for (uint8_t i = 0; i < FAT_MAX_VOLUMES; i++) {