feat! breaking changes on kernel sources.

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

6 files changed, 0 insertions, 1338 deletions

diff --git a/dev/kernel/FSKit/Defines.h b/dev/kernel/FSKit/Defines.h
deleted file mode 100644
index c5bf8f88..00000000
--- a/dev/kernel/FSKit/Defines.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
-
-======================================== */
-
-#pragma once
-
-#include <NeKit/Defines.h>
-
-#define FSKIT_VERSION "1.0.0"
-#define FSKIT_VERSION_BCD 0x0100
diff --git a/dev/kernel/FSKit/Ext2+IFS.h b/dev/kernel/FSKit/Ext2+IFS.h
deleted file mode 100644
index 01ca4c90..00000000
--- a/dev/kernel/FSKit/Ext2+IFS.h
+++ /dev/null
@@ -1,273 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
-
-======================================== */
-
-#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 {
-/// @brief Context for an EXT2 filesystem on a given drive
-class Ext2Context final {
- public:
-  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;
-  }
-
-  SizeT BlockSize() const {
-    if (!superblock) return kExt2FSBlockSizeBase;
-    return kExt2FSBlockSizeBase << superblock->fLogBlockSize;
-  }
-
-  operator BOOL() { return superblock != nullptr; }
-};
-
-/// ======================================================================= ///
-/// IFS FUNCTIONS
-/// ======================================================================= ///
-
-inline BOOL ext2_read_block(Kernel::DriveTrait* drv, Kernel::UInt32 lba, VoidPtr 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 VoidPtr buffer,
-                             Kernel::UInt32 size) {
-  if (!drv || !buffer) return false;
-
-  Kernel::DriveTrait::DrivePacket pkt{};
-  pkt.fPacketContent = const_cast<VoidPtr>(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;
-
-  // 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);
-}
-
-/*
- * Ext2FileSystemParser Class
- *
- * Provides high-level interface for EXT2 filesystem operations
- */
-class Ext2FileSystemParser final {
- private:
-  Ext2Context fCtx;  // Internal EXT2 context
-
- public:
-  /*
-   * Constructor
-   * Initializes the parser with a drive interface
-   *
-   * @param drive: Pointer to drive trait for disk I/O operations
-   */
-  explicit Ext2FileSystemParser(DriveTrait* drive);
-
-  NE_COPY_DELETE(Ext2FileSystemParser)
-
-  /*
-   * Open a file or directory by path
-   *
-   * @param path: Full path to the file/directory (e.g., "/home/user/file.txt")
-   * @param restrict_type: Access mode restriction (e.g., "r", "w", "rw")
-   * @return: VoidPtr handle to the opened file/directory, or nullptr on failure
-   */
-  VoidPtr Open(const char* path, const char* restrict_type);
-
-  /*
-   * Read data from an open file node
-   *
-   * @param node: File node handle returned by Open()
-   * @param flags: Read operation flags
-   * @param size: Number of bytes to read
-   * @return: Pointer to allocated buffer containing read data, or nullptr on failure
-   *          Caller is responsible for freeing the returned buffer
-   */
-  VoidPtr Read(VoidPtr node, Int32 flags, SizeT size);
-
-  /*
-   * Write data to an open file node
-   *
-   * @param node: File node handle returned by Open()
-   * @param data: Buffer containing data to write
-   * @param flags: Write operation flags
-   * @param size: Number of bytes to write
-   */
-  Void Write(VoidPtr node, VoidPtr data, Int32 flags, SizeT size);
-
-  /*
-   * Seek to a specific position in the file
-   *
-   * @param node: File node handle
-   * @param offset: Byte offset from beginning of file
-   * @return: true on success, false on failure
-   */
-  BOOL Seek(VoidPtr node, SizeT offset);
-
-  /*
-   * Get current position in the file
-   *
-   * @param node: File node handle
-   * @return: Current byte offset from beginning of file
-   */
-  SizeT Tell(VoidPtr node);
-
-  /*
-   * Reset file position to beginning
-   *
-   * @param node: File node handle
-   * @return: true on success, false on failure
-   */
-  BOOL Rewind(VoidPtr node);
-
-  /*
-   * Read data from a named file within a directory node
-   *
-   * @param name: Name of file within the directory
-   * @param node: Directory node handle
-   * @param flags: Read operation flags
-   * @param size: Number of bytes to read
-   * @return: Pointer to allocated buffer containing read data, or nullptr on failure
-   */
-  VoidPtr Read(const char* name, VoidPtr node, Int32 flags, SizeT size);
-
-  /*
-   * Write data to a named file within a directory node
-   *
-   * @param name: Name of file within the directory
-   * @param node: Directory node handle
-   * @param data: Buffer containing data to write
-   * @param flags: Write operation flags
-   * @param size: Number of bytes to write
-   */
-  Void Write(const char* name, VoidPtr node, VoidPtr data, Int32 flags, SizeT size);
-
-  /*
-   * Create a new regular file
-   *
-   * @param path: Full path for the new file
-   * @return: VoidPtr handle to the created file, or nullptr on failure
-   */
-  VoidPtr Create(const char* path);
-
-  /*
-   * Create a new directory
-   *
-   * @param path: Full path for the new directory
-   * @return: VoidPtr handle to the created directory, or nullptr on failure
-   */
-  VoidPtr CreateDirectory(const char* path);
-
-  /*
-   * Close and free a file/directory node
-   * Note: This method is not shown in the implementation but would typically be needed
-   *
-   * @param node: Node handle to close and free
-   */
-  Void Close(VoidPtr node);
-
-  /*
-   * Get file/directory information
-   * Note: This method is not shown in the implementation but would typically be needed
-   *
-   * @param node: Node handle
-   * @param info: Structure to fill with file information (size, type, permissions, etc.)
-   * @return: true on success, false on failure
-   */
-  BOOL GetInfo(VoidPtr node, VoidPtr info);
-};
-}  // namespace Kernel
diff --git a/dev/kernel/FSKit/Ext2.h b/dev/kernel/FSKit/Ext2.h
deleted file mode 100644
index e979e556..00000000
--- a/dev/kernel/FSKit/Ext2.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
-
-======================================== */
-
-#pragma once
-
-#include <CompilerKit/CompilerKit.h>
-#include <KernelKit/DriveMgr.h>
-#include <NeKit/Defines.h>
-#include <NeKit/KString.h>
-#include <hint/CompilerHint.h>
-
-/// @file Ext2.h
-/// @brief EXT2 filesystem structures, constants, and base wrappers.
-
-/// EXT2 Constants
-#define kExt2FSMagic (0xEF53)
-#define kExt2FSMaxFileNameLen (255U)
-#define kExt2FSSuperblockOffset (1024)
-#define kExt2FSRootInodeNumber (2)
-#define kExt2FSInodeSize (128U)
-#define kExt2FSBlockSizeBase (1024U)
-
-#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
-};
-
-typedef struct EXT2_GROUP_DESCRIPTOR final {
-  UInt32 fBlockBitmap;
-  UInt32 fInodeBitmap;
-  UInt32 fInodeTable;
-  UInt16 fFreeBlocksCount;
-  UInt16 fFreeInodesCount;
-  UInt16 fBgUsedDirsCount;
-  UInt16 fBgPad;
-  UInt32 fBgReserved[3];
-} EXT2_GROUP_DESCRIPTOR;
-
-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
-};
-
-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];
-};
-
-/// Directory entry
-struct PACKED EXT2_DIR_ENTRY final {
-  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};
-};
diff --git a/dev/kernel/FSKit/IndexableProperty.h b/dev/kernel/FSKit/IndexableProperty.h
deleted file mode 100644
index a89e78b8..00000000
--- a/dev/kernel/FSKit/IndexableProperty.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
-
-======================================== */
-
-#pragma once
-
-#include <CFKit/Property.h>
-#include <CompilerKit/CompilerKit.h>
-#include <KernelKit/DriveMgr.h>
-
-#define kIndexerCatalogNameLength (256U)
-#define kIndexerClaimed (0xCF)
-#define kIndexerUnclaimed (0xCA)
-
-namespace Kernel {
-namespace Indexer {
-  struct Index final {
-   public:
-    Char Drive[kDriveNameLen]{};
-    Char Path[kIndexerCatalogNameLength]{};
-  };
-
-  class IndexableProperty final : public Property {
-   public:
-    explicit IndexableProperty() : Property() {
-      KBasicString<> strProp(kMaxPropLen);
-      strProp += "/prop/indexable";
-
-      this->GetKey() = strProp;
-    }
-
-    ~IndexableProperty() override = default;
-
-    NE_COPY_DEFAULT(IndexableProperty)
-
-   public:
-    Index& Leak() noexcept;
-
-   public:
-    Void   AddFlag(UInt16 flag);
-    Void   RemoveFlag(UInt16 flag);
-    UInt16 HasFlag(UInt16 flag);
-
-   private:
-    Index  fIndex;
-    UInt32 fFlags{};
-  };
-
-  /// @brief Index a file into the indexer instance.
-  /// @param filename path
-  /// @param filenameLen used bytes in path.
-  /// @param indexer the filesystem indexer.
-  /// @return none.
-  Void fs_index_file(const Char* filename, SizeT filenameLen, IndexableProperty& indexer);
-}  // namespace Indexer
-}  // namespace Kernel
diff --git a/dev/kernel/FSKit/NeFS.h b/dev/kernel/FSKit/NeFS.h
deleted file mode 100644
index 54861dec..00000000
--- a/dev/kernel/FSKit/NeFS.h
+++ /dev/null
@@ -1,413 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
-
-  FILE: NeFS.h
-  PURPOSE: NeFS (New extended File System) support.
-
-  Revision History:
-
-  ?/?/?: Added file (amlel)
-  12/02/24: Add UUID macro for EPM and GPT partition schemes.
-  3/16/24: Add mandatory sector size, kNeFSSectorSz is set to 2048 by
-default.
-
-======================================== */
-
-#pragma once
-
-#include <CompilerKit/CompilerKit.h>
-#include <KernelKit/DriveMgr.h>
-#include <NeKit/Defines.h>
-#include <NeKit/KString.h>
-#include <hint/CompilerHint.h>
-
-/**
-  @brief New extended File System specification.
-  @author Amlal El Mahrouss (Amlal El Mahrouss, amlalelmahrouss at icloud dot com)
-*/
-
-#define kNeFSInvalidFork (-1)
-#define kNeFSInvalidCatalog (-1)
-#define kNeFSCatalogNameLen (256)
-
-#define kNeFSVolumeName "NeFS Volume"
-
-#define kNeFSMinimumDiskSize (mib_cast(8))
-
-#define kNeFSSectorSz (512)
-
-#define kNeFSIdentLen (8)
-#define kNeFSIdent "  NeFS"
-#define kNeFSPadLen (392)
-
-#define kNeFSMetaFilePrefix '$'
-
-#define kNeFSVersionInteger (0x0129)
-#define kNeFSVerionString "1.2.9"
-
-/// @brief Standard fork types.
-#define kNeFSDataFork "main_data"
-#define kNeFSResourceFork "main_rsrc"
-
-#define kNeFSForkSize (sizeof(NEFS_FORK_STRUCT))
-
-#define kNeFSPartitionTypeStandard (7)
-#define kNeFSPartitionTypePage (8)
-#define kNeFSPartitionTypeBoot (9)
-
-#define kNeFSCatalogKindFile (1)
-#define kNeFSCatalogKindDir (2)
-#define kNeFSCatalogKindAlias (3)
-
-//! Shared between network and/or partitions. Export forks as .zip when copying.
-#define kNeFSCatalogKindShared (4)
-
-#define kNeFSCatalogKindResource (5)
-#define kNeFSCatalogKindExecutable (6)
-
-#define kNeFSCatalogKindPage (8)
-
-#define kNeFSCatalogKindDevice (9)
-#define kNeFSCatalogKindLock (10)
-
-#define kNeFSCatalogKindRLE (11)
-#define kNeFSCatalogKindMetaFile (12)
-
-#define kNeFSCatalogKindTTF (13)
-#define kNeFSCatalogKindRIFF (14)
-#define kNeFSCatalogKindMPEG (15)
-#define kNeFSCatalogKindMOFF (16)
-
-#define kNeFSSeparator '/'
-#define kNeFSSeparatorAlt '/'
-
-#define kNeFSUpDir ".."
-#define kNeFSRoot "/"
-#define kNeFSRootAlt "/"
-
-#define kNeFSLF '\r'
-#define kNeFSEOF (-1)
-
-#define kNeFSBitWidth (sizeof(Kernel::Char))
-#define kNeFSLbaType (Kernel::Lba)
-
-/// @note Start after the partition map header. (Virtual addressing)
-#define kNeFSRootCatalogStartAddress (1024)
-#define kNeFSCatalogStartAddress (kNeFSRootCatalogStartAddress + sizeof(NEFS_ROOT_PARTITION_BLOCK))
-
-#define kResourceTypeDialog (10)
-#define kResourceTypeString (11)
-#define kResourceTypeMenu (12)
-#define kResourceTypeSound (13)
-#define kResourceTypeFont (14)
-#define kNeFSPartLen (32)
-
-#define kNeFSFlagDeleted (70)
-#define kNeFSFlagUnallocated (0)
-#define kNeFSFlagCreated (71)
-
-#define kNeFSMimeNameLen (200)
-#define kNeFSForkNameLen (199)
-
-#define kNeFSFrameworkExt ".fwrk/"
-#define kNeFSStepsExt ".step/"
-#define kNeFSApplicationExt ".app/"
-#define kNeFSJournalExt ".jrnl"
-
-struct NEFS_CATALOG_STRUCT;
-struct NEFS_FORK_STRUCT;
-struct NEFS_ROOT_PARTITION_BLOCK;
-
-enum {
-  kNeFSHardDrive         = 0xC0,  // Hard Drive
-  kNeFSSolidStateDrive   = 0xC1,  // Solid State Drive
-  kNeFSOpticalDrive      = 0x0C,  // Blu-Ray/DVD
-  kNeFSMassStorageDevice = 0xCC,  // USB
-  kNeFSScsiDrive         = 0xC4,  // SCSI Hard Drive
-  kNeFSFlashDrive        = 0xC6,
-  kNeFSUnknown           = 0xFF,  // Unknown device.
-  kNeFSDriveCount        = 7,
-};
-
-enum {
-  kNeFSStatusUnlocked = 0x18,
-  kNeFSStatusLocked,
-  kNeFSStatusError,
-  kNeFSStatusInvalid,
-  kNeFSStatusCount,
-};
-
-/// @brief Catalog record type.
-struct PACKED NEFS_CATALOG_STRUCT final {
-  BOOL ForkOrCatalog : 1 {0};
-
-  Kernel::Char Name[kNeFSCatalogNameLen] = {0};
-  Kernel::Char Mime[kNeFSMimeNameLen]    = {0};
-
-  /// Catalog flags.
-  Kernel::UInt16 Flags;
-
-  /// Catalog allocation status.
-  Kernel::UInt16 Status;
-
-  /// Custom catalog flags.
-  Kernel::UInt16 CatalogFlags;
-
-  /// Catalog kind.
-  Kernel::Int32 Kind;
-
-  /// Size of the data fork.
-  Kernel::Lba DataForkSize;
-
-  /// Size of all resource forks.
-  Kernel::Lba ResourceForkSize;
-
-  /// Forks LBA.
-  Kernel::Lba DataFork;
-  Kernel::Lba ResourceFork;
-
-  /// Buddy allocation tracker.
-  Kernel::Lba NextSibling;
-  Kernel::Lba PrevSibling;
-
-  /// Best-buddy tracker.
-  Kernel::Lba NextBestSibling;
-  Kernel::Lba NextPrevSibling;
-
-  Kernel::UInt32 Checksum;
-};
-
-/// @brief Fork type, contains a data page.
-/// @note The way we store is way different than how other filesystems do, specific chunk of code
-/// are written into either the data fork or resource fork, the resource fork is reserved for file
-/// metadata. whereas the data fork is reserved for file data.
-struct PACKED NEFS_FORK_STRUCT final {
-  BOOL ForkOrCatalog : 1 {1};
-
-  Kernel::Char ForkName[kNeFSForkNameLen]       = {0};
-  Kernel::Char CatalogName[kNeFSCatalogNameLen] = {0};
-
-  Kernel::Int32 Flags;
-  Kernel::Int32 Kind;
-
-  Kernel::Int64 ResourceId;
-  Kernel::Int32 ResourceKind;
-  Kernel::Int32 ResourceFlags;
-
-  Kernel::Lba   DataOffset;  // 8 Where to look for this data?
-  Kernel::SizeT DataSize;    /// Data size according using sector count.
-
-  Kernel::Lba NextSibling;
-  Kernel::Lba PreviousSibling;
-};
-
-/// @brief Partition block type
-struct PACKED NEFS_ROOT_PARTITION_BLOCK final {
-  Kernel::Char Ident[kNeFSIdentLen]        = {0};
-  Kernel::Char PartitionName[kNeFSPartLen] = {0};
-
-  Kernel::Int32 Flags;
-  Kernel::Int32 Kind;
-
-  Kernel::Lba   StartCatalog;
-  Kernel::SizeT CatalogCount;
-
-  Kernel::SizeT DiskSize;
-
-  Kernel::SizeT FreeCatalog;
-  Kernel::SizeT FreeSectors;
-
-  Kernel::SizeT SectorCount;
-  Kernel::SizeT SectorSize;
-
-  Kernel::UInt64 Version;
-
-  Kernel::Lba EpmBlock;
-
-  Kernel::Char Pad[kNeFSPadLen];
-};
-
-namespace Kernel {
-class NeFileSystemParser;
-class NeFileSystemJournal;
-class NeFileSystemHelper;
-
-enum {
-  kNeFSSubDriveA,
-  kNeFSSubDriveB,
-  kNeFSSubDriveC,
-  kNeFSSubDriveD,
-  kNeFSSubDriveInvalid,
-  kNeFSSubDriveCount,
-};
-
-/// \brief Resource fork kind.
-enum { kNeFSRsrcForkKind = 0, kNeFSDataForkKind = 1 };
-
-///
-/// \name NeFileSystemParser
-/// \brief NeFS parser class. (catalog creation, remove removal, root,
-/// forks...) Designed like the DOM, detects the filesystem automatically.
-///
-class NeFileSystemParser final {
- public:
-  explicit NeFileSystemParser() = default;
-  ~NeFileSystemParser()         = default;
-
- public:
-  NE_COPY_DELETE(NeFileSystemParser)
-
-  NE_MOVE_DELETE(NeFileSystemParser)
-
- public:
-  /// @brief Creates a new fork inside the NeFS  partition.
-  /// @param catalog it's catalog
-  /// @param theFork the fork itself.
-  /// @return the fork
-  _Output BOOL CreateFork(_Input NEFS_FORK_STRUCT& in);
-
-  /// @brief Find fork inside New filesystem.
-  /// @param catalog the catalog.
-  /// @param name the fork name.
-  /// @return the fork.
-  _Output NEFS_FORK_STRUCT* FindFork(_Input NEFS_CATALOG_STRUCT* catalog, _Input const Char* name,
-                                     Boolean data);
-
-  _Output Void RemoveFork(_Input NEFS_FORK_STRUCT* fork);
-
-  _Output Void CloseFork(_Input NEFS_FORK_STRUCT* fork);
-
-  _Output NEFS_CATALOG_STRUCT* FindCatalog(_Input const Char* catalog_name, Lba& ou_lba,
-                                           Bool search_hidden = YES, Bool local_search = NO);
-
-  _Output NEFS_CATALOG_STRUCT* GetCatalog(_Input const Char* name);
-
-  _Output NEFS_CATALOG_STRUCT* CreateCatalog(_Input const Char* name, _Input const Int32& flags,
-                                             _Input const Int32& kind);
-
-  _Output NEFS_CATALOG_STRUCT* CreateCatalog(_Input const Char* name);
-
-  _Output Bool WriteCatalog(_Input const Char* catalog, _Input Bool rsrc, _Input VoidPtr data,
-                            _Input SizeT sz, _Input const Char* name);
-
-  _Output VoidPtr ReadCatalog(_Input _Output NEFS_CATALOG_STRUCT* catalog, _Input Bool isRsrcFork,
-                              _Input SizeT dataSz, _Input const Char* forkName);
-
-  _Output Bool Seek(_Input _Output NEFS_CATALOG_STRUCT* catalog, SizeT off);
-
-  _Output SizeT Tell(_Input _Output NEFS_CATALOG_STRUCT* catalog);
-
-  _Output Bool RemoveCatalog(_Input const Char* catalog);
-
-  _Output Bool CloseCatalog(_InOut NEFS_CATALOG_STRUCT* catalog);
-
-  /// @brief Make a EPM+NeFS drive out of the disk.
-  /// @param drive The drive to write on.
-  /// @return If it was sucessful, see err_local_get().
-  _Output Bool Format(_Input _Output DriveTrait* drive, _Input const Int32 flags,
-                      const Char* part_name);
-
- public:
-  UInt32 mDriveIndex{kNeFSSubDriveA};
-};
-
-///
-/// \name NeFileSystemHelper
-/// \brief Filesystem helper class.
-///
-
-class NeFileSystemHelper final {
- public:
-  STATIC const Char* Root();
-  STATIC const Char* UpDir();
-  STATIC Char        Separator();
-  STATIC Char        MetaFile();
-};
-
-/// @brief Journal class for NeFS.
-class NeFileSystemJournal final {
- private:
-  NEFS_CATALOG_STRUCT* mNode{nullptr};
-
- public:
-  explicit NeFileSystemJournal(const char* stamp = nullptr) {
-    if (!stamp) {
-      kout << "Invalid: Journal stamp, using default name.\r";
-      return;
-    }
-
-    (Void)(kout << "Info: Journal stamp: " << stamp << kendl);
-    rt_copy_memory((VoidPtr) stamp, this->mStamp, rt_string_len(stamp));
-  }
-
-  ~NeFileSystemJournal() = default;
-
-  NE_COPY_DEFAULT(NeFileSystemJournal)
-
-  Bool CreateJournal(NeFileSystemParser* parser) {
-    if (!parser) return NO;
-
-    delete parser->CreateCatalog("/etc/xml/", 0, kNeFSCatalogKindDir);
-    mNode = parser->CreateCatalog(mStamp);
-
-    if (!mNode) return NO;
-
-    return YES;
-  }
-
-  Bool GetJournal(NeFileSystemParser* parser) {
-    if (!parser) return NO;
-
-    auto node = parser->GetCatalog(mStamp);
-
-    if (node) {
-      mNode = node;
-      return YES;
-    }
-
-    return NO;
-  }
-
-  Bool ReleaseJournal() {
-    if (mNode) {
-      delete mNode;
-      mNode = nullptr;
-      return YES;
-    }
-
-    return NO;
-  }
-
-  Bool CommitJournal(NeFileSystemParser* parser, Char* xml_data, Char* journal_name) {
-    if (!parser || !mNode) return NO;
-
-    NEFS_FORK_STRUCT new_fork{};
-
-    rt_copy_memory(mStamp, new_fork.CatalogName, rt_string_len(mStamp));
-    rt_copy_memory(journal_name, new_fork.ForkName, rt_string_len(journal_name));
-
-    new_fork.ResourceKind  = 0;
-    new_fork.ResourceId    = 0;
-    new_fork.ResourceFlags = 0;
-    new_fork.DataSize      = rt_string_len(xml_data);
-    new_fork.Kind          = kNeFSRsrcForkKind;
-
-    if (!parser->CreateFork(new_fork)) return NO;
-
-    (Void)(kout << "XML commit: " << xml_data << " to fork: " << journal_name << kendl);
-
-    auto ret = parser->WriteCatalog(new_fork.CatalogName, YES, xml_data, rt_string_len(xml_data),
-                                    new_fork.ForkName);
-
-    return ret;
-  }
-
- private:
-  Char mStamp[kNeFSCatalogNameLen] = {"/etc/xml/journal" kNeFSJournalExt};
-};
-
-namespace NeFS {
-  Boolean fs_init_nefs(Void) noexcept;
-}  // namespace NeFS
-}  // namespace Kernel
diff --git a/dev/kernel/FSKit/OpenHeFS.h b/dev/kernel/FSKit/OpenHeFS.h
deleted file mode 100644
index 04f07b8e..00000000
--- a/dev/kernel/FSKit/OpenHeFS.h
+++ /dev/null
@@ -1,434 +0,0 @@
-/* ========================================

-

-  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.

-

-======================================== */

