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/public/ntlite/ddk/thread.h

@@ -17,18 +17,49 @@ typedef enum THREAD_PRIORITY {
 #define NTL_THREAD_PRIORITY_DEFINED 1
 #endif
 
-// Creates a system-process kernel thread for a kernel-mode driver.
+// Selects dynamic normal scheduling or static real-time scheduling.
+typedef enum KE_SCHEDULING_CLASS {
+    KeSchedulingNormal = 0,
+    KeSchedulingRealtime = 1,
+    KeSchedulingClassCount = 2,
+} KE_SCHEDULING_CLASS;
+
+// Higher real-time values outrank lower values. Real-time threads always
+// outrank normal threads and round-robin with equal-priority peers.
+#define KE_REALTIME_PRIORITY_MIN   0u
+#define KE_REALTIME_PRIORITY_MAX  31u
+#define KE_REALTIME_PRIORITY_COUNT 32u
+
+// Creates a thread without placing it on a scheduler ready queue. The caller
+// must retain the returned THREAD reference and call KeResumeThread().
+#define KE_THREAD_CREATE_FLAG_SUSPENDED 0x00000001u
+
+// Describes initial scheduling, execution state, and affinity for one new
+// thread. Zero affinity selects the kernel default rather than an empty CPU
+// set.
+typedef struct KE_THREAD_CREATE_PARAMETERS {
+    KE_SCHEDULING_CLASS SchedulingClass;
+    uint32_t Priority;
+    uint32_t Flags;
+    uint64_t AffinityMask;
+} KE_THREAD_CREATE_PARAMETERS;
+
+#define KE_THREAD_CREATE_NORMAL(priorityValue) \
+    { KeSchedulingNormal, (uint32_t)(priorityValue), 0u, 0ULL }
+
+#define KE_THREAD_CREATE_REALTIME(priorityValue) \
+    { KeSchedulingRealtime, (uint32_t)(priorityValue), 0u, 0ULL }
+
+// Creates a system-process kernel thread with explicit scheduling parameters.
 __declspec(dllexport) KSTATUS KeCreateKernelThread(uintptr_t fn,
                                                    uintptr_t arg,
-                                                   THREAD_PRIORITY priority,
+                                                   const KE_THREAD_CREATE_PARAMETERS* parameters,
                                                    THREAD** out);
 
-// Creates a system-process kernel thread with an explicit affinity mask.
-__declspec(dllexport) KSTATUS KeCreateKernelThreadWithAffinity(uintptr_t fn,
-                                                               uintptr_t arg,
-                                                               THREAD_PRIORITY priority,
-                                                               uint64_t affinityMask,
-                                                               THREAD** out);
+// Decrements one thread's suspend count and queues it when the count reaches
+// zero. previousSuspendCountOut may be NULL.
+__declspec(dllexport) KSTATUS KeResumeThread(THREAD* thread,
+                                             uint32_t* previousSuspendCountOut);
 
 // Yields the current processor to another runnable thread.
 __declspec(dllexport) void KeYield(void);