OpenHeFS.h

Go to the documentation of this file.

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

 
#define kOpenHeFSVersion (0x0104)
#define kOpenHeFSMagic "OpenHeFS"
#define kOpenHeFSMagicLen (9U)
 
#define kOpenHeFSBlockLen (512U)
#define kOpenHeFSFileNameLen (256U)
#define kOpenHeFSPartNameLen (128U)
 
#define kOpenHeFSMinimumDiskSize (gib_cast(128))
 
#define kOpenHeFSDefaultVolumeName u8"OpenHeFS Volume"
 
#define kOpenHeFSINDStartOffset (sizeof(HEFS_BOOT_NODE))
#define kOpenHeFSINStartOffset (sizeof(HEFS_INDEX_NODE_DIRECTORY))
 
#define kOpenHeFSRootDirectory "/"
#define kOpenHeFSRootDirectoryU8 u8"/"
 
#define kOpenHeFSSeparator '/'
#define kOpenHeFSUpDir ".."
 
#define kOpenHeFSRootDirectoryLen (2U)
 
#define kOpenHeFSSearchAllStr u8"*"
 
struct HEFS_BOOT_NODE;
struct HEFS_INDEX_NODE;
struct HEFS_INDEX_NODE_DIRECTORY;
struct HEFS_JOURNAL_NODE;
 
enum : UInt8 {
  kOpenHeFSHardDrive         = 0xC0,  // Hard Drive
  kOpenHeFSSolidStateDrive   = 0xC1,  // Solid State Drive
  kOpenHeFSOpticalDrive      = 0x0C,  // Blu-Ray/DVD
  kOpenHeFSMassStorageDevice = 0xCC,  // USB
  kOpenHeFSScsiDrive         = 0xC4,  // SCSI Hard Drive
  kOpenHeFSFlashDrive        = 0xC6,
  kOpenHeFSUnknown           = 0xFF,  // Unknown device.
  kOpenHeFSDriveCount        = 8,
};
 
enum : UInt8 {
  kOpenHeFSStatusUnlocked = 0x18,
  kOpenHeFSStatusLocked,
  kOpenHeFSStatusError,
  kOpenHeFSStatusInvalid,
  kOpenHeFSStatusCount,
};
 
enum : UInt16 {
  kOpenHeFSEncodingFlagsUTF8 = 0x50,
  kOpenHeFSEncodingFlagsUTF16,
  kOpenHeFSEncodingFlagsUTF32,
  kOpenHeFSEncodingFlagsUTF16BE,
  kOpenHeFSEncodingFlagsUTF16LE,
  kOpenHeFSEncodingFlagsUTF32BE,
  kOpenHeFSEncodingFlagsUTF32LE,
  kOpenHeFSEncodingFlagsUTF8BE,
  kOpenHeFSEncodingFlagsUTF8LE,
  kOpenHeFSEncodingFlagsBinary,
  kOpenHeFSEncodingFlagsCount = 11,
  kOpenHeFSFlagsNone          = 0,
  kOpenHeFSFlagsReadOnly      = 0x100,
  kOpenHeFSFlagsHidden,
  kOpenHeFSFlagsSystem,
  kOpenHeFSFlagsArchive,
  kOpenHeFSFlagsDevice,
  kOpenHeFSFlagsCount = 7
};
 
inline constexpr UInt16 kOpenHeFSFileKindRegular      = 0x00;
inline constexpr UInt16 kOpenHeFSFileKindDirectory    = 0x01;
inline constexpr UInt16 kOpenHeFSFileKindBlock        = 0x02;
inline constexpr UInt16 kOpenHeFSFileKindCharacter    = 0x03;
inline constexpr UInt16 kOpenHeFSFileKindFIFO         = 0x04;
inline constexpr UInt16 kOpenHeFSFileKindSocket       = 0x05;
inline constexpr UInt16 kOpenHeFSFileKindSymbolicLink = 0x06;
inline constexpr UInt16 kOpenHeFSFileKindUnknown      = 0x07;
inline constexpr UInt16 kOpenHeFSFileKindCount        = 0x08;

inline constexpr UInt16 kOpenHeFSSliceCount = 0x10;
 
inline constexpr UInt16 kOpenHeFSInvalidVID = 0xFFFF;
 