-

-#pragma once

-

-#include <CompilerKit/CompilerKit.h>

-#include <KernelKit/DriveMgr.h>

-#include <KernelKit/UserMgr.h>

-#include <NeKit/Crc32.h>

-#include <NeKit/Defines.h>

-#include <NeKit/KString.h>

-#include <hint/CompilerHint.h>

-

-/// @file OpenHeFS.h

-/// @brief OpenHeFS filesystem support.

-

-#define kHeFSVersion (0x0104)

-#define kHeFSMagic "OpenHeFS"

-#define kHeFSMagicLen (9U)

-

-#define kHeFSBlockLen (512U)

-#define kHeFSFileNameLen (256U)

-#define kHeFSPartNameLen (128U)

-

-#define kHeFSMinimumDiskSize (gib_cast(128))

-

-#define kHeFSDefaultVolumeName u8"OpenHeFS Volume"

-

-#define kHeFSINDStartOffset (sizeof(HEFS_BOOT_NODE))

-#define kHeFSINStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY))

-

-#define kHeFSRootDirectory "/"

-#define kHeFSRootDirectoryU8 u8"/"

-

-#define kHeFSSeparator '/'

-#define kHeFSUpDir ".."

-

-#define kHeFSRootDirectoryLen (2U)

-

-#define kHeFSSearchAllStr u8"*"

