Merge pull request #55 from nekernel-org/dev

v0.0.4

25 files changed, 266 insertions, 327 deletions

diff --git a/dev/kernel/src/ACPIFactoryInterface.cc b/dev/kernel/src/ACPIFactoryInterface.cc
index 8cc11cad..01f30500 100644
--- a/dev/kernel/src/ACPIFactoryInterface.cc
+++ b/dev/kernel/src/ACPIFactoryInterface.cc
@@ -10,12 +10,11 @@
 #include <modules/ACPI/ACPIFactoryInterface.h>
 
 namespace Kernel {
-constexpr STATIC const auto kMinACPIVer = 1;
+constexpr STATIC const auto kMinACPIVer = 1U;
 
 /// @brief Finds a descriptor table inside ACPI XSDT.
 ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
-  MUST_PASS(this->fRsdp);
-
+  if (this->fRsdp) return ErrorOr<voidPtr>{kErrorInvalidData};
   if (!signature) return ErrorOr<voidPtr>{-kErrorInvalidData};
   if (*signature == 0) return ErrorOr<voidPtr>{-kErrorInvalidData};
 
@@ -33,7 +32,7 @@ ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
   if (num < 1) {
     /// stop here, we should have entries...
     ke_panic(RUNTIME_CHECK_ACPI);
-    return ErrorOr<voidPtr>{-1};
+    return ErrorOr<voidPtr>{-kErrorInvalidData};
   }
 
   this->fEntries = num;
@@ -62,7 +61,7 @@ ErrorOr<voidPtr> ACPIFactoryInterface::Find(const Char* signature) {
     }
   }
 
-  return ErrorOr<voidPtr>{-1};
+  return ErrorOr<voidPtr>{-kErrorInvalidData};
 }
 
 /***
diff --git a/dev/kernel/src/AsciiUtils.cc b/dev/kernel/src/AsciiUtils.cc
index bfc56aec..66a4aaef 100644
--- a/dev/kernel/src/AsciiUtils.cc
+++ b/dev/kernel/src/AsciiUtils.cc
@@ -8,8 +8,8 @@
 
 namespace Kernel {
 
-STATIC Int     rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size);
-STATIC voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size);
+Int     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) {
   for (Size i = 0; i < size; ++i) {
@@ -45,7 +45,7 @@ const Char* rt_alloc_string(const Char* src) {
   return buffer;
 }
 
-STATIC Int rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size) {
+Int 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);
@@ -58,7 +58,7 @@ STATIC Int rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size ds
   return static_cast<Int>(len);
 }
 
-STATIC voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size) {
+voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size) {
   if (!dst || len > dst_size) return nullptr;
   auto  p = reinterpret_cast<UInt8*>(dst);
   UInt8 v = static_cast<UInt8>(value & 0xFF);
@@ -73,8 +73,7 @@ Void rt_zero_memory(voidPtr pointer, Size len) {
 #ifdef __NE_ENFORCE_DEPRECATED_WARNINGS
 [[deprecated("Use rt_set_memory_safe instead")]]
 #endif
-voidPtr
-rt_set_memory(voidPtr src, UInt32 value, Size len) {
+voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len) {
   if (!src) return nullptr;
   auto  p = reinterpret_cast<UInt8*>(src);
   UInt8 v = static_cast<UInt8>(value & 0xFF);
@@ -156,26 +155,18 @@ Char* rt_string_has_char(Char* str, Char ch) {
   return (*str == ch) ? str : nullptr;
 }
 
-Int32 rt_strcmp(const Char* a, const Char* b) {
-  Size i = 0;
-  while (a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) {
-    ++i;
-  }
-  return static_cast<Int32>(static_cast<UInt8>(a[i]) - static_cast<UInt8>(b[i]));
-}
-
-// @uses the deprecated version callers should ensure 'len' is valid.
-extern "C" void* memset(void* dst, int c, long long unsigned int len) {
-  return Kernel::rt_set_memory(dst, c, static_cast<Size>(len));
+EXTERN_C void* memset(void* dst, int c, long long unsigned int len) {
+  return Kernel::rt_set_memory_safe(dst, c, static_cast<Size>(len), static_cast<Size>(len));
 }
 
-extern "C" void* memcpy(void* dst, const void* src, long long unsigned int len) {
-  Kernel::rt_copy_memory(const_cast<void*>(src), dst, static_cast<Size>(len));
+EXTERN_C void* memcpy(void* dst, const void* src, long long unsigned int len) {
+  Kernel::rt_copy_memory_safe(const_cast<void*>(src), dst, static_cast<Size>(len),
+                              static_cast<Size>(len));
   return dst;
 }
 
-extern "C" Kernel::Int32 strcmp(const char* a, const char* b) {
-  return Kernel::rt_strcmp(a, b);
+EXTERN_C Kernel::Int32 strcmp(const char* a, const char* b) {
+  return Kernel::rt_string_cmp(a, b, rt_string_len(a));
 }
 
 }  // namespace Kernel
diff --git a/dev/kernel/src/BinaryMutex.cc b/dev/kernel/src/BinaryMutex.cc
index bbf7a477..9bfb89d9 100644
--- a/dev/kernel/src/BinaryMutex.cc
+++ b/dev/kernel/src/BinaryMutex.cc
@@ -11,10 +11,10 @@ namespace Kernel {
 /***********************************************************************************/
 /// @brief Unlocks the binary mutex.
 /***********************************************************************************/
