add page cache with read-ahead and dirty writeback, file-backed and anonymous mmap with CoW, VAD-based virtual memory replacing the old user region model, PFN database with eviction and reclaim, file identity for cross-open section sharing, FAT32 path cache and per-file cluster chain cache, serial.sys for COM1 keyboard input, xHCI MSI with INTx and polled fallback, PciEnableMsiAuto, waitable input queue, KeWaitForAnyEvent, per-process thread info syscall, expanded kernel stats (PFN/PTE/VAD/file-cache/disk), pool allocation tags, async I/O user buffer locking, file flush on close, add docs.md.

code/user/apps/doom/doom.c

@@ -88,7 +88,8 @@ static int doom_read_wrapper(void* handle, void* buf, int count)
     if (!handle || count <= 0) return 0;
     DOOM_FILE_HANDLE* f = (DOOM_FILE_HANDLE*)handle;
     size_t read = 0;
-    SysReadFile(f->Handle, buf, (size_t)count, &read);
+    SYS_FILE_IO_REQUEST req = SysMakeFileIoRequest(f->Handle, buf, (size_t)count, &read);
+    SysReadFile(&req);
     f->Pos += read;
     if (f->Pos > f->Size) f->Size = f->Pos;
     return (int)read;
@@ -99,7 +100,8 @@ static int doom_write_wrapper(void* handle, const void* buf, int count)
     if (!handle || count <= 0) return 0;
     DOOM_FILE_HANDLE* f = (DOOM_FILE_HANDLE*)handle;
     size_t written = 0;
-    SysWriteFile(f->Handle, buf, (size_t)count, &written);
+    SYS_FILE_IO_REQUEST req = SysMakeFileIoRequest(f->Handle, buf, (size_t)count, &written);
+    SysWriteFile(&req);
     f->Pos += written;
     if (f->Pos > f->Size) f->Size = f->Pos;
     return (int)written;
@@ -262,7 +264,7 @@ static void poll_input(void)
 }
 
 // ---------------------------------------------------------------------------
-// Render — Performs lightweight software upscale and blits to the screen
+// Render — writes directly into a mapped kernel surface and presents it.
 // ---------------------------------------------------------------------------
 #define DOOM_W  320
 #define DOOM_H  200
@@ -270,32 +272,65 @@ static void poll_input(void)
 #define DISP_W  (DOOM_W * SCALE)
 #define DISP_H  (DOOM_H * SCALE)
 
-static uint32_t g_blit_buf[DISP_W * DISP_H]; 
+static uint32_t  g_surface_handle;
+static uint32_t* g_surface_pixels;
+static uint32_t  g_surface_pitch_pixels;
+
+static void init_surface(void)
+{
+    uint32_t s = SysCreateSurface(DISP_W, DISP_H, SYS_SURFACE_FORMAT_XRGB8888,
+                                  SYS_SURFACE_FLAG_NONE, &g_surface_handle);
+    if (s != SYS_STATUS_SUCCESS || !g_surface_handle) {
+        doom_print_wrapper("doom: SysCreateSurface failed\n");
+        SysExitProcess(1);
+    }
+
+    void* base = 0;
+    uint32_t pitchBytes = 0;
+    s = SysMapSurface(g_surface_handle, &base, &pitchBytes);
+    if (s != SYS_STATUS_SUCCESS || !base || pitchBytes < DISP_W * sizeof(uint32_t)) {
+        doom_print_wrapper("doom: SysMapSurface failed\n");
+        SysExitProcess(1);
+    }
+
+    g_surface_pixels = (uint32_t*)base;
+    g_surface_pitch_pixels = pitchBytes / sizeof(uint32_t);
+}
 
 static void render_frame(const uint8_t* rgba)
 {
     const uint32_t* src = (const uint32_t*)rgba;
-    
-    // Software upscale loop mapping 320x200 buffer directly to scaled window buffer
+    uint32_t* dstBase = g_surface_pixels;
+    uint32_t dstPitch = g_surface_pitch_pixels;
+
+    if (!dstBase || dstPitch < DISP_W) {
+        doom_print_wrapper("doom: surface not initialized\n");
+        SysExitProcess(1);
+    }
+
     for (int y = 0; y < DOOM_H; y++) {
         for (int x = 0; x < DOOM_W; x++) {
             uint32_t p = src[y * DOOM_W + x];
-            
-            // RGBA -> BGRA conversion (standard for linear x86/64 framebuffers)
+
+            // RGBA -> BGRA/XRGB8888 conversion for the current display path.
             uint32_t bgra = (p & 0xFF00FF00u)
                           | ((p & 0x00FF0000u) >> 16)
                           | ((p & 0x000000FFu) << 16);
 
-            // Populate SCALE * SCALE pixel block
+            uint32_t* block = dstBase + (size_t)(y * SCALE) * dstPitch + (size_t)(x * SCALE);
             for (int sy = 0; sy < SCALE; sy++) {
                 for (int sx = 0; sx < SCALE; sx++) {
-                    g_blit_buf[(y * SCALE + sy) * DISP_W + (x * SCALE + sx)] = bgra;
+                    block[(size_t)sy * dstPitch + sx] = bgra;
                 }
             }
         }
     }
 
-    SysBlitScreen(0, 0, DISP_W, DISP_H, g_blit_buf);
+    DISPLAY_RECT rect = { 0, 0, DISP_W, DISP_H };
+    uint32_t code = SysPresentSurface(g_surface_handle, &rect, 1);
+    if (code != SYS_STATUS_SUCCESS) {
+        SysExitProcess(code);
+    }
 }
 
 static int build_argv_from_command_line(const char* cmdline, char* storage, size_t storageSize,
@@ -373,6 +408,7 @@ int main(void)
     char argvStorage[512];
     const char* argv[32];
     int argc = build_argv_from_command_line(cmdline, argvStorage, sizeof(argvStorage), argv, 32);
+    init_surface();
     doom_init(argc, argv, 0);
 
     do { SYS_WRITE_CONSOLE_REQUEST req = { SYS_SV_LITERAL("doom: entering game loop\n") }; SysWriteConsole(&req); } while (0);