-

-struct HEFS_BOOT_NODE;

-struct HEFS_INDEX_NODE;

-struct HEFS_INDEX_NODE_DIRECTORY;

-struct HEFS_JOURNAL_NODE;

-

-enum : UInt8 {

-  kHeFSHardDrive         = 0xC0,  // Hard Drive

-  kHeFSSolidStateDrive   = 0xC1,  // Solid State Drive

-  kHeFSOpticalDrive      = 0x0C,  // Blu-Ray/DVD

-  kHeFSMassStorageDevice = 0xCC,  // USB

-  kHeFSScsiDrive         = 0xC4,  // SCSI Hard Drive

-  kHeFSFlashDrive        = 0xC6,

-  kHeFSUnknown           = 0xFF,  // Unknown device.

-  kHeFSDriveCount        = 8,

-};

-

-enum : UInt8 {

-  kHeFSStatusUnlocked = 0x18,

-  kHeFSStatusLocked,

-  kHeFSStatusError,

-  kHeFSStatusInvalid,

-  kHeFSStatusCount,

-};

-

-enum : UInt16 {

-  kHeFSEncodingFlagsUTF8 = 0x50,

-  kHeFSEncodingFlagsUTF16,

-  kHeFSEncodingFlagsUTF32,

-  kHeFSEncodingFlagsUTF16BE,

-  kHeFSEncodingFlagsUTF16LE,

-  kHeFSEncodingFlagsUTF32BE,

-  kHeFSEncodingFlagsUTF32LE,

-  kHeFSEncodingFlagsUTF8BE,

-  kHeFSEncodingFlagsUTF8LE,

-  kHeFSEncodingFlagsBinary,

-  kHeFSEncodingFlagsCount = 11,

-  kHeFSFlagsNone          = 0,

-  kHeFSFlagsReadOnly      = 0x100,

-  kHeFSFlagsHidden,

-  kHeFSFlagsSystem,

-  kHeFSFlagsArchive,

-  kHeFSFlagsDevice,

-  kHeFSFlagsCount = 7

-};

