0.0.1e: Last commit regarding 0.0.1

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

3 files changed, 193 insertions, 51 deletions

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 <FSKit/NeFS.h>
@@ -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)