clean up and standardize types across the codebase, unify atomic operations, improve UTF-8 handling throughout the system, remove obsolete input and named queue interfaces, redesign process preparation and creation, tighten IPC and service boundaries, improve error handling and reliability, minor documentation cleanup, fix doom surfaces, fix panic in ini parsing.

code/kernel/kmain.c

@@ -1,5 +1,6 @@
 // Kernel entry point. This file connects boot information to core subsystem initialization and scheduler start.
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
 #include <intrin.h>
@@ -128,7 +129,7 @@ typedef KSTATUS (*DRIVER_ENTRY_FN)(const NTL_DDK* ddk, NTL_DRIVER_INIT* init);
 static const HAL_API* gKmainHal;
 
 // Implements the page In Bootloader Region operation.
-static int KiPageInBootloaderRegion(const BOOT_INFO* bootInfo, PHYSICAL_ADDRESS page) {
+static bool KiPageInBootloaderRegion(const BOOT_INFO* bootInfo, PHYSICAL_ADDRESS page) {
     for (uint32_t i = 0; i < bootInfo->MemoryMap.RegionCount; i++) {
         const MEMORY_REGION* r = &bootInfo->MemoryMap.Regions[i];
         if (r->Type != MemoryBootloader) continue;
@@ -136,10 +137,10 @@ static int KiPageInBootloaderRegion(const BOOT_INFO* bootInfo, PHYSICAL_ADDRESS
         uintptr_t start = r->Base & PAGE_MASK;
         uintptr_t end   = (r->Base + r->Length + PAGE_SIZE - 1) & PAGE_MASK;
         if ((uintptr_t)page >= start && (uintptr_t)page < end) {
-            return 1;
+            return true;
         }
     }
-    return 0;
+    return false;
 }
 
 // Reclaims one exact page-backed blob after its boot consumer has copied or materialized it.
@@ -170,7 +171,7 @@ static void KiReclaimBootloaderMemory(const BOOT_INFO* bootInfo) {
 }
 
 // Returns whether one drivers.ini line character is horizontal whitespace.
-static int KiDriverConfigSpace(char c) {
+static bool KiDriverConfigSpace(char c) {
     return c == ' ' || c == '\t' || c == '\r';
 }
 
@@ -183,10 +184,10 @@ static void KiDriverConfigTrim(const char** begin, const char** end) {
 }
 
 // Returns whether one immutable drivers.ini span exactly matches an ASCII string.
-static int KiDriverConfigSpanEquals(const char* begin, const char* end, const char* text) {
+static bool KiDriverConfigSpanEquals(const char* begin, const char* end, const char* text) {
     while (begin < end && *text) {
         if (*begin++ != *text++)
-            return 0;
+            return false;
     }
     return begin == end && *text == '\0';
 }
@@ -605,55 +606,55 @@ void SystemInitThread(void* arg) {
 }
 
 // Returns whether one page-backed boot allocation is aligned, nonempty, and does not overflow.
-static int KiValidateBootPageRange(uintptr_t physicalBase, uint32_t pageCount) {
+static bool KiValidateBootPageRange(uintptr_t physicalBase, uint32_t pageCount) {
     if (!physicalBase || (physicalBase & (PAGE_SIZE - 1u)) != 0 || pageCount == 0)
-        return 0;
+        return false;
 
     uint64_t byteCount = (uint64_t)pageCount * PAGE_SIZE;
     return byteCount != 0 && physicalBase <= UINTPTR_MAX - byteCount;
 }
 
 // Returns whether one page-backed raw boot file is fully contained in its recorded allocation.
-static int KiValidateBootFile(const BOOT_FILE* file) {
+static bool KiValidateBootFile(const BOOT_FILE* file) {
     if (!file || !KiValidateBootPageRange(file->PhysicalBase, file->PageCount) || file->Length == 0)
-        return 0;
+        return false;
 
     uint64_t capacity = (uint64_t)file->PageCount * PAGE_SIZE;
     if ((uint64_t)file->Length + 1u > capacity || file->Name[0] == '\0')
-        return 0;
+        return false;
     return memchr(file->Name, '\0', sizeof(file->Name)) != NULL;
 }
 
 // Returns whether one fixed core-image descriptor fits inside its page-backed physical allocation.
-static int KiValidateBootImage(const BOOT_IMAGE* image, int requireEntry) {
+static bool KiValidateBootImage(const BOOT_IMAGE* image, int requireEntry) {
     if (!image || !image->VirtualBase || (image->VirtualBase & (PAGE_SIZE - 1u)) != 0 ||
         !KiValidateBootPageRange(image->PhysicalBase, image->PageCount) || !image->ImageSize) {
-        return 0;
+        return false;
     }
 
     uint64_t capacity = (uint64_t)image->PageCount * PAGE_SIZE;
     if (image->ImageSize > capacity || image->VirtualBase > UINTPTR_MAX - image->ImageSize)
-        return 0;
+        return false;
     if (requireEntry && image->EntryRva >= image->ImageSize)
-        return 0;
-    return 1;
+        return false;
+    return true;
 }
 
 // Validates the exact bootloader/kernel handoff contract before dereferencing variable physical blobs.
-static int KiValidateBootInfo(const BOOT_INFO* bootInfo) {
+static bool KiValidateBootInfo(const BOOT_INFO* bootInfo) {
     if (!bootInfo || bootInfo->Magic != BOOT_INFO_MAGIC ||
         bootInfo->Version != BOOT_INFO_VERSION || bootInfo->Size != sizeof(BOOT_INFO) ||
         bootInfo->MemoryMap.Magic != MEMORY_MAP_MAGIC ||
         bootInfo->MemoryMap.RegionCount > MEMORY_MAX_REGIONS ||
         bootInfo->PhysicalMapBase == 0) {
-        return 0;
+        return false;
     }
 
     uint64_t bootIniCapacity = (uint64_t)bootInfo->BootIni.PageCount * PAGE_SIZE;
     if (!KiValidateBootPageRange(bootInfo->BootIni.PhysicalBase, bootInfo->BootIni.PageCount) ||
         bootInfo->BootIni.Length == 0 || (uint64_t)bootInfo->BootIni.Length + 1u > bootIniCapacity ||
         bootInfo->BootIni.PhysicalBase > UINTPTR_MAX - bootInfo->PhysicalMapBase) {
-        return 0;
+        return false;
     }
 
     uint64_t driverListCapacity = (uint64_t)bootInfo->BootDrivers.PageCount * PAGE_SIZE;
@@ -661,7 +662,7 @@ static int KiValidateBootInfo(const BOOT_INFO* bootInfo) {
     if (!KiValidateBootPageRange(bootInfo->BootDrivers.FilesPhysical, bootInfo->BootDrivers.PageCount) ||
         bootInfo->BootDrivers.Count == 0 || driverListBytes > driverListCapacity ||
         bootInfo->BootDrivers.FilesPhysical > UINTPTR_MAX - bootInfo->PhysicalMapBase) {
-        return 0;
+        return false;
     }
 
     const BOOT_FILE* bootFiles =
@@ -669,16 +670,16 @@ static int KiValidateBootInfo(const BOOT_INFO* bootInfo) {
     for (uint32_t index = 0; index < bootInfo->BootDrivers.Count; ++index) {
         if (!KiValidateBootFile(&bootFiles[index]) ||
             bootFiles[index].PhysicalBase > UINTPTR_MAX - bootInfo->PhysicalMapBase) {
-            return 0;
+            return false;
         }
     }
 
     if (!KiValidateBootImage(&bootInfo->KernelImage, 1) ||
         !KiValidateBootImage(&bootInfo->HalImage, 0)) {
-        return 0;
+        return false;
     }
 
-    return 1;
+    return true;
 }
 
 // Main Kernel Entry.