-

-inline constexpr UInt16 kHeFSFileKindRegular      = 0x00;

-inline constexpr UInt16 kHeFSFileKindDirectory    = 0x01;

-inline constexpr UInt16 kHeFSFileKindBlock        = 0x02;

-inline constexpr UInt16 kHeFSFileKindCharacter    = 0x03;

-inline constexpr UInt16 kHeFSFileKindFIFO         = 0x04;

-inline constexpr UInt16 kHeFSFileKindSocket       = 0x05;

-inline constexpr UInt16 kHeFSFileKindSymbolicLink = 0x06;

-inline constexpr UInt16 kHeFSFileKindUnknown      = 0x07;

-inline constexpr UInt16 kHeFSFileKindCount        = 0x08;

-

-/// @brief OpenHeFS blocks are array containing sparse blocks of data.

-/// @details The blocks are used to store the data of a file. Each block is a pointer to a block of

-/// data on the disk.

-inline constexpr UInt16 kHeFSSliceCount = 0x10;

-

-inline constexpr UInt16 kHeFSInvalidVID = 0xFFFF;

-

-namespace Kernel {

-/// @brief Access time type.

-/// @details Used to keep track of the INode, INodeDir allocation status.

-typedef UInt64 ATime;

-

-/// @brief OpenHeFS Boot node.

-/// @details Acts like a superblock, it contains the information about the filesystem.

-/// @note The boot node is the first block of the filesystem.

-struct PACKED HEFS_BOOT_NODE final {

-  Char     fMagic[kHeFSMagicLen];       /// @brief Magic number of the filesystem.

-  Utf8Char fVolName[kHeFSPartNameLen];  /// @brief Volume name.

-  UInt32   fVersion;                    /// @brief Version of the filesystem.

-  UInt64   fBadSectors;                 /// @brief Number of bad sectors in the filesystem.

-  UInt64   fSectorCount;                /// @brief Number of sectors in the filesystem.

-  UInt64   fSectorSize;                 /// @brief Size of the sector.

-  UInt32   fChecksum;                   /// @brief Checksum of the boot node.

-  UInt8    fDiskKind;  /// @brief Kind of the drive. (Hard Drive, Solid State Drive, Optical

-                       /// Drive, etc).

-  UInt8  fEncoding;    /// @brief Encoding of the filesystem. (UTF-8, UTF-16, etc).

-  UInt64 fStartIND;    /// @brief Start of the INode directory tree.

-  UInt64 fEndIND;      /// @brief End of the INode directory tree.

-  UInt64 fINDCount;    /// @brief Number of leafs in the INode tree.

-  UInt64 fDiskSize;    /// @brief Size of the disk. (Could be a virtual size, that is not the

-                       /// real size of the disk.)

-  UInt16 fDiskStatus;  /// @brief Status of the disk. (locked, unlocked, error, invalid).

-  UInt16 fDiskFlags;   /// @brief Flags of the disk. (read-only, read-write, etc).

-  UInt16 fVID;  /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used).

-  UInt64 fStartIN;     /// @brief Start INodes range

-  UInt64 fEndIN;       /// @brief End INodes range

-  UInt64 fStartBlock;  /// @brief Start Blocks range

-  UInt64 fEndBlock;    /// @brief End Blocks range

-  UInt64 fJournalLBA;  /// @brief Boot Node's COW journal LBA.

-  Char   fPad[264];

-};