+
 Bool BinaryMutex::Unlock() noexcept {
-  if (fLockingProcess.Status == ProcessStatusKind::kRunning) {
-    fLockingProcess        = USER_PROCESS();
-    fLockingProcess.Status = ProcessStatusKind::kFrozen;
+  if (fLockingProcess->Status == ProcessStatusKind::kRunning) {
+    fLockingProcess = nullptr;
 
     return Yes;
   }
@@ -25,7 +25,8 @@ Bool BinaryMutex::Unlock() noexcept {
 /***********************************************************************************/
 /// @brief Locks process in the binary mutex.
 /***********************************************************************************/
-Bool BinaryMutex::Lock(USER_PROCESS& process) {
+
+Bool BinaryMutex::Lock(USER_PROCESS* process) {
   if (!process || this->IsLocked()) return No;
 
   this->fLockingProcess = process;
@@ -36,14 +37,16 @@ Bool BinaryMutex::Lock(USER_PROCESS& process) {
 /***********************************************************************************/
 /// @brief Checks if process is locked.
 /***********************************************************************************/
+
 Bool BinaryMutex::IsLocked() const {
-  return this->fLockingProcess.Status == ProcessStatusKind::kRunning;
+  return this->fLockingProcess->Status == ProcessStatusKind::kRunning;
 }
 
 /***********************************************************************************/
 /// @brief Try lock or wait.
 /***********************************************************************************/
-Bool BinaryMutex::LockOrWait(USER_PROCESS& process, TimerInterface* timer) {
+
+Bool BinaryMutex::LockOrWait(USER_PROCESS* process, TimerInterface* timer) {
   if (timer == nullptr) return No;
 
   this->Lock(process);
@@ -57,7 +60,8 @@ Bool BinaryMutex::LockOrWait(USER_PROCESS& process, TimerInterface* timer) {
 /// @brief Wait for process **sec** until we check if it's free.
 /// @param sec seconds.
 /***********************************************************************************/
-BOOL BinaryMutex::WaitForProcess(const Int16& sec) noexcept {
+
+BOOL BinaryMutex::WaitForProcess(const UInt32& sec) noexcept {
   HardwareTimer hw_timer(rtl_milliseconds(sec));
   hw_timer.Wait();
 
diff --git a/dev/kernel/src/BitMapMgr.cc b/dev/kernel/src/BitMapMgr.cc
index df678d41..22737dbe 100644
--- a/dev/kernel/src/BitMapMgr.cc
+++ b/dev/kernel/src/BitMapMgr.cc
@@ -19,6 +19,8 @@
 #define kBitMapSizeIdx (1U)
 #define kBitMapUsedIdx (2U)
 
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
+
 namespace Kernel {
 namespace HAL {
   namespace Detail {
diff --git a/dev/kernel/src/Crc32.cc b/dev/kernel/src/Crc32.cc
index fddcb095..46a1d940 100644
--- a/dev/kernel/src/Crc32.cc
+++ b/dev/kernel/src/Crc32.cc
@@ -49,11 +49,13 @@ UInt32 kChecksumPolys[kCrcCnt] = {
 /// @param in the data to compute.
 /// @param len the length of the data.
 /// @return CRC32 of **in**.
-UInt32 ke_calculate_crc32(const Char* in, Int32 len) noexcept {
-  if (!in || *in == 0) return ~0;
+UInt32 ke_calculate_crc32(const VoidPtr inp, Int32 len) noexcept {
+  if (!inp) return ~0;
 
   UInt32 crc = 0xffffffff;
 
+  Char* in = static_cast<Char*>(inp);
+
   while ((len--) > 0) crc = (crc >> 8) ^ kChecksumPolys[(crc ^ *(in++)) & 0xFF];
 
   return ~crc;
diff --git a/dev/kernel/src/CxxAbi-AMD64.cc b/dev/kernel/src/CxxAbi-AMD64.cc
deleted file mode 100644
index 30c8306e..00000000
--- a/dev/kernel/src/CxxAbi-AMD64.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-/* -------------------------------------------
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
-
-------------------------------------------- */
-
-#ifdef __NE_AMD64__
-
-#include <KernelKit/DebugOutput.h>
-#include <KernelKit/KPC.h>
-#include <KernelKit/UserProcessScheduler.h>
-#include <NeKit/CxxAbi.h>
-
-atexit_func_entry_t __atexit_funcs[kAtExitMacDestructors];
-
-uarch_t __atexit_func_count;
-
-/// @brief dynamic shared object Handle.
-Kernel::UIntPtr __dso_handle;
-
-EXTERN_C Kernel::Void __cxa_pure_virtual(void* self) {
-  (Kernel::Void)(Kernel::kout << "object: "
-                              << Kernel::number(reinterpret_cast<Kernel::UIntPtr>(self)));
-  (Kernel::Void)(Kernel::kout << ", has unimplemented virtual functions.\r");
-}
-
-EXTERN_C void ___chkstk_ms(PtrDiff frame_size) {
-  char* sp;
-  asm volatile("mov %%rsp, %0" : "=r"(sp));
-
-  for (PtrDiff offset = kPageSize; offset < frame_size; offset += kPageSize) {
-    sp[-offset] = 0;
-  }
-}
-
-EXTERN_C int atexit(void (*f)()) {
-  if (__atexit_func_count >= kAtExitMacDestructors) return 1;
-
-  __atexit_funcs[__atexit_func_count].destructor_func = f;
-
-  __atexit_func_count++;
-
-  return 0;
-}
-
-EXTERN_C void __cxa_finalize(void* f) {
-  uarch_t i = __atexit_func_count;
-  if (!f) {
-    while (i--) {
-      if (__atexit_funcs[i].destructor_func) {
-        (*__atexit_funcs[i].destructor_func)();
-      };
-    }
-
-    return;
-  }
-
-  while (i--) {
-    if (__atexit_funcs[i].destructor_func) {
-      (*__atexit_funcs[i].destructor_func)();
-      __atexit_funcs[i].destructor_func = 0;
-    };
-  }
-}
-
-namespace cxxabiv1 {
-EXTERN_C int __cxa_guard_acquire(__guard* g) {
-  (void) g;
-  return 0;
-}
-
-EXTERN_C int __cxa_guard_release(__guard* g) {
-  *(char*) g = 1;
-  return 0;
-}
-
-EXTERN_C void __cxa_guard_abort(__guard* g) {
-  (void) g;
-}
-}  // namespace cxxabiv1
-
-#endif  // ifdef __NE_AMD64__
diff --git a/dev/kernel/src/CxxAbi-ARM64.cc b/dev/kernel/src/CxxAbi-ARM64.cc
deleted file mode 100644
index e91eb958..00000000
--- a/dev/kernel/src/CxxAbi-ARM64.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -------------------------------------------
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
-
-------------------------------------------- */
-
-#ifdef __NE_ARM64__
-
-#include <KernelKit/DebugOutput.h>
-#include <KernelKit/KPC.h>
-#include <NeKit/CxxAbi.h>
-
-atexit_func_entry_t __atexit_funcs[kAtExitMacDestructors];
-
-uarch_t __atexit_func_count;
-
-/// @brief dynamic shared object Handle.
-Kernel::UIntPtr __dso_handle;
-
-EXTERN_C void __chkstk(void) {}
-
-EXTERN_C int atexit(void (*f)(), void* arg, void* dso) {
-  if (__atexit_func_count >= kAtExitMacDestructors) return 1;
-
-  __atexit_funcs[__atexit_func_count].destructor_func = f;
-  __atexit_funcs[__atexit_func_count].obj_ptr         = arg;
-  __atexit_funcs[__atexit_func_count].dso_handle      = dso;
-
-  __atexit_func_count++;
-
-  return 0;
-}
-
-EXTERN_C void __cxa_finalize(void* f) {
-  uarch_t i = __atexit_func_count;
-  if (!f) {
-    while (i--) {
-      if (__atexit_funcs[i].destructor_func) {
-        (*__atexit_funcs[i].destructor_func)();
-        __atexit_funcs[i].destructor_func = 0;
-      };
-    }
-
-    return;
-  }
-
-  while (i--) {
-    if (__atexit_funcs[i].destructor_func) {
-      (*__atexit_funcs[i].destructor_func)();
-      __atexit_funcs[i].destructor_func = 0;
-    };
-  }
-}
-
-namespace cxxabiv1 {
-EXTERN_C int __cxa_guard_acquire(__guard* g) {
-  (void) g;
-  return 0;
-}
-
-EXTERN_C int __cxa_guard_release(__guard* g) {
-  *(char*) g = 1;
-  return 0;
-}
-
-EXTERN_C void __cxa_guard_abort(__guard* g) {
-  (void) g;
-}
-}  // namespace cxxabiv1
-
-EXTERN_C Kernel::Void _purecall(void* self) {
-  (Kernel::Void)(Kernel::kout << "object: "
-                              << Kernel::number(reinterpret_cast<Kernel::UIntPtr>(self)));
-  (Kernel::Void)(Kernel::kout << ", has unimplemented virtual functions.\r");
-}
-
-EXTERN_C Kernel::Void _Init_thread_footer(Kernel::Int* thread_obj) {
-  NE_UNUSED(thread_obj);
-}
-
-EXTERN_C Kernel::Void _Init_thread_epoch(Kernel::Void) {
-  NE_UNUSED(0);
-}
-
-EXTERN_C Kernel::Void _Init_thread_header(Kernel::Int* thread_obj) {
-  NE_UNUSED(0);
-}
-
-EXTERN_C Kernel::Int _tls_index = 0UL;
-
-#endif  // ifdef __NE_ARM64__
diff --git a/dev/kernel/src/DriveMgr.cc b/dev/kernel/src/DriveMgr.cc
index b7c181c8..9f107e97 100644
--- a/dev/kernel/src/DriveMgr.cc
+++ b/dev/kernel/src/DriveMgr.cc
@@ -15,7 +15,8 @@
 
 /***********************************************************************************/
 /// @file DriveMgr.cc
-/// @brief Drive Manager of kernel.
+/// @brief Drive Manager of NeKernel.
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 /***********************************************************************************/
 
 namespace Kernel {
diff --git a/dev/kernel/src/FS/HeFS+FileSystemParser.cc b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
index 39f8c0a1..344369d5 100644
--- a/dev/kernel/src/FS/HeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/HeFS+FileSystemParser.cc
@@ -89,6 +89,8 @@ namespace Detail {
   /// @param path the directory path.
   /// @return The hashed path.
   STATIC UInt64 hefsi_hash_64(const Utf8Char* path) {
+    if (!path || *path == 0) return 0;
+
     const UInt64 FNV_OFFSET_BASIS = 0xcbf29ce484222325ULL;
     const UInt64 FNV_PRIME        = 0x100000001b3ULL;
 
@@ -798,11 +800,11 @@ _Output Bool HeFileSystemParser::Format(_Input _Output DriveTrait* mnt, _Input c
     return NO;
   }
 
-  rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
-                 rt_string_len("fs/hefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
+                      rt_string_len("fs/hefs-packet"), sizeof(mnt->fPacket.fPacketMime));
 
   urt_copy_memory((VoidPtr) vol_name, boot->fVolName, urt_string_len(vol_name) + 1);
-  rt_copy_memory((VoidPtr) kHeFSMagic, boot->fMagic, kHeFSMagicLen - 1);
+  rt_copy_memory_safe((VoidPtr) kHeFSMagic, boot->fMagic, kHeFSMagicLen - 1, sizeof(boot->fMagic));
 
   if (mnt->fLbaStart > mnt->fLbaEnd) {
     err_global_get() = kErrorDiskIsCorrupted;
@@ -906,8 +908,8 @@ _Output Bool HeFileSystemParser::INodeDirectoryCtlManip(_Input DriveTrait* mnt,
 
   HEFS_BOOT_NODE* boot = (HEFS_BOOT_NODE*) mm_alloc_ptr(sizeof(HEFS_BOOT_NODE), Yes, No);
 
-  rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
-                 rt_string_len("fs/hefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
+                      rt_string_len("fs/hefs-packet"), sizeof(mnt->fPacket.fPacketMime));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
@@ -992,8 +994,8 @@ _Output Bool HeFileSystemParser::INodeManip(_Input DriveTrait* mnt, VoidPtr bloc
     return NO;
   }
 
-  rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
-                 rt_string_len("fs/hefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
+                      rt_string_len("fs/hefs-packet"), sizeof(mnt->fPacket.fPacketMime));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
@@ -1078,8 +1080,8 @@ _Output Bool HeFileSystemParser::INodeCtlManip(_Input DriveTrait* mnt, _Input co
     return NO;
   }
 
-  rt_copy_memory((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
-                 rt_string_len("fs/hefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/hefs-packet", mnt->fPacket.fPacketMime,
+                      rt_string_len("fs/hefs-packet"), sizeof(mnt->fPacket.fPacketMime));
 
   mnt->fPacket.fPacketLba     = mnt->fLbaStart;
   mnt->fPacket.fPacketSize    = sizeof(HEFS_BOOT_NODE);
diff --git a/dev/kernel/src/FS/NeFS+FileSystemParser.cc b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
index 18595e9f..7b9ebcd6 100644
--- a/dev/kernel/src/FS/NeFS+FileSystemParser.cc
+++ b/dev/kernel/src/FS/NeFS+FileSystemParser.cc
@@ -154,8 +154,8 @@ _Output BOOL NeFileSystemParser::CreateFork(_Input NEFS_FORK_STRUCT& the_fork) {
 /// @return the newly found fork.
 /***********************************************************************************/
 _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUCT* catalog,
-                                                       _Input const Char* name,
-                                                       _Input Boolean     is_data) {
+                                                       _Input const Char*          name,
+                                                       _Input Boolean              is_data) {
   if (!catalog || !name) return nullptr;
 
   auto&            drive = kMountpoint.A();
@@ -167,8 +167,8 @@ _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUC
     drive.fPacket.fPacketSize    = sizeof(NEFS_FORK_STRUCT);
     drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&local_buf);
 
-    rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                   rt_string_len("fs/nefs-packet"));
+    rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                        rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
 
     if (auto res = fs_ifs_read(&kMountpoint, drive, this->mDriveIndex); res) {
       switch (res) {
@@ -190,7 +190,7 @@ _Output NEFS_FORK_STRUCT* NeFileSystemParser::FindFork(_Input NEFS_CATALOG_STRUC
     if (KStringBuilder::Equals(local_buf.ForkName, name) &&
         KStringBuilder::Equals(local_buf.CatalogName, catalog->Name)) {
       auto result = new NEFS_FORK_STRUCT();
-      rt_copy_memory(&local_buf, result, sizeof(NEFS_FORK_STRUCT));
+      rt_copy_memory_safe(&local_buf, result, sizeof(NEFS_FORK_STRUCT), sizeof(NEFS_FORK_STRUCT));
       return result;
     }
 
@@ -217,7 +217,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
 /// @param kind the catalog kind.
 /// @return catalog pointer.
 /***********************************************************************************/
-_Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char* name,
+_Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char*  name,
                                                                _Input const Int32& flags,
                                                                _Input const Int32& kind) {
   kout << "CreateCatalog(*...*)\r";
@@ -249,7 +249,7 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
   }
 
   Char* parent_name = (Char*) mm_alloc_ptr(nameLen + 1, Yes, No);
-  rt_copy_memory(const_cast<Char*>(name), parent_name, nameLen + 1);
+  rt_copy_memory_safe(const_cast<Char*>(name), parent_name, nameLen + 1, nameLen + 1);
 
   if (nameLen < 2) {
     mm_free_ptr(parent_name);
@@ -312,13 +312,14 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
   --i;
   if (kind == kNeFSCatalogKindDir) --i;
   while (name[i] != '/') --i;
-  rt_copy_memory((VoidPtr) (name + i), (VoidPtr) child_catalog->Name, rt_string_len(name) - i);
+  rt_copy_memory_safe((VoidPtr) (name + i), (VoidPtr) child_catalog->Name, rt_string_len(name) - i,
+                      kNeFSCatalogNameLen);
 
   NEFS_CATALOG_STRUCT temporary_catalog{};
   Lba                 start_free = out_lba;
 
-  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                 rt_string_len("fs/nefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                      rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
 
   Char buf_part_block[sizeof(NEFS_ROOT_PARTITION_BLOCK)] = {0};
   drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(buf_part_block);
@@ -380,13 +381,15 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char
 
       delete catalog;
       NEFS_CATALOG_STRUCT* found_catalog = new NEFS_CATALOG_STRUCT();
-      rt_copy_memory(&temporary_catalog, found_catalog, sizeof(NEFS_CATALOG_STRUCT));
+      rt_copy_memory_safe(&temporary_catalog, found_catalog, sizeof(NEFS_CATALOG_STRUCT),
+                          sizeof(NEFS_CATALOG_STRUCT));
 
       delete child_catalog;
       return found_catalog;
     } else if ((temporary_catalog.Flags & kNeFSFlagCreated) &&
                KStringBuilder::Equals(temporary_catalog.Name, name)) {
-      rt_copy_memory(&temporary_catalog, child_catalog, sizeof(NEFS_CATALOG_STRUCT));
+      rt_copy_memory_safe(&temporary_catalog, child_catalog, sizeof(NEFS_CATALOG_STRUCT),
+                          sizeof(NEFS_CATALOG_STRUCT));
       delete catalog;
       return child_catalog;
     }
@@ -411,8 +414,8 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
 
   // verify disk.
   drive->fVerify(drive->fPacket);
-  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive->fPacket.fPacketMime,
-                 rt_string_len("fs/nefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive->fPacket.fPacketMime,
+                      rt_string_len("fs/nefs-packet"), sizeof(drive->fPacket.fPacketMime));
   if (!drive->fPacket.fPacketGood) {
     err_global_get() = kErrorDiskIsCorrupted;
     return false;
@@ -430,9 +433,10 @@ bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const I
   if (rt_string_cmp(kNeFSIdent, part_block->Ident, kNeFSIdentLen) == 0) return true;
 
   const auto kNeFSUntitledHD = part_name;
-  rt_copy_memory((VoidPtr) kNeFSIdent, (VoidPtr) part_block->Ident, kNeFSIdentLen);
-  rt_copy_memory((VoidPtr) kNeFSUntitledHD, (VoidPtr) part_block->PartitionName,
-                 rt_string_len(kNeFSUntitledHD));
+  rt_copy_memory_safe((VoidPtr) kNeFSIdent, (VoidPtr) part_block->Ident, kNeFSIdentLen,
+                      sizeof(part_block->Ident));
+  rt_copy_memory_safe((VoidPtr) kNeFSUntitledHD, (VoidPtr) part_block->PartitionName,
+                      rt_string_len(kNeFSUntitledHD), sizeof(part_block->PartitionName));
 
   SizeT sectorCount    = drv_std_get_sector_count();
   SizeT sectorSize     = drive->fSectorSz;
@@ -513,9 +517,9 @@ bool NeFileSystemParser::WriteCatalog(_Input const Char* catalog_name, Bool is_r
 
   auto buf = new UInt8[size_of_data];
   rt_set_memory(buf, 0, size_of_data);
-  rt_copy_memory(data, buf, size_of_data);
-  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                 rt_string_len("fs/nefs-packet"));
+  rt_copy_memory_safe(data, buf, size_of_data, size_of_data);
+  rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                      rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
 
   NEFS_FORK_STRUCT* fork_data_input = new NEFS_FORK_STRUCT();
   NEFS_FORK_STRUCT  prev_fork{};
@@ -577,8 +581,8 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char*
   NEFS_ROOT_PARTITION_BLOCK part{};
   auto&                     drive = kMountpoint.A();
 
-  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                 rt_string_len("fs/nefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                      rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
   drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(&part);
   drive.fPacket.fPacketSize    = sizeof(NEFS_ROOT_PARTITION_BLOCK);
   drive.fPacket.fPacketLba     = kNeFSRootCatalogStartAddress;
@@ -607,7 +611,8 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char*
           return nullptr;
         }
         NEFS_CATALOG_STRUCT* catalog_ptr = new NEFS_CATALOG_STRUCT();
-        rt_copy_memory(&tmp, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT));
+        rt_copy_memory_safe(&tmp, catalog_ptr, sizeof(NEFS_CATALOG_STRUCT),
+                            sizeof(NEFS_CATALOG_STRUCT));
         out_lba = cursor;
         return catalog_ptr;
       }
@@ -619,7 +624,8 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::FindCatalog(_Input const Char*
   if (!KStringBuilder::Equals(catalog_name, NeFileSystemHelper::Root()) && local_search) {
     Char  parent_name[kNeFSCatalogNameLen] = {0};
     SizeT nameLen                          = rt_string_len(catalog_name);
-    rt_copy_memory(const_cast<Char*>(catalog_name), parent_name, nameLen + 1);
+    rt_copy_memory_safe(const_cast<Char*>(catalog_name), parent_name, nameLen + 1,
+                        kNeFSCatalogNameLen);
 
     SizeT indexReverseCopy = nameLen - 1;
     if (parent_name[indexReverseCopy] == NeFileSystemHelper::Separator()) {
@@ -727,8 +733,8 @@ _Output Boolean NeFileSystemParser::RemoveCatalog(_Input const Char* catalog_nam
     catalog->Flags &= (~kNeFSFlagCreated);
     catalog->Flags |= kNeFSFlagDeleted;
 
-    rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                   rt_string_len("fs/nefs-packet"));
+    rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                        rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
     drive.fPacket.fPacketLba     = out_lba;
     drive.fPacket.fPacketSize    = sizeof(NEFS_CATALOG_STRUCT);
     drive.fPacket.fPacketContent = reinterpret_cast<VoidPtr>(catalog);
@@ -795,8 +801,8 @@ VoidPtr NeFileSystemParser::ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* cata
   }
 
   auto* fs_buf = new NEFS_FORK_STRUCT();
-  rt_copy_memory((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
-                 rt_string_len("fs/nefs-packet"));
+  rt_copy_memory_safe((VoidPtr) "fs/nefs-packet", drive.fPacket.fPacketMime,
+                      rt_string_len("fs/nefs-packet"), sizeof(drive.fPacket.fPacketMime));
 
   NEFS_FORK_STRUCT* fs_fork_data = nullptr;
   while (dataForkLba >= kNeFSCatalogStartAddress) {
diff --git a/dev/kernel/src/FileMgr.cc b/dev/kernel/src/FileMgr.cc
index e000965f..faed9ae1 100644
--- a/dev/kernel/src/FileMgr.cc
+++ b/dev/kernel/src/FileMgr.cc
@@ -10,6 +10,7 @@
 /***********************************************************************************/
 /// @file FileMgr.cc
 //! @brief File System Manager API.
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 /***********************************************************************************/
 
 namespace Kernel {
diff --git a/dev/kernel/src/IPEFDylibObject.cc b/dev/kernel/src/IPEFDylibObject.cc
index d1d4eeca..a24fba72 100644
--- a/dev/kernel/src/IPEFDylibObject.cc
+++ b/dev/kernel/src/IPEFDylibObject.cc
@@ -35,6 +35,7 @@ using namespace Kernel;
 /***********************************************************************************/
 /// @file IPEFDylibObject.cc
 /// @brief PEF's Dylib runtime.
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 /***********************************************************************************/
 
 /***********************************************************************************/
diff --git a/dev/kernel/src/IndexableProperty.cc b/dev/kernel/src/IndexableProperty.cc
index 1d2a1ce8..251d6645 100644
--- a/dev/kernel/src/IndexableProperty.cc
+++ b/dev/kernel/src/IndexableProperty.cc
@@ -6,6 +6,8 @@
 
 #include <CompilerKit/CompilerKit.h>
 #include <FSKit/IndexableProperty.h>
+#include <NeKit/KString.h>
+#include <NeKit/KernelPanic.h>
 #include <NeKit/MutableArray.h>
 #include <NeKit/Utils.h>
 
@@ -16,13 +18,21 @@
 
 namespace Kernel {
 namespace Indexer {
-  Index& IndexableProperty::Leak() noexcept { return fIndex; }
+  Index& IndexableProperty::Leak() noexcept {
+    return fIndex;
+  }
 
-  Void IndexableProperty::AddFlag(Int16 flag) { fFlags |= flag; }
+  Void IndexableProperty::AddFlag(Int16 flag) {
+    fFlags |= flag;
+  }
 
-  Void IndexableProperty::RemoveFlag(Int16 flag) { fFlags &= flag; }
+  Void IndexableProperty::RemoveFlag(Int16 flag) {
+    fFlags &= flag;
+  }
 
-  Int16 IndexableProperty::HasFlag(Int16 flag) { return fFlags & flag; }
+  Int16 IndexableProperty::HasFlag(Int16 flag) {
+    return fFlags & flag;
+  }
 
   /// @brief Index a file into the indexer instance.
   /// @param filename filesystem path to access.
@@ -32,7 +42,8 @@ namespace Indexer {
   Void fs_index_file(const Char* filename, SizeT filenameLen, IndexableProperty& indexer) {
     if (!indexer.HasFlag(kIndexerClaimed)) {
       indexer.AddFlag(kIndexerClaimed);
-      rt_copy_memory((VoidPtr) indexer.Leak().Path, (VoidPtr) filename, filenameLen);
+      rt_copy_memory_safe(reinterpret_cast<VoidPtr>(const_cast<Char*>(filename)),
+                          (VoidPtr) indexer.Leak().Path, filenameLen, kIndexerCatalogNameLength);
 
       (Void)(kout << "FSKit: Indexed new file: " << filename << kendl);
     }
diff --git a/dev/kernel/src/Network/IPAddr.cc b/dev/kernel/src/Network/IPAddr.cc
index b341af8f..ec7d8a35 100644
--- a/dev/kernel/src/Network/IPAddr.cc
+++ b/dev/kernel/src/Network/IPAddr.cc
@@ -88,19 +88,23 @@ ErrorOr<KString> IPFactory::ToKString(Ref<RawIPAddress>& ipv4) {
 bool IPFactory::IpCheckVersion4(const Char* ip) {
   if (!ip) return NO;
 
-  Int32 cnter = 0;
+  Int32 cnter     = 0;
+  Int32 dot_cnter = 0;
 
   for (SizeT base = 0; base < rt_string_len(ip); ++base) {
     if (ip[base] == '.') {
       cnter = 0;
+      ++dot_cnter;
     } else {
-      if (!rt_is_alnum(ip[base])) return false;
-      if (cnter == 3) return false;
+      if (!rt_is_alnum(ip[base])) return NO;
+      if (cnter == 3) return NO;
 
       ++cnter;
     }
   }
 
-  return true;
+  if (dot_cnter != 3) return NO;
+
+  return YES;
 }
 }  // namespace Kernel
diff --git a/dev/kernel/src/Network/IPCMsg.cc b/dev/kernel/src/Network/IPCMsg.cc
index cff19cfa..9abefcef 100644
--- a/dev/kernel/src/Network/IPCMsg.cc
+++ b/dev/kernel/src/Network/IPCMsg.cc
@@ -87,6 +87,8 @@ Bool ipc_construct_packet(_Output IPC_MSG** pckt_in) {
     (*pckt_in)->IpcFrom.UserProcessID   = 0;
     (*pckt_in)->IpcFrom.UserProcessTeam = 0;
 
+    (*pckt_in)->IpcLock = kIPCLockFree;
+
     return Yes;
   }
 
@@ -103,7 +105,19 @@ Bool IPC_MSG::Pass(IPC_MSG* src, IPC_MSG* target) noexcept {
     if (src->IpcMsgSz > target->IpcMsgSz) return No;
     if (target->IpcMsgSz > src->IpcMsgSz) return No;
 
-    rt_copy_memory(src->IpcData, target->IpcData, src->IpcMsgSz);
+    UInt32 timeout = 0U;
+
+    while ((target->IpcLock % kIPCLockUsed) != 0) {
+      if (timeout > 100000U) {
+        return No;
+      }
+    }
+
+    ++target->IpcLock;
+
+    rt_copy_memory_safe(src->IpcData, target->IpcData, src->IpcMsgSz, kIPCMsgSize);
+
+    --target->IpcLock;
 
     return Yes;
   }
diff --git a/dev/kernel/src/PEFCodeMgr.cc b/dev/kernel/src/PEFCodeMgr.cc
index ed72473f..c0caeb5b 100644
--- a/dev/kernel/src/PEFCodeMgr.cc
+++ b/dev/kernel/src/PEFCodeMgr.cc
@@ -1,9 +1,11 @@
 /* -------------------------------------------
 
   Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
+  Copyright (C) 2025, Amlal El Mahrouss & NeKernel contributors, all rights reserved.
 
 ------------------------------------------- */
 
+#include <ArchKit/ArchKit.h>
 #include <KernelKit/DebugOutput.h>
 #include <KernelKit/HeapMgr.h>
 #include <KernelKit/PEFCodeMgr.h>
@@ -12,6 +14,11 @@
 #include <NeKit/KString.h>
 #include <NeKit/KernelPanic.h>
 #include <NeKit/OwnPtr.h>
+#include <NeKit/Utils.h>
+
+/// @author Amlal El Mahrouss (amlal@nekernel.org)
+/// @brief PEF backend for the Code Manager.
+/// @file PEFCodeMgr.cc
 
 /// @brief PEF stack size symbol.
 #define kPefStackSizeSymbol "__PEFSizeOfReserveStack"
@@ -23,7 +30,7 @@ namespace Detail {
   /***********************************************************************************/
   /// @brief Get the PEF platform signature according to the compiled architecture.
   /***********************************************************************************/
-  UInt32 ldr_get_platform(void) noexcept {
+  static UInt32 ldr_get_platform(void) noexcept {
 #if defined(__NE_32X0__)
     return kPefArch32x0;
 #elif defined(__NE_64X0__)
@@ -57,30 +64,34 @@ PEFLoader::PEFLoader(const Char* path) : fCachedBlob(nullptr), fFatBinary(false)
   fFile.New(const_cast<Char*>(path), kRestrictRB);
   fPath = KStringBuilder::Construct(path).Leak();
 
-  auto kPefHeader = "PEF_CONTAINER";
+  constexpr auto kPefHeader = "PEF_CONTAINER";
 
-  fCachedBlob = fFile->Read(kPefHeader, mib_cast(16));
+  /// @note zero here means that the FileMgr will read every container header inside the file.
+  fCachedBlob = fFile->Read(kPefHeader, 0UL);
 
   PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
 
-  if (container->Cpu == Detail::ldr_get_platform() && container->Magic[0] == kPefMagic[0] &&
-      container->Magic[1] == kPefMagic[1] && container->Magic[2] == kPefMagic[2] &&
-      container->Magic[3] == kPefMagic[3] && container->Magic[4] == kPefMagic[4] &&
-      container->Abi == kPefAbi) {
-    return;
-  } else if (container->Magic[4] == kPefMagic[0] && container->Magic[3] == kPefMagic[1] &&
-             container->Magic[2] == kPefMagic[2] && container->Magic[1] == kPefMagic[3] &&
-             container->Magic[0] == kPefMagic[4] && container->Abi == kPefAbi) {
-    /// This is a fat binary.
-    this->fFatBinary = true;
-    return;
+  if (container->Abi == kPefAbi &&
+      container->Count >=
+          3) { /* if same ABI, AND: .text, .bss, .data (or at least similar) exists */
+    if (container->Cpu == Detail::ldr_get_platform() && container->Magic[0] == kPefMagic[0] &&
+        container->Magic[1] == kPefMagic[1] && container->Magic[2] == kPefMagic[2] &&
+        container->Magic[3] == kPefMagic[3] && container->Magic[4] == kPefMagic[4]) {
+      return;
+    } else if (container->Magic[0] == kPefMagicFat[0] && container->Magic[1] == kPefMagicFat[1] &&
+               container->Magic[2] == kPefMagicFat[2] && container->Magic[3] == kPefMagicFat[3] &&
+               container->Magic[4] == kPefMagicFat[4]) {
+      /// This is a fat binary, treat it as such.
+      this->fFatBinary = true;
+      return;
+    }
   }
 
   fBad = true;
 
   if (fCachedBlob) mm_free_ptr(fCachedBlob);
 
-  kout << "PEFLoader: Warning: Executable format error!\r";
+  kout << "PEFLoader: warning: exec format error!\r";
 
   fCachedBlob = nullptr;
 }
@@ -102,14 +113,26 @@ PEFLoader::~PEFLoader() {
 ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
   if (!fCachedBlob || fBad || !name) return ErrorOr<VoidPtr>{kErrorInvalidData};
 
+  auto blob = fFile->Read(name, sizeof(PEFCommandHeader));
+
+  if (!blob) return ErrorOr<VoidPtr>{kErrorInvalidData};
+
   PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
 
-  auto blob = fFile->Read(name, sizeof(PEFCommandHeader));
+  if (!container) return ErrorOr<VoidPtr>{kErrorInvalidData};
+
+  PEFCommandHeader* command_header = reinterpret_cast<PEFCommandHeader*>(blob);
 
-  PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
+  if (command_header->VMSize < 1 || command_header->VMAddress == 0)
+    return ErrorOr<VoidPtr>{kErrorInvalidData};
 
-  constexpr auto kMangleCharacter  = '$';
-  const Char*    kContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
+  /// fat binary check.
+  if (command_header->Cpu != container->Cpu && !this->fFatBinary) {
+    return ErrorOr<VoidPtr>{kErrorInvalidData};
+  }
+
+  const auto  kMangleCharacter  = '$';
+  const Char* kContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
 
   ErrorOr<KString> error_or_symbol;
 
@@ -128,8 +151,8 @@ ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
     }
     default:
       return ErrorOr<VoidPtr>{kErrorInvalidData};
-      ;  // prevent that from the kernel's mode perspective, let that happen if it
-         // were a user process.
+      // prevent that from the kernel's mode perspective, let that happen if it
+      // were a user process.
   }
 
   Char* unconst_symbol = const_cast<Char*>(name);
@@ -142,35 +165,50 @@ ErrorOr<VoidPtr> PEFLoader::FindSymbol(const Char* name, Int32 kind) {
 
   error_or_symbol.Leak().Leak() += name;
 
-  for (SizeT index = 0; index < container->Count; ++index) {
-    if (KStringBuilder::Equals(container_header->Name, error_or_symbol.Leak().Leak().CData())) {
-      if (container_header->Kind == kind) {
-        if (container_header->Cpu != Detail::ldr_get_platform()) {
-          if (!this->fFatBinary) {
-            mm_free_ptr(blob);
-            return ErrorOr<VoidPtr>{kErrorInvalidData};
-          }
+  if (KStringBuilder::Equals(command_header->Name, error_or_symbol.Leak().Leak().CData())) {
+    if (command_header->Kind == kind) {
+      if (command_header->Cpu != Detail::ldr_get_platform()) {
+        if (!this->fFatBinary) {
+          mm_free_ptr(blob);
+          blob = nullptr;
+
+          return ErrorOr<VoidPtr>{kErrorInvalidData};
         }
+      }
+
+      Char* container_blob_value = new Char[command_header->VMSize];
+
+      rt_copy_memory_safe((VoidPtr) ((Char*) blob + sizeof(PEFCommandHeader)), container_blob_value,
+                          command_header->VMSize, command_header->VMSize);
 
-        Char* container_blob_value = new Char[container_header->Size];
+      mm_free_ptr(blob);
 
-        rt_copy_memory((VoidPtr) ((Char*) blob + sizeof(PEFCommandHeader)), container_blob_value,
-                       container_header->Size);
-        mm_free_ptr(blob);
+      kout << "PEFLoader: info: Loaded stub: " << command_header->Name << "!\r";
 
-        kout << "PEFLoader: Information: Loaded stub: " << container_header->Name << "!\r";
+      Int32 ret         = 0;
+      SizeT pages_count = (command_header->VMSize + kPageSize - 1) / kPageSize;
 
-        auto ret = HAL::mm_map_page((VoidPtr) container_header->VMAddress,
-                                    (VoidPtr) HAL::mm_get_page_addr(container_blob_value),
-                                    HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
+      for (SizeT i_vm{}; i_vm < pages_count; ++i_vm) {
+        ret = HAL::mm_map_page(
+            (VoidPtr) (command_header->VMAddress + (i_vm * kPageSize)),
+            (VoidPtr) (HAL::mm_get_page_addr(container_blob_value) + (i_vm * kPageSize)),
+            HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
 
         if (ret != kErrorSuccess) {
-          mm_free_ptr(container_blob_value);
+          /// We set the VMAddress to nullptr, if the mapping fail here.
+          for (SizeT i_vm_unmap{}; i_vm_unmap < i_vm; ++i_vm_unmap) {
+            ret = HAL::mm_map_page((VoidPtr) (command_header->VMAddress + (i_vm * kPageSize)),
+                                   nullptr, HAL::kMMFlagsPresent | HAL::kMMFlagsUser);
+          }
+
+          delete[] container_blob_value;
+          container_blob_value = nullptr;
+
           return ErrorOr<VoidPtr>{kErrorInvalidData};
         }
-
-        return ErrorOr<VoidPtr>{container_blob_value};
       }
+
+      return ErrorOr<VoidPtr>{container_blob_value};
     }
   }
 
@@ -198,17 +236,17 @@ const Char* PEFLoader::Path() {
 
 const Char* PEFLoader::AsString() {
 #ifdef __32x0__
-  return "32x0 PEF.";
+  return "32x0 PEF";
 #elif defined(__64x0__)
-  return "64x0 PEF.";
+  return "64x0 PEF";
 #elif defined(__x86_64__)
-  return "x86_64 PEF.";
+  return "x86_64 PEF";
 #elif defined(__aarch64__)
-  return "AARCH64 PEF.";
+  return "AARCH64 PEF";
 #elif defined(__powerpc64__)
-  return "POWER64 PEF.";
+  return "POWER64 PEF";
 #else
-  return "???? PEF.";
+  return "???? PEF";
 #endif  // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
 }
 
@@ -232,7 +270,7 @@ namespace Utils {
       symname = ErrorOr<VoidPtr>{(VoidPtr) rt_alloc_string("USER_PROCESS")};
     }
 
-    auto id =
+    ProcessID id =
         UserProcessScheduler::The().Spawn(reinterpret_cast<const Char*>(symname.Leak().Leak()),
                                           errOrStart.Leak().Leak(), exec.GetBlob().Leak().Leak());
 
@@ -241,7 +279,7 @@ namespace Utils {
     if (id != kSchedInvalidPID) {
       auto stacksym = exec.FindSymbol(kPefStackSizeSymbol, kPefData);
 
-      if (!symname) {
+      if (!stacksym) {
         stacksym = ErrorOr<VoidPtr>{(VoidPtr) new UIntPtr(kSchedMaxStackSz)};
       }
 
diff --git a/dev/kernel/src/PageMgr.cc b/dev/kernel/src/PageMgr.cc
index e78f4908..2aa2a79c 100644
--- a/dev/kernel/src/PageMgr.cc
+++ b/dev/kernel/src/PageMgr.cc
@@ -47,7 +47,7 @@ Bool PTEWrapper::Reclaim() {
 }
 
 /// @brief Request a PTE.
-/// @param Rw r/w?
+/// @param Rw Is it read write? or is it read only?
 /// @param User user mode?
 /// @param ExecDisable disable execution on page?
 /// @return
diff --git a/dev/kernel/src/Semaphore.cc b/dev/kernel/src/Semaphore.cc
new file mode 100644
index 00000000..acbbb57f
--- /dev/null
+++ b/dev/kernel/src/Semaphore.cc
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#include <KernelKit/Semaphore.h>
\ No newline at end of file
diff --git a/dev/kernel/src/SoftwareTimer.cc b/dev/kernel/src/SoftwareTimer.cc
index 535bec9e..52087931 100644
--- a/dev/kernel/src/SoftwareTimer.cc
+++ b/dev/kernel/src/SoftwareTimer.cc
@@ -7,6 +7,7 @@
 #include <KernelKit/Timer.h>
 
 /// @brief SoftwareTimer class, meant to be generic.
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 
 using namespace Kernel;
 
diff --git a/dev/kernel/src/ThreadLocalStorage.cc b/dev/kernel/src/ThreadLocalStorage.cc
index 03a71f1a..f54eeaab 100644
--- a/dev/kernel/src/ThreadLocalStorage.cc
+++ b/dev/kernel/src/ThreadLocalStorage.cc
@@ -16,6 +16,7 @@
 /// @bugs: 0
 /// @file ThreadLocalStorage.cc
 /// @brief NeKernel Thread Local Storage.
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 /***********************************************************************************/
 
 using namespace Kernel;
diff --git a/dev/kernel/src/Timer.cc b/dev/kernel/src/Timer.cc
index 826be99a..6539f1a9 100644
--- a/dev/kernel/src/Timer.cc
+++ b/dev/kernel/src/Timer.cc
@@ -9,6 +9,7 @@
 ///! BUGS: 0
 ///! @file Timer.cc
 ///! @brief Software Timer implementation
+///! @author Amlal El Mahrouss (amlal@nekernel.org)
 
 using namespace Kernel;
 
diff --git a/dev/kernel/src/UserMgr.cc b/dev/kernel/src/UserMgr.cc
index 8eade85e..8e4ba540 100644
--- a/dev/kernel/src/UserMgr.cc
+++ b/dev/kernel/src/UserMgr.cc
@@ -13,8 +13,11 @@
 #include <KernelKit/FileMgr.h>
 #include <KernelKit/HeapMgr.h>
 #include <KernelKit/KPC.h>
+#include <KernelKit/ThreadLocalStorage.h>
 #include <KernelKit/UserMgr.h>
+#include <NeKit/KString.h>
 #include <NeKit/KernelPanic.h>
+#include <NeKit/Utils.h>
 
 #define kStdUserType (0xEE)
 #define kSuperUserType (0xEF)
@@ -30,8 +33,8 @@ namespace Detail {
   /// \return the hashed password
   ////////////////////////////////////////////////////////////
   STATIC UInt64 user_fnv_generator(const Char* password, User* user) {
-    if (!password || !user) return 1;
-    if (*password == 0) return 1;
+    if (!password || !user) return 0;
+    if (*password == 0) return 0;
 
     kout << "user_fnv_generator: Hashing user password...\r";
 
@@ -47,7 +50,7 @@ namespace Detail {
 
     kout << "user_fnv_generator: Hashed user password.\r";
 
-    return 0;
+    return hash;
   }
 }  // namespace Detail
 
@@ -56,14 +59,16 @@ namespace Detail {
 ////////////////////////////////////////////////////////////
 User::User(const Int32& sel, const Char* user_name) : mUserRing((UserRingKind) sel) {
   MUST_PASS(sel >= 0);
-  rt_copy_memory((VoidPtr) user_name, this->mUserName, rt_string_len(user_name));
+  rt_copy_memory_safe((VoidPtr) user_name, this->mUserName, rt_string_len(user_name),
+                      kMaxUserNameLen);
 }
 
 ////////////////////////////////////////////////////////////
 /// @brief User ring constructor.
 ////////////////////////////////////////////////////////////
 User::User(const UserRingKind& ring_kind, const Char* user_name) : mUserRing(ring_kind) {
-  rt_copy_memory((VoidPtr) user_name, this->mUserName, rt_string_len(user_name));
+  rt_copy_memory_safe((VoidPtr) user_name, this->mUserName, rt_string_len(user_name),
+                      kMaxUserNameLen);
 }
 
 ////////////////////////////////////////////////////////////
diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc
index eff53745..45957c7b 100644
--- a/dev/kernel/src/UserProcessScheduler.cc
+++ b/dev/kernel/src/UserProcessScheduler.cc
@@ -20,6 +20,7 @@
 #include <KernelKit/KPC.h>
 #include <KernelKit/ProcessScheduler.h>
 #include <NeKit/KString.h>
+#include <NeKit/Utils.h>
 #include <SignalKit/Signals.h>
 
 ///! BUGS: 0
@@ -39,8 +40,9 @@ USER_PROCESS::~USER_PROCESS() = default;
 Void USER_PROCESS::Crash() {
   if (this->Status != ProcessStatusKind::kRunning) return;
 
+  this->Status = ProcessStatusKind::kKilled;
+
   (Void)(kout << this->Name << ": crashed, error id: " << number(-kErrorProcessFault) << kendl);
-  this->Exit(-kErrorProcessFault);
 }
 
 /***********************************************************************************/
@@ -83,7 +85,8 @@ Void USER_PROCESS::Wake(Bool should_wakeup) {
 /** @param tree The tree to calibrate */
 /***********************************************************************************/
 
-STATIC PROCESS_HEAP_TREE<VoidPtr>* sched_try_go_upper_ptr_tree(PROCESS_HEAP_TREE<VoidPtr>* tree) {
+template <typename T>
+STATIC T* sched_try_go_upper_ptr_tree(T* tree) {
   if (!tree) {
     return nullptr;
   }
@@ -104,7 +107,7 @@ STATIC PROCESS_HEAP_TREE<VoidPtr>* sched_try_go_upper_ptr_tree(PROCESS_HEAP_TREE
 }
 
 /***********************************************************************************/
-/** @brief Allocate pointer to heap tree. */
+/** @brief Allocate pointer to heap/file tree. */
 /***********************************************************************************/
 
 ErrorOr<VoidPtr> USER_PROCESS::New(SizeT sz, SizeT pad_amount) {
@@ -119,7 +122,7 @@ ErrorOr<VoidPtr> USER_PROCESS::New(SizeT sz, SizeT pad_amount) {
 
   hal_write_cr3(vm_register);
 #else
-  auto ptr           = mm_alloc_ptr(sz, Yes, Yes, pad_amount);
+  auto ptr = mm_alloc_ptr(sz, Yes, Yes, pad_amount);
 #endif
 
   if (!this->HeapTree) {
@@ -231,23 +234,24 @@ const AffinityKind& USER_PROCESS::GetAffinity() noexcept {
 /** @brief Free heap tree. */
 /***********************************************************************************/
 
-STATIC Void sched_free_ptr_tree(PROCESS_HEAP_TREE<VoidPtr>* memory_ptr_list) {
+template <typename T>
+STATIC Void sched_free_ptr_tree(T* tree) {
   // Deleting memory lists. Make sure to free all of them.
-  while (memory_ptr_list) {
-    if (memory_ptr_list->Entry) {
-      MUST_PASS(mm_free_ptr(memory_ptr_list->Entry));
+  while (tree) {
+    if (tree->Entry) {
+      MUST_PASS(mm_free_ptr(tree->Entry));
     }
 
-    auto next = memory_ptr_list->Next;
+    auto next = tree->Next;
 
     if (next->Child) sched_free_ptr_tree(next->Child);
 
-    memory_ptr_list->Child = nullptr;
+    tree->Child = nullptr;
 
-    mm_free_ptr(memory_ptr_list);
+    mm_free_ptr(tree);
 
-    memory_ptr_list = nullptr;
-    memory_ptr_list = next;
+    tree = nullptr;
+    tree = next;
   }
 }
 
@@ -271,6 +275,9 @@ Void USER_PROCESS::Exit(const Int32& exit_code) {
   sched_free_ptr_tree(this->HeapTree);
   this->HeapTree = nullptr;
 
+  sched_free_ptr_tree(this->FileTree);
+  this->FileTree = nullptr;
+
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   hal_write_cr3(pd);
 #endif
@@ -314,10 +321,10 @@ Void USER_PROCESS::Exit(const Int32& exit_code) {
 }
 
 /***********************************************************************************/
-/// @brief Add dylib to process.
+/// @brief Add dylib to the process object.
 /***********************************************************************************/
 
-Bool USER_PROCESS::SpawnDylib() {
+Bool USER_PROCESS::InitDylib() {
   // React according to the process's kind.
   switch (this->Kind) {
     case USER_PROCESS::kExecutableDylibKind: {
@@ -340,7 +347,6 @@ Bool USER_PROCESS::SpawnDylib() {
 
   (Void)(kout << "Unknown process kind: " << hex_number(this->Kind) << kendl);
   this->Crash();
-  return NO;
 
   return NO;
 }
@@ -379,7 +385,8 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
     return -kErrorProcessFault;
   }
 
-  rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(name)), process.Name, len);
+  rt_copy_memory_safe(reinterpret_cast<VoidPtr>(const_cast<Char*>(name)), process.Name, len,
+                      kSchedNameLen);
 
 #ifdef __NE_VIRTUAL_MEMORY_SUPPORT__
   process.VMRegister = kKernelVM;
@@ -419,6 +426,17 @@ ProcessID UserProcessScheduler::Spawn(const Char* name, VoidPtr code, VoidPtr im
   process.PTime     = 0;
   process.RTime     = 0;
 
+  if (!process.FileTree) {
+    process.FileTree = new PROCESS_FILE_TREE<VoidPtr>();
+
+    if (!process.FileTree) {
+      process.Crash();
+      return ErrorOr<VoidPtr>(-kErrorHeapOutOfMemory);
+    }
+
+    /// @todo File Tree allocation and dispose methods (amlal)
+  }
+
   (Void)(kout << "PID: " << number(process.ProcessId) << kendl);
   (Void)(kout << "Name: " << process.Name << kendl);
 
diff --git a/dev/kernel/src/UserProcessTeam.cc b/dev/kernel/src/UserProcessTeam.cc
index dd21ac49..73ba7285 100644
--- a/dev/kernel/src/UserProcessTeam.cc
+++ b/dev/kernel/src/UserProcessTeam.cc
@@ -7,6 +7,7 @@
 /***********************************************************************************/
 /// @file UserProcessTeam.cc
 /// @brief Process teams implementation.
+/// @author Amlal El Mahrouss (amlal@nekernel.org)
 /***********************************************************************************/
 
 #include <KernelKit/UserProcessScheduler.h>
diff --git a/dev/kernel/src/UtfUtils.cc b/dev/kernel/src/UtfUtils.cc
index ae17aed7..a5c03b85 100644
--- a/dev/kernel/src/UtfUtils.cc
+++ b/dev/kernel/src/UtfUtils.cc
@@ -6,6 +6,8 @@
 
 #include <NeKit/Utils.h>
 
+/// @author Amlal El Mahrouss (amlal@nekernel.org)
+
 namespace Kernel {
 Size urt_string_len(const Utf8Char* str) {
   SizeT len{0};