HeFS.h

Go to the documentation of this file.

/* -------------------------------------------
 
  Copyright (C) 2024-2025, Amlal El Mahrouss, all rights reserved.
 
------------------------------------------- */
 
#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>

 
#define kHeFSVersion (0x0103)
#define kHeFSMagic "  HeFS"
#define kHeFSMagicLen (8)
 
#define kHeFSBlockLen (512U)
#define kHeFSFileNameLen (256U)
#define kHeFSPartNameLen (128U)
 
#define kHeFSMinimumDiskSize (gib_cast(128))
 
#define kHeFSDefaultVolumeName u8"HeFS Volume"
 
#define kHeFSINDStartOffset (sizeof(HEFS_BOOT_NODE))
#define kHeFSINStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY))
 
#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;

inline constexpr UInt16 kHeFSSliceCount = 0x10;
 
inline constexpr UInt16 kHeFSInvalidVID = 0xFFFF;
 
namespace Kernel {
typedef UInt64 ATime;

struct PACKED HEFS_BOOT_NODE final {
  Char     fMagic[kHeFSMagicLen];       
  Utf8Char fVolName[kHeFSPartNameLen];  
  UInt32   fVersion;                    
  UInt64   fBadSectors;                 
  UInt64   fSectorCount;                
  UInt64   fSectorSize;                 
  UInt32   fChecksum;                   
  UInt8    fDiskKind;  
  UInt8  fEncoding;    
  UInt64 fStartIND;    
  UInt64 fEndIND;      
  UInt64 fINDCount;    
  UInt64 fDiskSize;    
  UInt16 fDiskStatus;  
  UInt16 fDiskFlags;   
  UInt16 fVID;  
  UInt64 fStartIN;     
  UInt64 fEndIN;       
  UInt64 fStartBlock;  
  UInt64 fEndBlock;    
  UInt64 fJournalLBA;  
  Char   fPad[264];
};
 
inline constexpr ATime kHeFSTimeInvalid = 0x0000000000000000;
inline constexpr ATime kHeFSTimeMax     = 0xFFFFFFFFFFFFFFFF - 1;

struct PACKED HEFS_JOURNAL_NODE {
  UInt64 fHashPath;
  UInt64 fStatus;
  UInt64 fCopyElem;
  UInt8  fCopyKind;
  UInt8  fPad[487];
};

enum HeFSJournalKind : UInt8 {
  kJournalKindInvalid  = 0x00,
  kJournalKindWrite    = 0x01,
  kJournalKindRename   = 0x02,
  kJournalKindDelete   = 0x03,
  kJournalKindFlagEdit = 0x04,
  kJournalKindCreate   = 0x05,
  kJournalKindCount,
};

struct PACKED HEFS_INDEX_NODE final {
  UInt64 fHashPath;  
  UInt32 fFlags;     
  UInt16 fKind;      
  UInt32 fSize;      
  UInt32 fChecksum;  
 
  Boolean fSymLink;  
 
  ATime  fCreated, fAccessed, fModified, fDeleted;  
  UInt32 fUID, fGID;                                
  UInt32 fMode;  

  UInt32 fOffsetSliceLow;
  UInt32 fOffsetSliceHigh;
 
  Char fPad[437];
};
 
enum {
  kHeFSInvalidColor = 0,
  kHeFSRed          = 100,
  kHeFSBlack,
  kHeFSColorCount,
};

struct PACKED HEFS_INDEX_NODE_DIRECTORY final {
  UInt64 fHashPath;  
 
  UInt32 fFlags;       
  UInt16 fReserved;    
  UInt32 fEntryCount;  
  UInt32 fChecksum;    
 
  ATime fCreated, fAccessed, fModified,
      fDeleted;       
  UInt32 fUID, fGID;  
  UInt32 fMode;       

  UInt64 fINSlices[kHeFSSliceCount];  
 
  UInt8 fColor;                         
  Lba   fNext, fPrev, fChild, fParent;  
 
  Char fPad[285];
};
}  // namespace Kernel
 
namespace Kernel::Detail {
inline UInt32 hefs_year_get(ATime raw_atime) noexcept {
  return (raw_atime) >> 32;
}

inline UInt32 hefs_month_get(ATime raw_atime) noexcept {
  return (raw_atime) >> 24;
}

inline UInt32 hefs_day_get(ATime raw_atime) noexcept {
  return (raw_atime) >> 16;
}

inline UInt32 hefs_hour_get(ATime raw_atime) noexcept {
  return (raw_atime) >> 8;
}

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 {
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:
  _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 HeFS {

  Boolean fs_init_hefs(Void) noexcept;
}  // namespace HeFS
}  // namespace Kernel