-

-inline constexpr ATime kHeFSTimeInvalid = 0x0000000000000000;

-inline constexpr ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;

-

-/// @brief Journal Node structure

-/// @param fHashPath target hash path

-/// @param fStatus target status

-/// @param fCopyElem copy of element

-/// @param fCopyKind kind of element

-struct PACKED HEFS_JOURNAL_NODE {

-  UInt64 fHashPath;

-  UInt64 fStatus;

-  UInt64 fCopyElem;

-  UInt8  fCopyKind;

-  UInt8  fPad[487];

-};

-

-/// @brief This enum defines the opcode of the journal, here mentioned as 'kinds'

-enum HeFSJournalKind : UInt8 {

-  kJournalKindInvalid  = 0x00,

-  kJournalKindWrite    = 0x01,

-  kJournalKindRename   = 0x02,

-  kJournalKindDelete   = 0x03,

-  kJournalKindFlagEdit = 0x04,

-  kJournalKindCreate   = 0x05,

-  kJournalKindCount,

-};

-

-/// @brief OpenHeFS index node.

-/// @details This structure is used to store the file information of a file.

-/// @note The index node is a special type of INode that contains the file information.

-/// @note The index node is used to store the file information of a file.

-struct PACKED HEFS_INDEX_NODE final {

-  UInt64 fHashPath;  /// @brief File name.

-  UInt32 fFlags;     /// @brief File flags.

-  UInt16 fKind;      /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket,

-                     /// Symbolic Link, Unknown).

-  UInt32 fSize;      /// @brief File size.

-  UInt32 fChecksum;  /// @brief Checksum.

-

-  Boolean fSymLink;  /// @brief Is this a symbolic link? (if yes, the fName is the path to

-                     /// the file and blocklinkstart and end contains it's inodes.)

-

-  ATime  fCreated, fAccessed, fModified, fDeleted;  /// @brief File timestamps.

-  UInt32 fUID, fGID;                                /// @brief User ID and Group ID of the file.

-  UInt32 fMode;  /// @brief File mode. (read, write, execute, etc).

-

-  /// @brief Extents system by using blocks

-  /// @details Using an offset to ask fBase, and fLength to compute each slice's length.

-  UInt32 fOffsetSliceLow;

-  UInt32 fOffsetSliceHigh;

-

-  Char fPad[437];

-};