namespace Kernel {
typedef UInt64 ATime;

struct PACKED HEFS_BOOT_NODE final {
  Char     fMagic[kOpenHeFSMagicLen];       
  Utf8Char fVolName[kOpenHeFSPartNameLen];  
  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 kOpenHeFSTimeInvalid = 0x0000000000000000;
inline constexpr ATime kOpenHeFSTimeMax     = 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 {
  kOpenHeFSInvalidColor = 0,
  kOpenHeFSRed          = 100,
  kOpenHeFSBlack,
  kOpenHeFSColorCount,
};

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[kOpenHeFSSliceCount];  
 
  UInt8 fColor;                         
  Lba   fNext, fPrev, fChild, fParent;  
 
  Char fPad[285];
};
}  // namespace Kernel
 
namespace Kernel::Detail {
inline UInt32 hefs_year_get(ATime raw_atime) {
  return (raw_atime) >> 32;
}

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

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

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

inline UInt32 hefs_minute_get(ATime raw_atime) {
  return (raw_atime) & 0xFF;
}
 
inline constexpr UInt32 kOpenHeFSBaseYear   = 1970;
inline constexpr UInt32 kOpenHeFSBaseMonth  = 1;
inline constexpr UInt32 kOpenHeFSBaseDay    = 1;
inline constexpr UInt32 kOpenHeFSBaseHour   = 0;
inline constexpr UInt32 kOpenHeFSBaseMinute = 0;
 
inline const Char* hefs_status_to_string(UInt16 status) {
  switch (status) {
    case kOpenHeFSStatusUnlocked:
      return "Unlocked";
    case kOpenHeFSStatusLocked:
      return "Locked";
    case kOpenHeFSStatusError:
      return "Error";
    case kOpenHeFSStatusInvalid:
      return "Invalid";
    default:
      return "Unknown";
  }
}
 
inline const Char* hefs_drive_kind_to_string(UInt8 kind) {
  switch (kind) {
    case kOpenHeFSHardDrive:
      return "Hard Drive";
    case kOpenHeFSSolidStateDrive:
      return "Solid State Drive";
    case kOpenHeFSOpticalDrive:
      return "Optical Drive";
    case kOpenHeFSMassStorageDevice:
      return "Mass Storage Device";
    case kOpenHeFSScsiDrive:
      return "SCSI/SAS Drive";
    case kOpenHeFSFlashDrive:
      return "Flash Drive";
    case kOpenHeFSUnknown:
    default:
      return "Unknown";
  }
}
 
inline const Char* hefs_encoding_to_string(UInt8 encoding) {
  switch (encoding) {
    case kOpenHeFSEncodingFlagsUTF8:
      return "UTF-8";
    case kOpenHeFSEncodingFlagsUTF16:
      return "UTF-16";
    case kOpenHeFSEncodingFlagsUTF32:
      return "UTF-32";
    case kOpenHeFSEncodingFlagsUTF16BE:
      return "UTF-16BE";
    case kOpenHeFSEncodingFlagsUTF16LE:
      return "UTF-16LE";
    case kOpenHeFSEncodingFlagsUTF32BE:
      return "UTF-32BE";
    case kOpenHeFSEncodingFlagsUTF32LE:
      return "UTF-32LE";
    case kOpenHeFSEncodingFlagsUTF8BE:
      return "UTF-8BE";
    case kOpenHeFSEncodingFlagsUTF8LE:
      return "UTF-8LE";
    default:
      return "Unknown";
  }
}
 
inline const Char* hefs_file_kind_to_string(UInt16 kind) {
  switch (kind) {
    case kOpenHeFSFileKindRegular:
      return "Regular File";
    case kOpenHeFSFileKindDirectory:
      return "Directory";
    case kOpenHeFSFileKindBlock:
      return "Block Device";
    case kOpenHeFSFileKindCharacter:
      return "Character Device";
    case kOpenHeFSFileKindFIFO:
      return "FIFO";
    case kOpenHeFSFileKindSocket:
      return "Socket";
    case kOpenHeFSFileKindSymbolicLink:
      return "Symbolic Link";
    case kOpenHeFSFileKindUnknown:
    default:
      return "Unknown";
  }
}
 
inline const Char* hefs_file_flags_to_string(UInt32 flags) {
  switch (flags) {
    case kOpenHeFSFlagsNone:
      return "No Flags";
    case kOpenHeFSFlagsReadOnly:
      return "Read Only";
    case kOpenHeFSFlagsHidden:
      return "Hidden";
    case kOpenHeFSFlagsSystem:
      return "System";
    case kOpenHeFSFlagsArchive:
      return "Archive";
    case kOpenHeFSFlagsDevice:
      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 OpenHeFS {

  Boolean fs_init_openhefs(Void);
}  // namespace OpenHeFS
}  // namespace Kernel