refactor: move filesystem discovery code into separate module

kernel/src/Fs/Boot.cpp

@@ -0,0 +1,86 @@
+/*
+    * Boot.cpp
+    * Boot-time filesystem initialization
+    * Copyright (c) 2026 Daniel Hammer
+*/
+
+#include "Boot.hpp"
+#include <Terminal/Terminal.hpp>
+#include <Fs/Ramdisk.hpp>
+#include <Fs/Vfs.hpp>
+#include <Fs/Fat32.hpp>
+#include <Fs/Ext2.hpp>
+#include <Fs/FsProbe.hpp>
+
+namespace Fs {
+
+    namespace {
+
+        bool StringsEqual(const char* lhs, const char* rhs) {
+            if (lhs == nullptr || rhs == nullptr) return false;
+
+            while (*lhs != '\0' && *rhs != '\0') {
+                if (*lhs != *rhs) return false;
+                lhs++;
+                rhs++;
+            }
+
+            return *lhs == *rhs;
+        }
+
+        bool InitializeRamdiskFromModules(const volatile limine_module_response* moduleResponse) {
+            if (moduleResponse == nullptr || moduleResponse->module_count == 0) {
+                Kt::KernelLogStream(Kt::WARNING, "Modules") << "No modules loaded (ramdisk unavailable)";
+                return false;
+            }
+
+            Kt::KernelLogStream(Kt::OK, "Modules")
+                << "Found " << (uint64_t)moduleResponse->module_count << " module(s)";
+
+            bool hasRamdisk = false;
+            for (uint64_t i = 0; i < moduleResponse->module_count; i++) {
+                limine_file* module = moduleResponse->modules[i];
+                if (module == nullptr || !StringsEqual(module->string, "ramdisk")) {
+                    continue;
+                }
+
+                Kt::KernelLogStream(Kt::OK, "Modules")
+                    << "Ramdisk module at " << kcp::hex << (uint64_t)module->address
+                    << kcp::dec << ", size=" << module->size;
+                Ramdisk::Initialize(module->address, module->size);
+                hasRamdisk = true;
+            }
+
+            return hasRamdisk;
+        }
+
+        Vfs::FsDriver g_ramdiskDriver = {
+            Ramdisk::Open,
+            Ramdisk::Read,
+            Ramdisk::GetSize,
+            Ramdisk::Close,
+            Ramdisk::ReadDir,
+            Ramdisk::Write,
+            Ramdisk::Create,
+            Ramdisk::Delete,
+            Ramdisk::Mkdir,
+            nullptr,
+        };
+
+    }
+
+    void InitializeBootFilesystems(const volatile limine_module_response* moduleResponse) {
+        bool hasRamdisk = InitializeRamdiskFromModules(moduleResponse);
+
+        Vfs::Initialize();
+        if (hasRamdisk) {
+            Vfs::RegisterDrive(0, &g_ramdiskDriver);
+        }
+
+        // When no ramdisk, disk partitions start at drive 0 so init.elf is found there.
+        Fat32::RegisterProbe();
+        Ext2::RegisterProbe();
+        FsProbe::MountPartitions(hasRamdisk ? 1 : 0);
+    }
+
+}

kernel/src/Fs/Boot.hpp

@@ -0,0 +1,14 @@
+/*
+    * Boot.hpp
+    * Boot-time filesystem initialization
+    * Copyright (c) 2026 Daniel Hammer
+*/
+
+#pragma once
+#include <limine.h>
+
+namespace Fs {
+
+    void InitializeBootFilesystems(const volatile limine_module_response* moduleResponse);
+
+}

kernel/src/Main.cpp

@@ -32,11 +32,7 @@
 #include <Graphics/Cursor.hpp>
 #include <Hal/MSR.hpp>
 #include <Hal/Cpu.hpp>
-#include <Fs/Ramdisk.hpp>
-#include <Fs/Vfs.hpp>
-#include <Fs/Fat32.hpp>
-#include <Fs/Ext2.hpp>
-#include <Fs/FsProbe.hpp>
+#include <Fs/Boot.hpp>
 #include <Sched/Scheduler.hpp>
 #include <Ipc/Ipc.hpp>
 #include <Api/Syscall.hpp>
@@ -178,51 +174,7 @@ extern "C" void kmain() {
     Efi::SystemTable* ST = (Efi::SystemTable*)Memory::HHDM(system_table_request.response->address);
     Efi::Init(ST, efi_memmap_request.response);
 
-    // Initialize ramdisk from Limine modules
-    bool hasRamdisk = false;
-    if (module_request.response != nullptr && module_request.response->module_count > 0) {
-        Kt::KernelLogStream(OK, "Modules") << "Found " << (uint64_t)module_request.response->module_count << " module(s)";
-        for (uint64_t i = 0; i < module_request.response->module_count; i++) {
-            limine_file* mod = module_request.response->modules[i];
-            const char* modString = mod->string;
-
-            // Find "ramdisk" module by its string
-            if (modString != nullptr &&
-                modString[0] == 'r' && modString[1] == 'a' && modString[2] == 'm' &&
-                modString[3] == 'd' && modString[4] == 'i' && modString[5] == 's' &&
-                modString[6] == 'k' && modString[7] == '\0') {
-                Kt::KernelLogStream(OK, "Modules") << "Ramdisk module at " << kcp::hex << (uint64_t)mod->address << kcp::dec << ", size=" << mod->size;
-                Fs::Ramdisk::Initialize(mod->address, mod->size);
-                hasRamdisk = true;
-            }
-        }
-    } else {
-        Kt::KernelLogStream(WARNING, "Modules") << "No modules loaded (ramdisk unavailable)";
-    }
-
-    // Initialize VFS and register ramdisk as drive 0 only if present
-    Fs::Vfs::Initialize();
-
-    if (hasRamdisk) {
-        static Fs::Vfs::FsDriver ramdiskDriver = {
-            Fs::Ramdisk::Open,
-            Fs::Ramdisk::Read,
-            Fs::Ramdisk::GetSize,
-            Fs::Ramdisk::Close,
-            Fs::Ramdisk::ReadDir,
-            Fs::Ramdisk::Write,
-            Fs::Ramdisk::Create,
-            Fs::Ramdisk::Delete,
-            Fs::Ramdisk::Mkdir
-        };
-        Fs::Vfs::RegisterDrive(0, &ramdiskDriver);
-    }
-
-    // Register filesystem probes and auto-mount partitions.
-    // When no ramdisk, disk partitions start at drive 0 so init.elf is found there.
-    Fs::Fat32::RegisterProbe();
-    Fs::Ext2::RegisterProbe();
-    Fs::FsProbe::MountPartitions(hasRamdisk ? 1 : 0);
+    Fs::InitializeBootFilesystems(module_request.response);
 
     Hal::LoadTSS();
     Montauk::InitializeSyscalls();