Merge pull request #66 from 0xf00sec/patch-2

feat: `T.Value` (ErrorOr.h)

14 files changed, 288 insertions, 309 deletions

diff --git a/dev/kernel/FSKit/Ext2+IFS.h b/dev/kernel/FSKit/Ext2+IFS.h
new file mode 100644
index 00000000..d73ae43c
--- /dev/null
+++ b/dev/kernel/FSKit/Ext2+IFS.h
@@ -0,0 +1,140 @@
+#pragma once
+
+#include <FSKit/Ext2.h>
+#include <KernelKit/DriveMgr.h>
+#include <KernelKit/HeapMgr.h>
+#include <KernelKit/KPC.h>
+#include <NeKit/ErrorOr.h>
+#include <NeKit/KernelPanic.h>
+#include <NeKit/Utils.h>
+
+namespace Kernel::Ext2 {
+/// @brief Context for an EXT2 filesystem on a given drive
+struct Ext2Context {
+  Kernel::DriveTrait* drive{nullptr};
+  EXT2_SUPER_BLOCK*   superblock{nullptr};
+
+  /// @brief context with a drive
+  Ext2Context(Kernel::DriveTrait* drv) : drive(drv) {}
+
+  /// @brief Clean up
+  ~Ext2Context() {
+    if (superblock) {
+      Kernel::mm_free_ptr(superblock);
+      superblock = nullptr;
+    }
+  }
+
+  Ext2Context(const Ext2Context&) = delete;
+  Ext2Context& operator=(const Ext2Context&) = delete;
+
+  Ext2Context(Ext2Context&& other) noexcept : drive(other.drive), superblock(other.superblock) {
+    other.drive      = nullptr;
+    other.superblock = nullptr;
+  }
+
+  Ext2Context& operator=(Ext2Context&& other) noexcept {
+    if (this != &other) {
+      if (superblock) {
+        Kernel::mm_free_ptr(superblock);
+      }
+      drive            = other.drive;
+      superblock       = other.superblock;
+      other.drive      = nullptr;
+      other.superblock = nullptr;
+    }
+    return *this;
+  }
+
+  Kernel::SizeT LeakBlockSize() const {
+    if (!superblock) return kExt2FSBlockSizeBase;
+    return kExt2FSBlockSizeBase << superblock->fLogBlockSize;
+  }
+
+  BOOL operator bool() { return superblock != nullptr; }
+};
+
+/// ======================================================================= ///
+/// IFS FUNCTIONS
+/// ======================================================================= ///
+
+inline bool ext2_read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer,
+                            Kernel::UInt32 size) {
+  if (!drv || !buffer) return false;
+
+  Kernel::DriveTrait::DrivePacket pkt{};
+  pkt.fPacketContent = buffer;
+  pkt.fPacketSize    = size;
+  pkt.fPacketLba     = lba;
+  drv->fInput(pkt);
+
+  return pkt.fPacketGood;
+}
+
+inline bool ext2_write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* buffer,
+                             Kernel::UInt32 size) {
+  if (!drv || !buffer) return false;
+
+  Kernel::DriveTrait::DrivePacket pkt{};
+  pkt.fPacketContent = const_cast<void*>(buffer);
+  pkt.fPacketSize    = size;
+  pkt.fPacketLba     = lba;
+  drv->fOutput(pkt);
+  return pkt.fPacketGood;
+}
+
+inline Kernel::ErrorOr<EXT2_SUPER_BLOCK*> ext2_load_superblock(Ext2Context* ctx) {
+  if (!ctx || !ctx->drive) return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorInvalidData);
+
+  auto buf = Kernel::mm_alloc_ptr(sizeof(EXT2_SUPER_BLOCK), true, false);
+  if (!buf) return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorHeapOutOfMemory);
+
+  Kernel::UInt32 blockLba = kExt2FSSuperblockOffset / ctx->drive->fSectorSz;
+
+  if (!ext2_read_block(ctx->drive, blockLba, buf, sizeof(EXT2_SUPER_BLOCK))) {
+    Kernel::mm_free_ptr(buf);
+    return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorDisk);
+  }
+
+  auto sb = reinterpret_cast<EXT2_SUPER_BLOCK*>(buf);
+  if (sb->fMagic != kExt2FSMagic) {
+    Kernel::mm_free_ptr(buf);
+    return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorInvalidData);
+  }
+
+  ctx->superblock = sb;
+  return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(sb);
+}
+
+// Load inode
+inline Kernel::ErrorOr<Ext2Node*> ext2_load_inode(Ext2Context* ctx, Kernel::UInt32 inodeNumber) {
+  if (!ctx || !ctx->superblock) return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorInvalidData);
+
+  auto nodePtr = Kernel::mm_alloc_ptr(sizeof(Ext2Node), true, false);
+  if (!nodePtr) return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorHeapOutOfMemory);
+
+  auto ext2Node         = reinterpret_cast<Ext2Node*>(nodePtr);
+  ext2Node->inodeNumber = inodeNumber;
+
+  // Compute block group and index within group
+  Kernel::UInt32 inodesPerGroup = ctx->superblock->fInodesPerGroup;
+  Kernel::UInt32 group          = (inodeNumber - 1) / inodesPerGroup;
+  Kernel::UInt32 index          = (inodeNumber - 1) % inodesPerGroup;
+
+  // dummy: just offset first inode
+  Kernel::UInt32 inodeTableBlock = ctx->superblock->fFirstInode + group;
+
+  if (!ext2_read_block(ctx->drive, inodeTableBlock, &ext2Node->inode, sizeof(EXT2_INODE))) {
+    Kernel::mm_free_ptr(nodePtr);
+    return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorDisk);
+  }
+
+  ext2Node->cursor = 0;
+  return Kernel::ErrorOr<Ext2Node*>(ext2Node);
+}
+
+inline Kernel::UInt32 inode_offset(const Ext2Context* ctx, Kernel::UInt32 inodeNumber) {
+  if (!ctx || !ctx->superblock) return 0;
+  return ((inodeNumber - 1) % ctx->superblock->fInodesPerGroup) * ctx->superblock->fInodeSize;
+}
+}  // namespace Kernel::Ext2
diff --git a/dev/kernel/FSKit/Ext2.h b/dev/kernel/FSKit/Ext2.h
index 42875c47..06370a8c 100644
--- a/dev/kernel/FSKit/Ext2.h
+++ b/dev/kernel/FSKit/Ext2.h
@@ -18,126 +18,126 @@
 namespace Ext2 {
 
 /// EXT2 Constants
-#define kExt2FSMagic              (0xEF53)
-#define kExt2FSMaxFileNameLen     (255U)
-#define kExt2FSSuperblockOffset   (1024)
-#define kExt2FSRootInodeNumber    (2)
-#define kExt2FSInodeSize          (128U)
-#define kExt2FSBlockSizeBase      (1024U)
+#define kExt2FSMagic (0xEF53)
+#define kExt2FSMaxFileNameLen (255U)
+#define kExt2FSSuperblockOffset (1024)
+#define kExt2FSRootInodeNumber (2)
+#define kExt2FSInodeSize (128U)
+#define kExt2FSBlockSizeBase (1024U)
 
-#define kExt2FSRev0               (0)
-#define kExt2FSRev1               (1)
+#define kExt2FSRev0 (0)
+#define kExt2FSRev1 (1)
 
 /// EXT2 file types
 enum {
-    kExt2FileTypeUnknown      = 0,
-    kExt2FileTypeRegular      = 1,
-    kExt2FileTypeDirectory    = 2,
-    kExt2FileTypeCharDevice   = 3,
-    kExt2FileTypeBlockDevice  = 4,
-    kExt2FileTypeFIFO         = 5,
-    kExt2FileTypeSocket       = 6,
-    kExt2FileTypeSymbolicLink = 7
+  kExt2FileTypeUnknown      = 0,
+  kExt2FileTypeRegular      = 1,
+  kExt2FileTypeDirectory    = 2,
+  kExt2FileTypeCharDevice   = 3,
+  kExt2FileTypeBlockDevice  = 4,
+  kExt2FileTypeFIFO         = 5,
+  kExt2FileTypeSocket       = 6,
+  kExt2FileTypeSymbolicLink = 7
 };
 
 struct PACKED EXT2_SUPER_BLOCK final {
-    Kernel::UInt32 fInodeCount;
-    Kernel::UInt32 fBlockCount;
-    Kernel::UInt32 fReservedBlockCount;
-    Kernel::UInt32 fFreeBlockCount;
-    Kernel::UInt32 fFreeInodeCount;
-    Kernel::UInt32 fFirstDataBlock;
-    Kernel::UInt32 fLogBlockSize;
-    Kernel::UInt32 fLogFragmentSize;
-    Kernel::UInt32 fBlocksPerGroup;
-    Kernel::UInt32 fFragmentsPerGroup;
-    Kernel::UInt32 fInodesPerGroup;
-    Kernel::UInt32 fMountTime;
-    Kernel::UInt32 fWriteTime;
-    Kernel::UInt16 fMountCount;
-    Kernel::UInt16 fMaxMountCount;
-    Kernel::UInt16 fMagic;
-    Kernel::UInt16 fState;
-    Kernel::UInt16 fErrors;
-    Kernel::UInt16 fMinorRevision;
-    Kernel::UInt32 fLastCheck;
-    Kernel::UInt32 fCheckInterval;
-    Kernel::UInt32 fCreatorOS;
-    Kernel::UInt32 fRevisionLevel;
-    Kernel::UInt16 fDefaultUID;
-    Kernel::UInt16 fDefaultGID;
-
-    // EXT2_DYNAMIC_REV fields
-    Kernel::UInt32 fFirstInode;
-    Kernel::UInt16 fInodeSize;
-    Kernel::UInt16 fBlockGroupNumber;
-    Kernel::UInt32 fFeatureCompat;
-    Kernel::UInt32 fFeatureIncompat;
-    Kernel::UInt32 fFeatureROCompat;
-    Kernel::UInt8  fUUID[16];
-    Kernel::Char   fVolumeName[16];
-    Kernel::Char   fLastMounted[64];
-    Kernel::UInt32 fAlgoBitmap;
-
-    Kernel::UInt8  fPreallocBlocks;
-    Kernel::UInt8  fPreallocDirBlocks;
-    Kernel::UInt16 fReservedGDTBlocks;
-
-    Kernel::UInt8  fJournalUUID[16];
-    Kernel::UInt32 fJournalInode;
-    Kernel::UInt32 fJournalDevice;
-    Kernel::UInt32 fLastOrphan;
-
-    Kernel::UInt32 fHashSeed[4];
-    Kernel::UInt8  fDefHashVersion;
-    Kernel::UInt8  fReservedCharPad;
-    Kernel::UInt16 fReservedWordPad;
-    Kernel::UInt32 fDefaultMountOpts;
-    Kernel::UInt32 fFirstMetaBlockGroup;
-
-    Kernel::UInt8 fReserved[760]; // Padding to make 1024 bytes
+  Kernel::UInt32 fInodeCount;
+  Kernel::UInt32 fBlockCount;
+  Kernel::UInt32 fReservedBlockCount;
+  Kernel::UInt32 fFreeBlockCount;
+  Kernel::UInt32 fFreeInodeCount;
+  Kernel::UInt32 fFirstDataBlock;
+  Kernel::UInt32 fLogBlockSize;
+  Kernel::UInt32 fLogFragmentSize;
+  Kernel::UInt32 fBlocksPerGroup;
+  Kernel::UInt32 fFragmentsPerGroup;
+  Kernel::UInt32 fInodesPerGroup;
+  Kernel::UInt32 fMountTime;
+  Kernel::UInt32 fWriteTime;
+  Kernel::UInt16 fMountCount;
+  Kernel::UInt16 fMaxMountCount;
+  Kernel::UInt16 fMagic;
+  Kernel::UInt16 fState;
+  Kernel::UInt16 fErrors;
+  Kernel::UInt16 fMinorRevision;
+  Kernel::UInt32 fLastCheck;
+  Kernel::UInt32 fCheckInterval;
+  Kernel::UInt32 fCreatorOS;
+  Kernel::UInt32 fRevisionLevel;
+  Kernel::UInt16 fDefaultUID;
+  Kernel::UInt16 fDefaultGID;
+
+  // EXT2_DYNAMIC_REV fields
+  Kernel::UInt32 fFirstInode;
+  Kernel::UInt16 fInodeSize;
+  Kernel::UInt16 fBlockGroupNumber;
+  Kernel::UInt32 fFeatureCompat;
+  Kernel::UInt32 fFeatureIncompat;
+  Kernel::UInt32 fFeatureROCompat;
+  Kernel::UInt8  fUUID[16];
+  Kernel::Char   fVolumeName[16];
+  Kernel::Char   fLastMounted[64];
+  Kernel::UInt32 fAlgoBitmap;
+
+  Kernel::UInt8  fPreallocBlocks;
+  Kernel::UInt8  fPreallocDirBlocks;
+  Kernel::UInt16 fReservedGDTBlocks;
+
+  Kernel::UInt8  fJournalUUID[16];
+  Kernel::UInt32 fJournalInode;
+  Kernel::UInt32 fJournalDevice;
+  Kernel::UInt32 fLastOrphan;
+
+  Kernel::UInt32 fHashSeed[4];
+  Kernel::UInt8  fDefHashVersion;
+  Kernel::UInt8  fReservedCharPad;
+  Kernel::UInt16 fReservedWordPad;
+  Kernel::UInt32 fDefaultMountOpts;
+  Kernel::UInt32 fFirstMetaBlockGroup;
+
+  Kernel::UInt8 fReserved[760];  // Padding to make 1024 bytes
 };
 
 struct PACKED EXT2_INODE final {
-    Kernel::UInt16 fMode;
-    Kernel::UInt16 fUID;
-    Kernel::UInt32 fSize;
-    Kernel::UInt32 fAccessTime;
-    Kernel::UInt32 fCreateTime;
-    Kernel::UInt32 fModifyTime;
-    Kernel::UInt32 fDeleteTime;
-    Kernel::UInt16 fGID;
-    Kernel::UInt16 fLinksCount;
-    Kernel::UInt32 fBlocks;
-    Kernel::UInt32 fFlags;
-    Kernel::UInt32 fOSD1;
-
-    Kernel::UInt32 fBlock[15]; // direct 0-11, indirect 12, double 13, triple 14
-
-    Kernel::UInt32 fGeneration;
-    Kernel::UInt32 fFileACL;
-    Kernel::UInt32 fDirACL;
-    Kernel::UInt32 fFragmentAddr;
-
-    Kernel::UInt8 fOSD2[12];
+  Kernel::UInt16 fMode;
+  Kernel::UInt16 fUID;
+  Kernel::UInt32 fSize;
+  Kernel::UInt32 fAccessTime;
+  Kernel::UInt32 fCreateTime;
+  Kernel::UInt32 fModifyTime;
+  Kernel::UInt32 fDeleteTime;
+  Kernel::UInt16 fGID;
+  Kernel::UInt16 fLinksCount;
+  Kernel::UInt32 fBlocks;
+  Kernel::UInt32 fFlags;
+  Kernel::UInt32 fOSD1;
+
+  Kernel::UInt32 fBlock[15];  // direct 0-11, indirect 12, double 13, triple 14
+
+  Kernel::UInt32 fGeneration;
+  Kernel::UInt32 fFileACL;
+  Kernel::UInt32 fDirACL;
+  Kernel::UInt32 fFragmentAddr;
+
+  Kernel::UInt8 fOSD2[12];
 };
 
 /// Directory entry
 struct PACKED EXT2_DIR_ENTRY final {
-    Kernel::UInt32 fInode;
-    Kernel::UInt16 fRecordLength;
-    Kernel::UInt8  fNameLength;
-    Kernel::UInt8  fFileType;
-    Kernel::Char   fName[kExt2FSMaxFileNameLen]; 
+  Kernel::UInt32 fInode;
+  Kernel::UInt16 fRecordLength;
+  Kernel::UInt8  fNameLength;
+  Kernel::UInt8  fFileType;
+  Kernel::Char   fName[kExt2FSMaxFileNameLen];
 };
 
 /// VFS usage
 struct Ext2Node {
-    Kernel::UInt32 inodeNumber;
-    EXT2_INODE inode;
-    Kernel::UInt32 cursor{0}; 
+  Kernel::UInt32 inodeNumber;
+  EXT2_INODE     inode;
+  Kernel::UInt32 cursor{0};
 };
 
 class Ext2FileSystemMgr;
 
-} // namespace Ext2
+}  // namespace Ext2
diff --git a/dev/kernel/FSKit/Ext2IFS.h b/dev/kernel/FSKit/Ext2IFS.h
deleted file mode 100644
index 87095bc6..00000000
--- a/dev/kernel/FSKit/Ext2IFS.h
+++ /dev/null
@@ -1,133 +0,0 @@
-#pragma once
-
-#include <FSKit/Ext2.h>
-#include <KernelKit/DriveMgr.h>
-#include <KernelKit/HeapMgr.h>
-#include <NeKit/Utils.h>
-#include <NeKit/KernelPanic.h>
-#include <NeKit/ErrorOr.h>
-#include <KernelKit/KPC.h> 
-
-namespace Ext2 {
-
-/// @brief Context for an EXT2 filesystem on a given drive
-struct Context { 
-    Kernel::DriveTrait* drive{nullptr};
-    EXT2_SUPER_BLOCK* superblock{nullptr};
-
-    /// @brief context with a drive
-    explicit Context(Kernel::DriveTrait* drv) : drive(drv) {}
-
-     /// @brief Clean up
-    ~Context() {
-        if (superblock) {
-            Kernel::mm_free_ptr(superblock);
-            superblock = nullptr;
-        }
-    }
-
-    Context(const Context&) = delete;
-    Context& operator=(const Context&) = delete;
-
-    Context(Context&& other) noexcept : drive(other.drive), superblock(other.superblock) {
-        other.drive = nullptr;
-        other.superblock = nullptr;
-    }
-
-    Context& operator=(Context&& other) noexcept {
-        if (this != &other) {
-            if (superblock) {
-                Kernel::mm_free_ptr(superblock);
-            }
-            drive = other.drive;
-            superblock = other.superblock;
-            other.drive = nullptr;
-            other.superblock = nullptr;
-        }
-        return *this;
-    }
-
-    inline Kernel::UInt32 BlockSize() const { 
-        if (!superblock) return kExt2FSBlockSizeBase;
-        return kExt2FSBlockSizeBase << superblock->fLogBlockSize;
-    }
-};
-
-inline bool ext2_read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, void* buffer, Kernel::UInt32 size) { 
-    if (!drv || !buffer) return false;
-
-    Kernel::DriveTrait::DrivePacket pkt{};
-    pkt.fPacketContent = buffer;
-    pkt.fPacketSize = size;
-    pkt.fPacketLba = lba;
-    drv->fInput(pkt);
-    return pkt.fPacketGood;
-}
-
-inline bool ext2_write_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, const void* buffer, Kernel::UInt32 size) { 
-    if (!drv || !buffer) return false;
-
-    Kernel::DriveTrait::DrivePacket pkt{};
-    pkt.fPacketContent = const_cast<void*>(buffer);
-    pkt.fPacketSize = size;
-    pkt.fPacketLba = lba;
-    drv->fOutput(pkt);
-    return pkt.fPacketGood;
-}
-
-// Load superblock
-inline Kernel::ErrorOr<EXT2_SUPER_BLOCK*> ext2_load_superblock(Context* ctx) {
-    if (!ctx || !ctx->drive) return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorInvalidData); 
-
-    auto buf = Kernel::mm_alloc_ptr(sizeof(EXT2_SUPER_BLOCK), true, false);
-    if (!buf) return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorHeapOutOfMemory); 
-
-    Kernel::UInt32 blockLba = kExt2FSSuperblockOffset / ctx->drive->fSectorSz;
-    if (!ext2_read_block(ctx->drive, blockLba, buf, sizeof(EXT2_SUPER_BLOCK))) { 
-        Kernel::mm_free_ptr(buf);
-        return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorDisk); 
-    }
-
-    auto sb = reinterpret_cast<EXT2_SUPER_BLOCK*>(buf);
-    if (sb->fMagic != kExt2FSMagic) {
-        Kernel::mm_free_ptr(buf);
-        return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(Kernel::kErrorInvalidData); 
-    }
-
-    ctx->superblock = sb;
-    return Kernel::ErrorOr<EXT2_SUPER_BLOCK*>(sb); 
-}
-
-// Load inode
-inline Kernel::ErrorOr<Ext2Node*> ext2_load_inode(Context* ctx, Kernel::UInt32 inodeNumber) { 
-    if (!ctx || !ctx->superblock) return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorInvalidData); 
-
-    auto nodePtr = Kernel::mm_alloc_ptr(sizeof(Ext2Node), true, false);
-    if (!nodePtr) return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorHeapOutOfMemory);
-
-    auto ext2Node = reinterpret_cast<Ext2Node*>(nodePtr);
-    ext2Node->inodeNumber = inodeNumber;
-
-    // Compute block group and index within group
-    Kernel::UInt32 inodesPerGroup = ctx->superblock->fInodesPerGroup;
-    Kernel::UInt32 group = (inodeNumber - 1) / inodesPerGroup;
-    Kernel::UInt32 index = (inodeNumber - 1) % inodesPerGroup;
-
-    // dummy: just offset first inode
-    Kernel::UInt32 inodeTableBlock = ctx->superblock->fFirstInode + group;
-
-    if (!ext2_read_block(ctx->drive, inodeTableBlock, &ext2Node->inode, sizeof(EXT2_INODE))) { 
-        Kernel::mm_free_ptr(nodePtr);
-        return Kernel::ErrorOr<Ext2Node*>(Kernel::kErrorDisk);
-    }
-
-    ext2Node->cursor = 0;
-    return Kernel::ErrorOr<Ext2Node*>(ext2Node); 
-}
-
-inline Kernel::UInt32 inode_offset(const Context* ctx, Kernel::UInt32 inodeNumber) {
-    if (!ctx || !ctx->superblock) return 0;
-    return ((inodeNumber - 1) % ctx->superblock->fInodesPerGroup) * ctx->superblock->fInodeSize;
-}
-
-} // namespace Ext2
diff --git a/dev/kernel/HALKit/AMD64/CxxAbi.cc b/dev/kernel/HALKit/AMD64/CxxAbi.cc
index cd135abc..84a00449 100644
--- a/dev/kernel/HALKit/AMD64/CxxAbi.cc
+++ b/dev/kernel/HALKit/AMD64/CxxAbi.cc
@@ -62,17 +62,18 @@ EXTERN_C void __cxa_finalize(void* f) {
 }
 
 namespace cxxabiv1 {
-EXTERN_C int __cxa_guard_acquire(__guard* g) {
-  (void) g;
+EXTERN_C int __cxa_guard_acquire(__guard g) {
+  if ((*g & 1) || (*g & 2)) return 1;
+  *g |= 2;
   return 0;
 }
 
-EXTERN_C int __cxa_guard_release(__guard* g) {
-  *(char*) g = 1;
-  return 0;
+EXTERN_C void __cxa_guard_release(__guard g) {
+  *g |= 1;
+  *g &= 2;
 }
 
-EXTERN_C void __cxa_guard_abort(__guard* g) {
-  (void) g;
+EXTERN_C void __cxa_guard_abort(__guard g) {
+  *g &= ~2;
 }
 }  // namespace cxxabiv1
diff --git a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
index df5386e4..e3e08830 100644
--- a/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
+++ b/dev/kernel/HALKit/AMD64/HalApplicationProcessor.cc
@@ -88,7 +88,7 @@ struct LAPIC final {
 /// @param target
 /// @return
 /***********************************************************************************/
-Void hal_send_ipi_msg(UInt32 target, UInt32 apic_id, UInt8 vector) {
+EXTERN_C Void hal_send_ipi_msg(UInt32 target, UInt32 apic_id, UInt8 vector) {
   Kernel::ke_dma_write<UInt32>(target, APIC_ICR_HIGH, apic_id << 24);
   Kernel::ke_dma_write<UInt32>(target, APIC_ICR_LOW, 0x00000600 | 0x00004000 | 0x00000000 | vector);
 
@@ -200,10 +200,7 @@ Void mp_init_cores(VoidPtr vendor_ptr) noexcept {
       UInt8 type   = *entry_ptr;
       UInt8 length = *(entry_ptr + 1);
 
-      // Avoid infinite loop on bad APIC tables.
-      if (length < 2) break;
-
-      if (type == 0) {
+      if (type == 0 && length == sizeof(struct LAPIC)) {
         volatile LAPIC* entry_struct = (volatile LAPIC*) entry_ptr;
 
         if (entry_struct->Flags & 0x1) {
@@ -212,15 +209,15 @@ Void mp_init_cores(VoidPtr vendor_ptr) noexcept {
 
           ++kSMPCount;
 
-          kout << "Kind: LAPIC: ON\r";
+          kout << "AP: kind: LAPIC: ON.\r";
 
           // 0x7c00, as recommended by the Intel SDM.
           hal_send_ipi_msg(kApicBaseAddress, entry_struct->ProcessorID, 0x7c);
         } else {
-          kout << "Kind: LAPIC: OFF\r";
+          kout << "AP: kind: LAPIC: OFF.\r";
         }
       } else {
-        kout << "Kind: UNKNOWN: OFF\r";
+        kout << "AP: kind: UNKNOWN: OFF.\r";
       }
 
       entry_ptr += length;
diff --git a/dev/kernel/HALKit/AMD64/HalKernelMain.cc b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
index f121fbb4..6f4d7e0a 100644
--- a/dev/kernel/HALKit/AMD64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/AMD64/HalKernelMain.cc
@@ -32,17 +32,14 @@ EXTERN_C Int32 hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
 
   HAL::rt_sti();
 
-  kHandoverHeader = handover_hdr;
-
-  FB::fb_clear_video();
-
   fw_init_efi((EfiSystemTable*) handover_hdr->f_FirmwareCustomTables[1]);
 
   Boot::ExitBootServices(handover_hdr->f_HardwareTables.f_ImageKey,
                          handover_hdr->f_HardwareTables.f_ImageHandle);
 
-  kBitMapCursor = 0UL;
-  kKernelVM     = kHandoverHeader->f_PageStart;
+  kHandoverHeader = handover_hdr;
+
+  kKernelVM = kHandoverHeader->f_PageStart;
 
   if (!kKernelVM) {
     MUST_PASS(kKernelVM);
@@ -55,6 +52,7 @@ EXTERN_C Int32 hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
   /*     INITIALIZE BIT MAP.              */
   /************************************** */
 
+  kBitMapCursor    = 0UL;
   kKernelBitMpSize = kHandoverHeader->f_BitMapSize;
   kKernelBitMpStart =
       reinterpret_cast<VoidPtr>(reinterpret_cast<UIntPtr>(kHandoverHeader->f_BitMapStart));
@@ -120,6 +118,8 @@ EXTERN_C Int32 hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
   kGDTArray[4].fFlags      = 0;
   kGDTArray[4].fBaseHigh   = 0;
 
+  FB::fb_clear_video();
+
   // Load memory descriptors.
   HAL::Register64 gdt_reg;
 
@@ -133,24 +133,14 @@ EXTERN_C Int32 hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
   return kEfiFail;
 }
 
-EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept {
+EXTERN_C Kernel::Void hal_real_init(Kernel::Void) {
   using namespace Kernel;
 
-  for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Capacity(); ++index) {
-    HardwareThreadScheduler::The()[index].Leak()->Kind() = ThreadKind::kAPStandard;
-    HardwareThreadScheduler::The()[index].Leak()->ID()   = index;
-    HardwareThreadScheduler::The()[index].Leak()->Busy(NO);
-  }
-
-  for (SizeT index = 0UL; index < UserProcessScheduler::The().TheCurrentTeam().AsArray().Count();
-       ++index) {
-    UserProcessScheduler::The().TheCurrentTeam().AsArray()[index].Status =
-        ProcessStatusKind::kInvalid;
-  }
+  HAL::Register64 idt_reg;
+  idt_reg.Base = reinterpret_cast<UIntPtr>(kInterruptVectorTable);
 
-  rtl_create_user_process(sched_idle_task, "MgmtSrv");    //! Mgmt command server.
-  rtl_create_user_process(sched_idle_task, "LaunchSrv");  //! launchd
-  rtl_create_user_process(sched_idle_task, "SecSrv");     //! Login Server
+  HAL::IDTLoader idt_loader;
+  idt_loader.Load(idt_reg);
 
   HAL::mp_init_cores(kHandoverHeader->f_HardwareTables.f_VendorPtr);
 
@@ -162,13 +152,6 @@ EXTERN_C Kernel::Void hal_real_init(Kernel::Void) noexcept {
   NeFS::fs_init_nefs();
 #endif
 
-  HAL::Register64 idt_reg;
-  idt_reg.Base = reinterpret_cast<UIntPtr>(kInterruptVectorTable);
-
-  HAL::IDTLoader idt_loader;
-
-  idt_loader.Load(idt_reg);
-
   while (YES)
     ;
 }
diff --git a/dev/kernel/HALKit/ARM64/HalKernelMain.cc b/dev/kernel/HALKit/ARM64/HalKernelMain.cc
index d7663f4e..b711b833 100644
--- a/dev/kernel/HALKit/ARM64/HalKernelMain.cc
+++ b/dev/kernel/HALKit/ARM64/HalKernelMain.cc
@@ -35,10 +35,6 @@ EXTERN_C void hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
     return;
   }
 
-  FB::fb_clear_video();
-
-  kBitMapCursor = 0UL;
-
 #ifdef __NE_ARM64_EFI__
   fw_init_efi((EfiSystemTable*) handover_hdr->f_FirmwareCustomTables[1]);
 
@@ -46,31 +42,19 @@ EXTERN_C void hal_init_platform(Kernel::HEL::BootInfoHeader* handover_hdr) {
                          handover_hdr->f_HardwareTables.f_ImageHandle);
 #endif
 
+  FB::fb_clear_video();
+
   /************************************** */
   /*     INITIALIZE BIT MAP.              */
   /************************************** */
 
+  kBitMapCursor     = 0UL;
   kKernelBitMpSize  = kHandoverHeader->f_BitMapSize;
   kKernelBitMpStart = reinterpret_cast<Kernel::VoidPtr>(
       reinterpret_cast<Kernel::UIntPtr>(kHandoverHeader->f_BitMapStart));
 
   /// @note do initialize the interrupts after it.
 
-  for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Capacity(); ++index) {
-    HardwareThreadScheduler::The()[index].Leak()->Kind() = ThreadKind::kAPStandard;
-    HardwareThreadScheduler::The()[index].Leak()->Busy(NO);
-  }
-
-  for (SizeT index = 0UL; index < UserProcessScheduler::The().TheCurrentTeam().AsArray().Count();
-       ++index) {
-    UserProcessScheduler::The().TheCurrentTeam().AsArray()[index].Status =
-        ProcessStatusKind::kInvalid;
-  }
-
-  rtl_create_user_process(sched_idle_task, "MgmtSrv");    //! Mgmt command server.
-  rtl_create_user_process(sched_idle_task, "LaunchSrv");  //! launchd
-  rtl_create_user_process(sched_idle_task, "SecSrv");     //! Login Server
-
   Kernel::mp_init_cores();
 
   while (YES)
diff --git a/dev/kernel/NeKit/CxxAbi.h b/dev/kernel/NeKit/CxxAbi.h
index 164a257d..4b7bf002 100644
--- a/dev/kernel/NeKit/CxxAbi.h
+++ b/dev/kernel/NeKit/CxxAbi.h
@@ -7,7 +7,7 @@
 
 #include <NeKit/Defines.h>
 
-#ifndef __TOOLCHAINKIT__
+#ifndef __NECTI__
 
 #define kAtExitMacDestructors (128)
 
@@ -17,10 +17,10 @@ struct atexit_func_entry_t {
   void* dso_handle;
 };
 
-typedef unsigned uarch_t;
+typedef Kernel::UInt32 uarch_t;
 
 namespace cxxabiv1 {
-typedef void* __guard;
+typedef Kernel::SizeT* __guard;
 }
 
-#endif  // __GNUC__
+#endif  // !__NECTI__
diff --git a/dev/kernel/NeKit/ErrorOr.h b/dev/kernel/NeKit/ErrorOr.h
index b653e0ee..52f0d6a9 100644
--- a/dev/kernel/NeKit/ErrorOr.h
+++ b/dev/kernel/NeKit/ErrorOr.h
@@ -38,6 +38,8 @@ class ErrorOr final {
     return *this;
   }
 
+  T Value() const { return *mRef; }
+  
   Ref<T>& Leak() { return mRef; }
 
   Int32 Error() { return mId; }
diff --git a/dev/kernel/src/ACPIFactoryInterface.cc b/dev/kernel/src/ACPIFactoryInterface.cc
index 711ea588..6cebf26c 100644
--- a/dev/kernel/src/ACPIFactoryInterface.cc
+++ b/dev/kernel/src/ACPIFactoryInterface.cc
@@ -70,7 +70,7 @@ ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
 @param len the length of it.
 */
 bool ACPIFactoryInterface::Checksum(const Char* checksum, SSizeT len) {
-  if (len == 0 || !checksum) return false;
+  if (len == 0 || !checksum) return NO;
 
   Char chr = 0;
 
diff --git a/dev/kernel/src/AsciiUtils.cc b/dev/kernel/src/AsciiUtils.cc
index 24e4e220..cca3a368 100644
--- a/dev/kernel/src/AsciiUtils.cc
+++ b/dev/kernel/src/AsciiUtils.cc
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-Int     rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size);
+Int32   rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size);
 voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size);
 
 Int32 rt_string_cmp(const Char* src, const Char* cmp, Size size) {
@@ -45,7 +45,7 @@ const Char* rt_alloc_string(const Char* src) {
   return buffer;
 }
 
-Int rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size) {
+Int32 rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size) {
   if (!src || !dst || len > dst_size) {
     if (dst && dst_size) {
       rt_set_memory_safe(dst, 0, dst_size, dst_size);
@@ -85,7 +85,7 @@ rt_set_memory(voidPtr src, UInt32 value, Size len) {
 #ifdef __NE_ENFORCE_DEPRECATED_WARNINGS
 [[deprecated("Use rt_copy_memory_safe instead")]]
 #endif
-Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
+Int32 rt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
   if (!src || !dst) return -1;
   auto s = reinterpret_cast<const UInt8*>(src);
   auto d = reinterpret_cast<UInt8*>(dst);
@@ -134,11 +134,15 @@ Bool rt_to_string(Char* str, UInt64 value, Int32 base) {
     str[j]         = str[i - j - 1];
     str[i - j - 1] = tmp;
   }
+
+  return YES;
 #endif
-  return true;
+  return NO;
 }
 
 VoidPtr rt_string_in_string(const Char* haystack, const Char* needle) {
+  if (!haystack || !needle) return nullptr;
+
   SizeT needle_len = rt_string_len(needle);
   SizeT hay_len    = rt_string_len(haystack);
 
@@ -152,6 +156,7 @@ VoidPtr rt_string_in_string(const Char* haystack, const Char* needle) {
 }
 
 Char* rt_string_has_char(Char* str, Char ch) {
+  if (!str) return nullptr;
   while (*str && *str != ch) ++str;
   return (*str == ch) ? str : nullptr;
 }
@@ -166,7 +171,7 @@ EXTERN_C void* memcpy(void* dst, const void* src, long long unsigned int len) {
   return dst;
 }
 
-EXTERN_C Kernel::Int32 strcmp(const char* a, const char* b) {
+EXTERN_C Int32 strcmp(const char* a, const char* b) {
   return Kernel::rt_string_cmp(a, b, rt_string_len(a));
 }
 
diff --git a/dev/kernel/src/FS/Ext2+FileSystemParser.cc b/dev/kernel/src/FS/Ext2+FileSystemParser.cc
index 80449ed9..318f83d6 100644
--- a/dev/kernel/src/FS/Ext2+FileSystemParser.cc
+++ b/dev/kernel/src/FS/Ext2+FileSystemParser.cc
@@ -6,7 +6,7 @@
 
 #ifdef __FSKIT_INCLUDES_EXT2__
 
-#include <FSKit/Ext2.h>
+#include <FSKit/Ext2+IFS.h>
 #include <FirmwareKit/EPM.h>
 #include <KernelKit/KPC.h>
 #include <KernelKit/ProcessScheduler.h>
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index 174862a4..07c4a572 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -438,7 +438,7 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
   }
 
   (Void)(kout << "ProcessID: " << number(process.ProcessId) << kendl);
-  (Void)(kout << "Name: " << process.Name << kendl);
+  (Void)(kout << "ProcesName: " << process.Name << kendl);
 
   return pid;
 }
diff --git a/dev/kernel/src/UtfUtils.cc b/dev/kernel/src/UtfUtils.cc
index 907632ad..e98b8306 100644
--- a/dev/kernel/src/UtfUtils.cc
+++ b/dev/kernel/src/UtfUtils.cc
@@ -37,7 +37,7 @@ Int32 urt_string_cmp(const Utf8Char* src, const Utf8Char* cmp, Size size) {
   return counter;
 }
 
-Int urt_copy_memory(const VoidPtr src, VoidPtr dst, Size len) {
+Int32 urt_copy_memory(const VoidPtr src, VoidPtr dst, Size len) {
   Utf8Char* srcChr  = reinterpret_cast<Utf8Char*>(src);
   Utf8Char* dstChar = reinterpret_cast<Utf8Char*>(dst);