NeFS.h

Go to the documentation of this file.

/* ========================================
 
  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/Config.h>
#include <NeKit/KString.h>
#include <hint/CompilerHint.h>

 
#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"

#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)

#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)

#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,
};

struct PACKED NEFS_CATALOG_STRUCT final {
  BOOL ForkOrCatalog : 1 {0};
 
  Kernel::Char Name[kNeFSCatalogNameLen] = {0};
  Kernel::Char Mime[kNeFSMimeNameLen]    = {0};

  Kernel::UInt16 Flags;

  Kernel::UInt16 Status;

  Kernel::UInt16 CatalogFlags;

  Kernel::Int32 Kind;

  Kernel::Lba DataForkSize;

  Kernel::Lba ResourceForkSize;

  Kernel::Lba DataFork;
  Kernel::Lba ResourceFork;

  Kernel::Lba NextSibling;
  Kernel::Lba PrevSibling;

  Kernel::Lba NextBestSibling;
  Kernel::Lba NextPrevSibling;
 
  Kernel::UInt32 Checksum;
};

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;    
 
  Kernel::Lba NextSibling;
  Kernel::Lba PreviousSibling;
};

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,
};

enum { kNeFSRsrcForkKind = 0, kNeFSDataForkKind = 1 };

class NeFileSystemParser final {
 public:
  explicit NeFileSystemParser() = default;
  ~NeFileSystemParser()         = default;
 
 public:
  NE_COPY_DELETE(NeFileSystemParser)
 
  NE_MOVE_DELETE(NeFileSystemParser)
 
 public:
  _Output BOOL CreateFork(_Input NEFS_FORK_STRUCT& in);

  _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);

  _Output Bool Format(_Input _Output DriveTrait* drive, _Input const Int32 flags,
                      const Char* part_name);
 
 public:
  UInt32 mDriveIndex{kNeFSSubDriveA};
};

 
class NeFileSystemHelper final {
 public:
  STATIC const Char* Root();
  STATIC const Char* UpDir();
  STATIC Char        Separator();
  STATIC Char        MetaFile();
};

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);
}  // namespace NeFS
}  // namespace Kernel