-

-enum {

-  kHeFSInvalidColor = 0,

-  kHeFSRed          = 100,

-  kHeFSBlack,

-  kHeFSColorCount,

-};

-

-/// @brief OpenHeFS directory node.

-/// @details This structure is used to store the directory information of a file.

-/// @note The directory node is a special type of INode that contains the directory entries.

-struct PACKED HEFS_INDEX_NODE_DIRECTORY final {

-  UInt64 fHashPath;  /// @brief Directory path as FNV hash.

-

-  UInt32 fFlags;       /// @brief File flags.

-  UInt16 fReserved;    /// @note Reserved for future use.

-  UInt32 fEntryCount;  /// @brief Entry Count of this directory inode.

-  UInt32 fChecksum;    /// @brief Checksum of the file, index node checksum.

-

-  ATime fCreated, fAccessed, fModified,

-      fDeleted;       /// @brief File timestamps and allocation status.

-  UInt32 fUID, fGID;  /// @brief User ID and Group ID of the file.

-  UInt32 fMode;       /// @brief File mode. (read, write, execute, etc).

-

-  /// @note These slices are organized as:

-  /// [0] = OFFSET

-  /// [1] = SIZE

-  /// @note Thus the += 2 when iterating over them.

-  UInt64 fINSlices[kHeFSSliceCount];  /// @brief Start of the index node.

-

-  UInt8 fColor;                         /// @brief Color of the node. (Red or Black).

-  Lba   fNext, fPrev, fChild, fParent;  /// @brief Red-black tree pointers.

-

-  Char fPad[285];

-};

