From 6402e4cdbe4a7f5189501204b151d7accde474a3 Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Sat, 19 Apr 2025 18:28:18 +0200 Subject: 0.0.1e: Last commit regarding 0.0.1 Signed-off-by: Amlal El Mahrouss --- dev/kernel/FSKit/HeFS.h | 225 ++++++++++++++++++++++++++++++++++++---------- dev/kernel/FSKit/NeFS.h | 4 +- dev/kernel/src/FS/NeFS.cc | 15 +++- 3 files changed, 193 insertions(+), 51 deletions(-) (limited to 'dev') diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h index 15ed5ac2..fae33072 100644 --- a/dev/kernel/FSKit/HeFS.h +++ b/dev/kernel/FSKit/HeFS.h @@ -86,22 +86,22 @@ inline constexpr UInt16 kHeFSInvalidVID = 0xFFFF; /// @note The boot node is the first block of the filesystem. struct PACKED HeFS_BOOT_NODE final { - Kernel::Char fMagic[kHeFSMagicLen]; /// @brief Magic number of the filesystem. + Kernel::Char fMagic[kHeFSMagicLen]; /// @brief Magic number of the filesystem. Kernel::Utf16Char fVolName[kHeFSPartNameLen]; /// @brief Volume name. - Kernel::UInt32 fVersion; /// @brief Version of the filesystem. - Kernel::UInt64 fBadSectors; /// @brief Number of bad sectors in the filesystem. - Kernel::UInt64 fSectorCount; /// @brief Number of sectors in the filesystem. - Kernel::UInt64 fSectorSize; /// @brief Size of the sector. - Kernel::UInt32 fChecksum; /// @brief Checksum of the boot node. - Kernel::UInt8 fDriveKind; /// @brief Kind of the drive. (Hard Drive, Solid State Drive, Optical Drive, etc). - Kernel::UInt8 fEncoding; /// @brief Encoding of the filesystem. (UTF-8, UTF-16, etc). - Kernel::UInt64 fStartIND; /// @brief Start of the INode tree. - Kernel::UInt64 fEndIND; /// @brief End of the INode tree. - Kernel::UInt64 fINDCount; /// @brief Number of leafs in the INode tree. - Kernel::UInt64 fDiskSize; /// @brief Size of the disk. (Could be a virtual size, that is not the real size of the disk.) - Kernel::UInt16 fDiskStatus; /// @brief Status of the disk. (locked, unlocked, error, invalid). - Kernel::UInt16 fDiskFlags; /// @brief Flags of the disk. (read-only, read-write, etc). - Kernel::UInt16 fVID; /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used). + Kernel::UInt32 fVersion; /// @brief Version of the filesystem. + Kernel::UInt64 fBadSectors; /// @brief Number of bad sectors in the filesystem. + Kernel::UInt64 fSectorCount; /// @brief Number of sectors in the filesystem. + Kernel::UInt64 fSectorSize; /// @brief Size of the sector. + Kernel::UInt32 fChecksum; /// @brief Checksum of the boot node. + Kernel::UInt8 fDriveKind; /// @brief Kind of the drive. (Hard Drive, Solid State Drive, Optical Drive, etc). + Kernel::UInt8 fEncoding; /// @brief Encoding of the filesystem. (UTF-8, UTF-16, etc). + Kernel::UInt64 fStartIND; /// @brief Start of the INode tree. + Kernel::UInt64 fEndIND; /// @brief End of the INode tree. + Kernel::UInt64 fINDCount; /// @brief Number of leafs in the INode tree. + Kernel::UInt64 fDiskSize; /// @brief Size of the disk. (Could be a virtual size, that is not the real size of the disk.) + Kernel::UInt16 fDiskStatus; /// @brief Status of the disk. (locked, unlocked, error, invalid). + Kernel::UInt16 fDiskFlags; /// @brief Flags of the disk. (read-only, read-write, etc). + Kernel::UInt16 fVID; /// @brief Virtual Identification Number within an EPM disk. (0xFFFF if not used). }; /// @brief Access time type. @@ -117,24 +117,24 @@ inline constexpr ATime kHeFSTimeMax = 0xFFFFFFFFFFFFFFFF; /// @note The index node is used to store the file information of a file. struct PACKED HeFS_INDEX_NODE final { - Kernel::Utf16Char fName[kHeFSFileNameLen]; /// @brief File name. - Kernel::UInt32 fFlags; /// @brief File flags. - Kernel::UInt16 fKind; /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket, Symbolic Link, Unknown). - Kernel::UInt32 fSize; /// @brief File size. + Kernel::Utf16Char fName[kHeFSFileNameLen]; /// @brief File name. + Kernel::UInt32 fFlags; /// @brief File flags. + Kernel::UInt16 fKind; /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket, Symbolic Link, Unknown). + Kernel::UInt32 fSize; /// @brief File size. Kernel::UInt32 fChecksum, fRecoverChecksum, fBlockChecksum, fLinkChecksum; /// @brief Checksum of the file, recovery checksum, block checksum, link checksum. ATime fCreated, fAccessed, fModified, fDeleted; /// @brief File timestamps. - Kernel::UInt32 fUID, fGID; /// @brief User ID and Group ID of the file. - Kernel::UInt32 fMode; /// @brief File mode. (read, write, execute, etc). + Kernel::UInt32 fUID, fGID; /// @brief User ID and Group ID of the file. + Kernel::UInt32 fMode; /// @brief File mode. (read, write, execute, etc). Kernel::UInt64 fBlockLinkStart[kHeFSBlockCount]; /// @brief Start of the block link. - Kernel::UInt64 fBlockLinkEnd[kHeFSBlockCount]; /// @brief End of the block link. + Kernel::UInt64 fBlockLinkEnd[kHeFSBlockCount]; /// @brief End of the block link. Kernel::UInt64 fBlockStart[kHeFSBlockCount]; /// @brief Start of the block. - Kernel::UInt64 fBlockEnd[kHeFSBlockCount]; /// @brief End of the block. + Kernel::UInt64 fBlockEnd[kHeFSBlockCount]; /// @brief End of the block. Kernel::UInt64 fBlockRecoveryStart[kHeFSBlockCount]; /// @brief Start of the block recovery. - Kernel::UInt64 fBlockRecoveryEnd[kHeFSBlockCount]; /// @brief End of the block recovery. + Kernel::UInt64 fBlockRecoveryEnd[kHeFSBlockCount]; /// @brief End of the block recovery. Kernel::Lba fNext, fPrev, fChild, fParent; /// @brief Red-black tree pointers. }; @@ -146,17 +146,17 @@ struct PACKED HeFS_INDEX_NODE_DIRECTORY final { Kernel::Utf16Char fName[kHeFSFileNameLen]; /// @brief Directory name. - Kernel::UInt32 fFlags; /// @brief File flags. - Kernel::UInt16 fKind; /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket, Symbolic Link, Unknown). - Kernel::UInt32 fSize; /// @brief Size of the directory. + Kernel::UInt32 fFlags; /// @brief File flags. + Kernel::UInt16 fKind; /// @brief File kind. (Regular, Directory, Block, Character, FIFO, Socket, Symbolic Link, Unknown). + Kernel::UInt32 fSize; /// @brief Size of the directory. Kernel::UInt32 fChecksum, fIndexNodeChecksum; /// @brief Checksum of the file, index node checksum. ATime fCreated, fAccessed, fModified, fDeleted; /// @brief File timestamps. - Kernel::UInt32 fUID, fGID; /// @brief User ID and Group ID of the file. - Kernel::UInt32 fMode; /// @brief File mode. (read, write, execute, etc). + Kernel::UInt32 fUID, fGID; /// @brief User ID and Group ID of the file. + Kernel::UInt32 fMode; /// @brief File mode. (read, write, execute, etc). Kernel::UInt64 fIndexNodeStart[kHeFSBlockCount]; /// @brief Start of the index node. - Kernel::UInt64 fIndexNodeEnd[kHeFSBlockCount]; /// @brief End of the index node. + Kernel::UInt64 fIndexNodeEnd[kHeFSBlockCount]; /// @brief End of the index node. Kernel::Lba fNext, fPrev, fChild, fParent; /// @brief Red-black tree pointers. }; @@ -205,24 +205,29 @@ namespace Kernel::Detail /// @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; + 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 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"; + case kHeFSStatusUnlocked: + return "Unlocked"; + case kHeFSStatusLocked: + return "Locked"; + case kHeFSStatusError: + return "Error"; + case kHeFSStatusInvalid: + return "Invalid"; + default: + return "Unknown"; } } @@ -230,14 +235,136 @@ namespace Kernel::Detail { 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: return "Unknown"; - default: return "Unknown"; + 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: + return "Unknown"; + default: + return "Unknown"; } } -} // namespace Kernel::Detail \ No newline at end of file + + inline const Char* hefs_encoding_to_string(UInt8 encoding) noexcept + { + switch (encoding) + { + case kHeFSEncodingUTF8: + return "UTF-8"; + case kHeFSEncodingUTF16: + return "UTF-16"; + case kHeFSEncodingUTF32: + return "UTF-32"; + case kHeFSEncodingUTF16BE: + return "UTF-16BE"; + case kHeFSEncodingUTF16LE: + return "UTF-16LE"; + case kHeFSEncodingUTF32BE: + return "UTF-32BE"; + case kHeFSEncodingUTF32LE: + return "UTF-32LE"; + case kHeFSEncodingUTF8BE: + return "UTF-8BE"; + case kHeFSEncodingUTF8LE: + 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: + return "Unknown"; + default: + return "Unknown"; + } + } + + inline const Char* hefs_file_flags_to_string(UInt32 flags) noexcept + { + switch (flags) + { + case 0x00: + return "No Flags"; + case 0x01: + return "Read Only"; + case 0x02: + return "Hidden"; + case 0x04: + return "System"; + case 0x08: + return "Archive"; + case 0x10: + return "Device"; + default: + return "Unknown"; + } + } + + inline Lba hefs_get_block_size(Lba block_size) noexcept + { + return block_size * kHeFSBlockCount; + } + + inline Lba hefs_get_block_count(Lba block_size, Lba block_count) noexcept + { + return block_size / block_count; + } +} // namespace Kernel::Detail + +namespace Kernel +{ + class HeFSFileSystemParser final + { + public: + HeFSFileSystemParser() = default; + ~HeFSFileSystemParser() = default; + + public: + HeFSFileSystemParser(const HeFSFileSystemParser&) = delete; + HeFSFileSystemParser& operator=(const HeFSFileSystemParser&) = delete; + + HeFSFileSystemParser(HeFSFileSystemParser&&) = delete; + HeFSFileSystemParser& operator=(HeFSFileSystemParser&&) = delete; + + public: + /// @brief Make a EPM+HeFS drive out of the disk. + /// @param drive The drive to write on. + /// @return If it was sucessful, see err_local_get(). + _Output Bool FormatEPM(_Input _Output DriveTrait* drive, _Input const Lba end_lba, _Input const Int32 flags, const Char* part_name); + + /// @brief Make a GPT+HeFS drive out of the disk. + /// @param drive The drive to write on. + /// @return If it was sucessful, see err_local_get(). + _Output Bool FormatGPT(_Input _Output DriveTrait* drive, _Input const Lba end_lba, _Input const Int32 flags, const Char* part_name); + + public: + UInt32 mDriveIndex{MountpointInterface::kDriveIndexA}; /// @brief Drive index. + }; +} // namespace Kernel \ No newline at end of file diff --git a/dev/kernel/FSKit/NeFS.h b/dev/kernel/FSKit/NeFS.h index e4002f42..4f4151d7 100644 --- a/dev/kernel/FSKit/NeFS.h +++ b/dev/kernel/FSKit/NeFS.h @@ -321,7 +321,9 @@ namespace Kernel /// @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 Lba endLba, _Input const Int32 flags, const Char* part_name); + _Output Bool FormatEPM(_Input _Output DriveTrait* drive, _Input const Lba end_lba, _Input const Int32 flags, const Char* part_name); + + _Output Bool FormatGPT(_Input _Output DriveTrait* drive, _Input const Lba end_lba, _Input const Int32 flags, const Char* part_name); public: UInt32 mDriveIndex{kNeFSSubDriveA}; diff --git a/dev/kernel/src/FS/NeFS.cc b/dev/kernel/src/FS/NeFS.cc index 8bbec1d2..9cab99c5 100644 --- a/dev/kernel/src/FS/NeFS.cc +++ b/dev/kernel/src/FS/NeFS.cc @@ -4,6 +4,7 @@ ------------------------------------------- */ +#include "NewKit/Macros.h" #ifdef __FSKIT_INCLUDES_NEFS__ #include @@ -454,10 +455,22 @@ _Output NEFS_CATALOG_STRUCT* NeFileSystemParser::CreateCatalog(_Input const Char return nullptr; } +_Output Bool NeFileSystemParser::FormatGPT(_Input _Output DriveTrait* drive, _Input const Lba end_lba, _Input const Int32 flags, const Char* part_name) +{ + NE_UNUSED(drive); + NE_UNUSED(end_lba); + NE_UNUSED(flags); + NE_UNUSED(part_name); + + (void)(kout << "FormatGPT: Not implemented yet.\r"); + + return NO; +} + /// @brief Make a EPM+NeFS drive out of the disk. /// @param drive The drive to write on. /// @return If it was sucessful, see err_global_get(). -bool NeFileSystemParser::Format(_Input _Output DriveTrait* drive, _Input const Lba endLba, _Input const Int32 flags, const Char* part_name) +bool NeFileSystemParser::FormatEPM(_Input _Output DriveTrait* drive, _Input const Lba endLba, _Input const Int32 flags, const Char* part_name) { if (*part_name == 0 || endLba == 0) -- cgit v1.2.3