fix the return value of LdrLoadImage, make use of __declspec(dllexport), speed up blitting, add dummy TEB, redesign the syscall interface, fix stack alignent so movaps doesn't crash, implement a shitload of win32, implement a simple shell, add bink as video.exe 😎, minor kmain.c cleanup, HAL now supports power-off events, implemented \b in hal_screen.c, fix many deadlocks, add wait for exit event for processes, completely new error codes, small readme changes.

code/kernel/ke_thread.c

@@ -66,7 +66,18 @@ KSTATUS KeCreateThread(PROCESS* owner, uintptr_t entry, uintptr_t arg,
         return STATUS_NO_MEMORY;
     }
     thread->UserStackBase = ustack;
-    uintptr_t userStackTop = (uintptr_t)ustack + USTACK_SIZE;
+    uintptr_t userStackTop = (uintptr_t)ustack + USTACK_SIZE - 8; // i don't know why, i don't want to know why
+    // i shouldn't have to wonder why but the stack is off by 8 bytes unless we do this terribleness
+    // this magic number will hunt me in my dreams
+
+    // Initialize the dummy TEB
+    // offset 0x10 is StackLimit, which __chkstk checks.
+    uint64_t* teb = (uint64_t*)ustack;
+    teb[0] = 0; // ExceptionList (GS:0x00)
+    teb[1] = 0; // StackBase     (GS:0x08)
+    teb[2] = 0; // StackLimit    (GS:0x10) - __chkstk will see 0 and safely exit
+    
+    thread->Teb = teb;
 
     thread->UserEntry = entry;
     thread->UserArg   = arg;
@@ -108,6 +119,78 @@ void KeExitThread(THREAD* thread, int code) {
     KeYield();
 }
 
+// ---------------------------------------------------------------------------
+// KeCreateKernelThread
+// ---------------------------------------------------------------------------
+// Kernel threads never go to ring 3: they have no user stack, no TEB, and
+// their entry stub (KeKernelThreadEntry) calls the function directly then
+// calls KeExitThread instead of IRETQ-ing.
+//
+// Stack layout built here (from KernelStackTop downward):
+//   [ksp - 8 ]  arg          <-- popped by KeKernelThreadEntry as r12
+//   [ksp - 16]  fn           <-- popped by KeKernelThreadEntry as rbx
+//   [ksp - 16 - sizeof(KCONTEXT)]  KCONTEXT { .Rip = KeKernelThreadEntry }
+// ---------------------------------------------------------------------------
+extern void KeKernelThreadEntry(void);
+
+KSTATUS KeCreateKernelThread(uintptr_t fn, uintptr_t arg,
+                              THREAD_PRIORITY priority, THREAD **out) {
+    // Kernel threads are owned by the idle process.  We need a PROCESS* for
+    // the owner field; grab it from the idle/init thread that already exists.
+    THREAD* idleThread = KeCurrentThread(); // safe to call before scheduler starts
+    PROCESS* owner = idleThread ? idleThread->Owner : (PROCESS*)0;
+    if (!owner) return STATUS_INVALID_PARAMETER;
+    if (priority >= PriorityCount) return STATUS_INVALID_PARAMETER;
+
+    THREAD* thread = (THREAD*)ObAllocateObject(ObjectTypeThread, sizeof(THREAD));
+    if (!thread) return STATUS_NO_MEMORY;
+
+    thread->Header.Destroy  = ThreadDestroy;
+    thread->ThreadId        = _InterlockedExchangeAdd((volatile long*)&gNextThreadId, 1);
+    thread->State           = ThreadReady;
+    thread->Priority        = priority;
+    thread->QuantaConsumed  = 0;
+    thread->WaitObject      = (OBJECT*)0;
+    thread->SchedLockFlags  = 0x202ULL;
+    thread->UserStackBase   = (void*)0;   // no user stack
+    thread->Teb             = (void*)0;   // no TEB; GS_BASE will be 0 in kernel ctx
+
+    void* kstack = MmAllocatePool(KSTACK_SIZE);
+    if (!kstack) {
+        ObDereferenceObject(&thread->Header);
+        return STATUS_NO_MEMORY;
+    }
+    memset(kstack, 0, KSTACK_SIZE);
+    thread->KernelStackBase = kstack;
+    thread->KernelStackTop  = (uintptr_t)kstack + KSTACK_SIZE;
+    thread->TssRsp0         = thread->KernelStackTop;
+
+    // Build the initial stack: arg, fn, then KCONTEXT.
+    uintptr_t* ksp = (uintptr_t*)thread->KernelStackTop;
+    *(--ksp) = arg;   // popped second  (-> r12)
+    *(--ksp) = fn;    // popped first   (-> rbx)
+
+    ksp -= sizeof(KCONTEXT) / sizeof(uintptr_t);
+    KCONTEXT* ctx = (KCONTEXT*)ksp;
+    memset(ctx, 0, sizeof(KCONTEXT));
+    ctx->Rip = (uint64_t)KeKernelThreadEntry;
+    thread->SavedContext = ctx;
+
+    // Register with the owning process.
+    ObReferenceObject(&owner->Header);
+    thread->Owner = owner;
+
+    uintptr_t flags = KeAcquireSpinlock(&owner->HandleLock);
+    ListInsertTail(&owner->ThreadList, &thread->ProcessLink);
+    owner->ThreadCount++;
+    KeReleaseSpinlock(&owner->HandleLock, flags);
+
+    if (out) *out = thread;
+
+    KeReadyThread(thread);
+    return STATUS_SUCCESS;
+}
+
 void KeBlockThread(THREAD* thread, OBJECT* waitObject) {
     thread->State      = ThreadWaiting;
     thread->WaitObject = waitObject;