-}  // namespace Kernel

-

-namespace Kernel::Detail {

-/// @brief OpenHeFS get year from ATime.

-/// @param raw_atime the raw ATime value.

-/// @return the year value.

-/// @note The year is stored in the upper 32 bits of the ATime value.

-inline UInt32 hefs_year_get(ATime raw_atime) noexcept {

-  return (raw_atime) >> 32;

-}

-

-/// @brief OpenHeFS get month from ATime.

-/// @param raw_atime the raw ATime value.

-/// @return the month value.

-/// @note The month is stored in the upper 24 bits of the ATime value.

-inline UInt32 hefs_month_get(ATime raw_atime) noexcept {

-  return (raw_atime) >> 24;

-}

-

-/// @brief OpenHeFS get day from ATime.

-/// @param raw_atime the raw ATime value.

-/// @return the day value.

-/// @note The day is stored in the upper 16 bits of the ATime value.

-inline UInt32 hefs_day_get(ATime raw_atime) noexcept {

-  return (raw_atime) >> 16;

-}

-

-/// @brief OpenHeFS get hour from ATime.

-/// @param raw_atime the raw ATime value.

-/// @return the hour value.

-/// @note The hour is stored in the upper 8 bits of the ATime value.

-inline UInt32 hefs_hour_get(ATime raw_atime) noexcept {

-  return (raw_atime) >> 8;

-}

-

-/// @brief OpenHeFS get minute from ATime.

-/// @param raw_atime the raw ATime value.

-/// @return the minute value.

-/// @note The minute is stored in the lower 8 bits of the ATime value.

-inline UInt32 hefs_minute_get(ATime raw_atime) noexcept {

-  return (raw_atime) &0xFF;

-}

-

-inline constexpr UInt32 kHeFSBaseYear   = 1970;

-inline constexpr UInt32 kHeFSBaseMonth  = 1;

-inline constexpr UInt32 kHeFSBaseDay    = 1;

-inline constexpr UInt32 kHeFSBaseHour   = 0;

-inline constexpr UInt32 kHeFSBaseMinute = 0;

-

-inline const Char* hefs_status_to_string(UInt16 status) noexcept {

-  switch (status) {

-    case kHeFSStatusUnlocked:

-      return "Unlocked";

-    case kHeFSStatusLocked:

-      return "Locked";

-    case kHeFSStatusError:

-      return "Error";

-    case kHeFSStatusInvalid:

-      return "Invalid";

-    default:

-      return "Unknown";

-  }

-}

-

-inline const Char* hefs_drive_kind_to_string(UInt8 kind) noexcept {

-  switch (kind) {

-    case kHeFSHardDrive:

-      return "Hard Drive";

-    case kHeFSSolidStateDrive:

-      return "Solid State Drive";

-    case kHeFSOpticalDrive:

-      return "Optical Drive";

-    case kHeFSMassStorageDevice:

-      return "Mass Storage Device";

-    case kHeFSScsiDrive:

-      return "SCSI/SAS Drive";

-    case kHeFSFlashDrive:

-      return "Flash Drive";

-    case kHeFSUnknown:

-    default:

-      return "Unknown";

-  }

-}

-

-inline const Char* hefs_encoding_to_string(UInt8 encoding) noexcept {

-  switch (encoding) {

-    case kHeFSEncodingFlagsUTF8:

-      return "UTF-8";

-    case kHeFSEncodingFlagsUTF16:

-      return "UTF-16";

-    case kHeFSEncodingFlagsUTF32:

-      return "UTF-32";

-    case kHeFSEncodingFlagsUTF16BE:

-      return "UTF-16BE";

-    case kHeFSEncodingFlagsUTF16LE:

-      return "UTF-16LE";

-    case kHeFSEncodingFlagsUTF32BE:

-      return "UTF-32BE";

-    case kHeFSEncodingFlagsUTF32LE:

-      return "UTF-32LE";

-    case kHeFSEncodingFlagsUTF8BE:

-      return "UTF-8BE";

-    case kHeFSEncodingFlagsUTF8LE:

-      return "UTF-8LE";

-    default:

-      return "Unknown";

-  }

-}

-

-inline const Char* hefs_file_kind_to_string(UInt16 kind) noexcept {

-  switch (kind) {

-    case kHeFSFileKindRegular:

-      return "Regular File";

-    case kHeFSFileKindDirectory:

-      return "Directory";

-    case kHeFSFileKindBlock:

-      return "Block Device";

-    case kHeFSFileKindCharacter:

-      return "Character Device";

-    case kHeFSFileKindFIFO:

-      return "FIFO";

-    case kHeFSFileKindSocket:

-      return "Socket";

-    case kHeFSFileKindSymbolicLink:

-      return "Symbolic Link";

-    case kHeFSFileKindUnknown:

-    default:

-      return "Unknown";

-  }

-}

-

-inline const Char* hefs_file_flags_to_string(UInt32 flags) noexcept {

-  switch (flags) {

-    case kHeFSFlagsNone:

-      return "No Flags";

-    case kHeFSFlagsReadOnly:

-      return "Read Only";

-    case kHeFSFlagsHidden:

-      return "Hidden";

-    case kHeFSFlagsSystem:

-      return "System";

-    case kHeFSFlagsArchive:

-      return "Archive";

-    case kHeFSFlagsDevice:

-      return "Device";

-    default:

-      return "Unknown";

-  }

-}

-}  // namespace Kernel::Detail

