From 4d1a1aa6862737b77f128f4d17caaa81acfe312f Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Sat, 19 Apr 2025 10:10:09 +0200 Subject: dev, fs: document HeFS, add Ext2 C++ source file. Signed-off-by: Amlal El Mahrouss --- dev/kernel/FSKit/HeFS.h | 128 ++++++++++++++++++++++++++++++------------------ dev/kernel/FSKit/NeFS.h | 8 +-- 2 files changed, 83 insertions(+), 53 deletions(-) (limited to 'dev/kernel/FSKit') diff --git a/dev/kernel/FSKit/HeFS.h b/dev/kernel/FSKit/HeFS.h index 8fdf933e..15ed5ac2 100644 --- a/dev/kernel/FSKit/HeFS.h +++ b/dev/kernel/FSKit/HeFS.h @@ -79,24 +79,29 @@ inline constexpr UInt16 kHeFSFileKindCount = 0x08; /// @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 kHeFSBlockCount = 0x10; +inline constexpr UInt16 kHeFSInvalidVID = 0xFFFF; + +/// @brief HeFS 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 { - Kernel::Char fMagic[kHeFSMagicLen]; - Kernel::Utf16Char fVolName[kHeFSPartNameLen]; - Kernel::UInt32 fVersion; - Kernel::UInt64 fBadSectors; - Kernel::UInt64 fSectorCount; - Kernel::UInt64 fSectorSize; - Kernel::UInt32 fChecksum; - Kernel::UInt8 fDriveKind; - Kernel::UInt8 fEncoding; - Kernel::UInt64 fStartIND; - Kernel::UInt64 fEndIND; - Kernel::UInt64 fINodeCount; - Kernel::UInt64 fDiskSize; - Kernel::UInt16 fDiskStatus; - Kernel::UInt16 fDiskFlags; - Kernel::UInt16 fVID; // virtual identification number within an EPM disk. + 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). }; /// @brief Access time type. @@ -112,27 +117,26 @@ 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]; - Kernel::UInt32 fFlags; - Kernel::UInt16 fKind; - Kernel::UInt32 fSize; - Kernel::UInt32 fChecksum, fRecoverChecksum, fBlockChecksum, fLinkChecksum; + 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; - Kernel::UInt32 fUID, fGID; - Kernel::UInt32 fMode; + 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::UInt64 fBlockLinkStart[kHeFSBlockCount]; - Kernel::UInt64 fBlockLinkEnd[kHeFSBlockCount]; + Kernel::UInt64 fBlockLinkStart[kHeFSBlockCount]; /// @brief Start of the block link. + Kernel::UInt64 fBlockLinkEnd[kHeFSBlockCount]; /// @brief End of the block link. - Kernel::UInt64 fBlockStart[kHeFSBlockCount]; - Kernel::UInt64 fBlockEnd[kHeFSBlockCount]; + Kernel::UInt64 fBlockStart[kHeFSBlockCount]; /// @brief Start of the block. + Kernel::UInt64 fBlockEnd[kHeFSBlockCount]; /// @brief End of the block. - Kernel::UInt64 fBlockRecoveryStart[kHeFSBlockCount]; - Kernel::UInt64 fBlockRecoveryEnd[kHeFSBlockCount]; + Kernel::UInt64 fBlockRecoveryStart[kHeFSBlockCount]; /// @brief Start of the block recovery. + Kernel::UInt64 fBlockRecoveryEnd[kHeFSBlockCount]; /// @brief End of the block recovery. - /// @brief Red-black tree pointers. - Kernel::Lba fNext, fPrev, fChild, fParent; + Kernel::Lba fNext, fPrev, fChild, fParent; /// @brief Red-black tree pointers. }; /// @brief HeFS directory node. @@ -140,22 +144,21 @@ struct PACKED HeFS_INDEX_NODE final /// @note The directory node is a special type of INode that contains the directory entries. struct PACKED HeFS_INDEX_NODE_DIRECTORY final { - Kernel::Utf16Char fName[kHeFSFileNameLen]; + Kernel::Utf16Char fName[kHeFSFileNameLen]; /// @brief Directory name. - Kernel::UInt32 fFlags; - Kernel::UInt16 fKind; - Kernel::UInt32 fSize; - Kernel::UInt32 fChecksum, fIndexNodeChecksum; + 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; - Kernel::UInt32 fUID, fGID; - Kernel::UInt32 fMode; + 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::UInt64 fIndexNodeStart[kHeFSBlockCount]; - Kernel::UInt64 fIndexNodeEnd[kHeFSBlockCount]; + Kernel::UInt64 fIndexNodeStart[kHeFSBlockCount]; /// @brief Start of the index node. + Kernel::UInt64 fIndexNodeEnd[kHeFSBlockCount]; /// @brief End of the index node. - /// @brief Red-black tree pointers. - Kernel::Lba fNext, fPrev, fChild, fParent; + Kernel::Lba fNext, fPrev, fChild, fParent; /// @brief Red-black tree pointers. }; namespace Kernel::Detail @@ -166,7 +169,7 @@ namespace Kernel::Detail /// @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 & 0x00000000FFFFFFFF) >> 32; + return (raw_atime) >> 32; } /// @brief HeFS get month from ATime. @@ -175,7 +178,7 @@ namespace Kernel::Detail /// @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 & 0x00000000FFFFFFFF) >> 24; + return (raw_atime) >> 24; } /// @brief HeFS get day from ATime. @@ -184,7 +187,7 @@ namespace Kernel::Detail /// @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 & 0x00000000FFFFFFFF) >> 16; + return (raw_atime) >> 16; } /// @brief HeFS get hour from ATime. @@ -193,7 +196,7 @@ namespace Kernel::Detail /// @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 & 0x00000000FFFFFFFF) >> 8; + return (raw_atime) >> 8; } /// @brief HeFS get minute from ATime. @@ -202,7 +205,7 @@ 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 & 0x00000000FFFFFFFF); + return (raw_atime) & 0xFF; } inline constexpr UInt32 kHeFSBaseYear = 1970; @@ -210,4 +213,31 @@ namespace Kernel::Detail 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: return "Unknown"; + default: return "Unknown"; + } + } } // namespace Kernel::Detail \ No newline at end of file diff --git a/dev/kernel/FSKit/NeFS.h b/dev/kernel/FSKit/NeFS.h index 747af16b..e4002f42 100644 --- a/dev/kernel/FSKit/NeFS.h +++ b/dev/kernel/FSKit/NeFS.h @@ -329,7 +329,7 @@ namespace Kernel /// /// \name NeFileSystemHelper - /// \brief Filesystem helper and utils. + /// \brief Filesystem helper class. /// class NeFileSystemHelper final @@ -352,11 +352,11 @@ namespace Kernel { if (!stamp) { - kout << "Invalid: Journal Stamp, using default name.\r"; + kout << "Invalid: Journal stamp, using default name.\r"; return; } - (void)(kout << "Info: Journal stamp: " << stamp << kendl); + (Void)(kout << "Info: Journal stamp: " << stamp << kendl); rt_copy_memory((VoidPtr)stamp, this->mStamp, rt_string_len(stamp)); } @@ -428,7 +428,7 @@ namespace Kernel if (!parser->CreateFork(new_fork)) return NO; - (void)(kout << "XML Commited: " << xml_data << "\r\nTo Journal Fork: " << journal_name << kendl); + (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); -- cgit v1.2.3 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/kernel/FSKit') 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