-

-namespace Kernel {

-/// @brief OpenHeFS filesystem parser class.

-/// @details This class is used to parse the OpenHeFS filesystem.

-class HeFileSystemParser final {

- public:

-  HeFileSystemParser()  = default;

-  ~HeFileSystemParser() = default;

-

- public:

-  HeFileSystemParser(const HeFileSystemParser&) = delete;

-  HeFileSystemParser& operator=(const HeFileSystemParser&) = delete;

-

-  HeFileSystemParser(HeFileSystemParser&&) = delete;

-  HeFileSystemParser& operator=(HeFileSystemParser&&) = delete;

-

- public:

-  /// @brief Make a EPM+OpenHeFS drive out of the disk.

-  /// @param drive The drive to write on.

-  /// @return If it was sucessful, see err_local_get().

-  _Output Bool Format(_Input _Output DriveTrait* drive, _Input const Int32 flags,

-                      const Utf8Char* part_name);

-

-  _Output Bool CreateINodeDirectory(_Input DriveTrait* drive, _Input const Int32 flags,

-                                    const Utf8Char* dir);

-

-  _Output Bool RemoveINodeDirectory(_Input DriveTrait* drive, _Input const Int32 flags,

-                                    const Utf8Char* dir);

-

-  _Output Bool CreateINode(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,

-                           const Utf8Char* name, const UInt8 kind);

-

-  _Output Bool DeleteINode(_Input DriveTrait* drive, _Input const Int32 flags, const Utf8Char* dir,

-                           const Utf8Char* name, const UInt8 kind);

-

-  _Output Bool INodeManip(_Input DriveTrait* drive, VoidPtr block, SizeT block_sz,

-                          const Utf8Char* dir, const Utf8Char* name, const UInt8 kind,

-                          const BOOL input);

-

- private:

-  _Output Bool INodeCtlManip(_Input DriveTrait* drive, _Input const Int32 flags,

-                             const Utf8Char* dir, const Utf8Char* name, const BOOL delete_or_create,

-                             const UInt8 kind);

-

-  _Output Bool INodeDirectoryCtlManip(_Input DriveTrait* drive, _Input const Int32 flags,

-                                      const Utf8Char* dir, const BOOL delete_or_create);

-};

-

-namespace OpenHeFS {

-

-  /// @brief Initialize OpenHeFS inside the main disk.

-  /// @return Whether it successfuly formated it or not.

-  Boolean fs_init_openhefs(Void) noexcept;

-}  // namespace OpenHeFS

-}  // namespace Kernel