[MHR-36] Refactors and such.

Signed-off-by: Amlal <amlal@zka.com>

8 files changed, 146 insertions, 147 deletions

diff --git a/Boot/BootKit/BootKit.hxx b/Boot/BootKit/BootKit.hxx
index 1b93bd30..aa9482a2 100644
--- a/Boot/BootKit/BootKit.hxx
+++ b/Boot/BootKit/BootKit.hxx
@@ -226,7 +226,7 @@ public:
 
 		fDiskDev.Read(buf, BootDev::kSectorSize);
 
-		NewPartitionBlock* blockPart = reinterpret_cast<NewPartitionBlock*>(buf);
+		NFS_ROOT_PARTITION_BLOCK* blockPart = reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(buf);
 
 		BTextWriter writer;
 
@@ -260,7 +260,7 @@ private:
 	/// @param fileBlobs the blobs.
 	/// @param blobCount the number of blobs to write.
 	/// @param partBlock the NewFS partition block.
-	Boolean WriteRootCatalog(BFileDescriptor* fileBlobs, SizeT blobCount, NewPartitionBlock& partBlock)
+	Boolean WriteRootCatalog(BFileDescriptor* fileBlobs, SizeT blobCount, NFS_ROOT_PARTITION_BLOCK& partBlock)
 	{
 		if (partBlock.SectorSize != BootDev::kSectorSize)
 			return false;
@@ -269,13 +269,13 @@ private:
 		Lba				 startLba = partBlock.StartCatalog;
 		BTextWriter		 writer;
 
-		Char bufCatalog[sizeof(NewCatalog)] = {0};
+		Char bufCatalog[sizeof(NFS_CATALOG_STRUCT)] = {0};
 
 		constexpr auto cNewFSCatalogPadding = 4;
 
-		NewCatalog* catalogKind	 = (NewCatalog*)bufCatalog;
+		NFS_CATALOG_STRUCT* catalogKind	 = (NFS_CATALOG_STRUCT*)bufCatalog;
 		catalogKind->PrevSibling = startLba;
-		catalogKind->NextSibling = (startLba + (sizeof(NewCatalog) * cNewFSCatalogPadding));
+		catalogKind->NextSibling = (startLba + (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding));
 
 		/// Fill catalog kind.
 		catalogKind->Kind  = blob->fKind;
@@ -293,14 +293,14 @@ private:
 		memcpy(catalogKind->Name, blob->fFileName, strlen(blob->fFileName));
 
 		fDiskDev.Leak().mBase = startLba;
-		fDiskDev.Leak().mSize = sizeof(NewCatalog);
+		fDiskDev.Leak().mSize = sizeof(NFS_CATALOG_STRUCT);
 
-		fDiskDev.Write((Char*)bufCatalog, sizeof(NewCatalog));
+		fDiskDev.Write((Char*)bufCatalog, sizeof(NFS_CATALOG_STRUCT));
 
 		--partBlock.FreeCatalog;
 		--partBlock.FreeSectors;
 
-		memset(bufCatalog, 0, sizeof(NewCatalog));
+		memset(bufCatalog, 0, sizeof(NFS_CATALOG_STRUCT));
 
 		return true;
 	}
@@ -327,7 +327,7 @@ inline Boolean BDiskFormatFactory<BootDev>::Format(const char*							partName,
 	SizeT sectorSz					= BootDev::kSectorSize;
 	Char  buf[BootDev::kSectorSize] = {0};
 
-	NewPartitionBlock* partBlock = reinterpret_cast<NewPartitionBlock*>(buf);
+	NFS_ROOT_PARTITION_BLOCK* partBlock = reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(buf);
 
 	memcpy(partBlock->Ident, kNewFSIdent, kNewFSIdentLen - 1);
 	memcpy(partBlock->PartitionName, partName, strlen(partName));
@@ -348,7 +348,7 @@ inline Boolean BDiskFormatFactory<BootDev>::Format(const char*							partName,
 	partBlock->CatalogCount = blobCount;
 	partBlock->Kind			= kNewFSHardDrive;
 	partBlock->SectorSize	= sectorSz;
-	partBlock->FreeCatalog	= fDiskDev.GetSectorsCount() / sizeof(NewCatalog);
+	partBlock->FreeCatalog	= fDiskDev.GetSectorsCount() / sizeof(NFS_CATALOG_STRUCT);
 	partBlock->SectorCount	= fDiskDev.GetSectorsCount();
 	partBlock->FreeSectors	= fDiskDev.GetSectorsCount();
 	partBlock->StartCatalog = kNewFSCatalogStartAddress;
@@ -366,10 +366,10 @@ inline Boolean BDiskFormatFactory<BootDev>::Format(const char*							partName,
 		/// Reset buffer.
 		SetMem(buf, 0, sectorSz);
 
-		BootBlockType* epmBoot = (BootBlockType*)buf;
+		BOOT_BLOCK_STRUCT* epmBoot = (BOOT_BLOCK_STRUCT*)buf;
 
 		constexpr auto cFsName	  = "NewFS";
-		constexpr auto cBlockName = "Zeta:";
+		constexpr auto cBlockName = "ZKA:";
 
 		CopyMem(reinterpret_cast<VoidPtr>(const_cast<Char*>(cFsName)), epmBoot->Fs, StrLen(cFsName));
 
diff --git a/Boot/Sources/HEL/AMD64/BootMain.cxx b/Boot/Sources/HEL/AMD64/BootMain.cxx
index 5828e340..3cd6c0e3 100644
--- a/Boot/Sources/HEL/AMD64/BootMain.cxx
+++ b/Boot/Sources/HEL/AMD64/BootMain.cxx
@@ -20,7 +20,7 @@
 
 // make the compiler shut up.
 #ifndef kMachineModel
-#define kMachineModel "Zeta SSD"
+#define kMachineModel "ZKA SSD"
 #endif // !kMachineModel
 
 #ifndef cExpectedWidth
diff --git a/Boot/amd64-efi.make b/Boot/amd64-efi.make
index b9a4fc1a..f1e40d7a 100644
--- a/Boot/amd64-efi.make
+++ b/Boot/amd64-efi.make
@@ -21,7 +21,7 @@ EMU=qemu-system-x86_64
 endif
 
 ifeq ($(NEWS_MODEL), )
-NEWOS_MODEL=-DkMachineModel="\"Zeta SSD\""
+NEWOS_MODEL=-DkMachineModel="\"ZKA SSD\""
 endif
 
 BIOS=OVMF.fd
diff --git a/Kernel/FSKit/NewFS.hxx b/Kernel/FSKit/NewFS.hxx
index f8924fee..711bde0b 100644
--- a/Kernel/FSKit/NewFS.hxx
+++ b/Kernel/FSKit/NewFS.hxx
@@ -68,9 +68,11 @@ default.
 #define kNewFSCatalogKindRLE	(11)
 
 #define kNewFSSeparator '\\'
+#define kNewFSSeparatorAlt '/'
 
 #define kNewFSUpDir ".."
 #define kNewFSRoot	"\\"
+#define kNewFSRootAlt "/"
 
 #define kNewFSLF  '\r'
 #define kNewFSEOF (-1)
@@ -80,7 +82,7 @@ default.
 
 /// Start After the PM headers, pad 1024 bytes.
 #define kNewFSStartLba			  (1024)
-#define kNewFSCatalogStartAddress ((2048) + sizeof(NewPartitionBlock) + sizeof(NewCatalog))
+#define kNewFSCatalogStartAddress ((2048) + sizeof(NFS_ROOT_PARTITION_BLOCK) + sizeof(NFS_CATALOG_STRUCT))
 
 #define kResourceTypeDialog (10)
 #define kResourceTypeString (11)
@@ -111,7 +113,7 @@ enum
 };
 
 /// @brief Catalog type.
-struct PACKED NewCatalog final
+struct PACKED NFS_CATALOG_STRUCT final
 {
 	NewCharType Name[kNewFSNodeNameLen];
 	NewCharType Mime[kNewFSMimeNameLen];
@@ -140,7 +142,7 @@ struct PACKED NewCatalog final
 /// @note The way we store is way different than how other filesystems do, specific chunk of code are
 /// written into either the data fork or resource fork, the resource fork is reserved for file metadata.
 /// whereas the data fork is reserved for file data.
-struct PACKED NewFork final
+struct PACKED NFS_FORK_STRUCT final
 {
 	NewCharType	 ForkName[kNewFSForkNameLen];
 	Kernel::Char CatalogName[kNewFSNodeNameLen];
@@ -160,7 +162,7 @@ struct PACKED NewFork final
 };
 
 /// @brief Partition block type
-struct PACKED NewPartitionBlock final
+struct PACKED NFS_ROOT_PARTITION_BLOCK final
 {
 	NewCharType Ident[kNewFSIdentLen];
 	NewCharType PartitionName[kPartLen];
@@ -186,7 +188,6 @@ struct PACKED NewPartitionBlock final
 
 namespace Kernel
 {
-
 	enum
 	{
 		kNewFSSubDriveA,
@@ -223,47 +224,47 @@ namespace Kernel
 		/// @param catalog it's catalog
 		/// @param theFork the fork itself.
 		/// @return the fork
-		_Output NewFork* CreateFork(_Input NewCatalog* catalog,
-									_Input NewFork&	   theFork);
+		_Output NFS_FORK_STRUCT* CreateFork(_Input NFS_CATALOG_STRUCT* catalog,
+									_Input NFS_FORK_STRUCT&	   theFork);
 
 		/// @brief Find fork inside New filesystem.
 		/// @param catalog the catalog.
 		/// @param name the fork name.
 		/// @return the fork.
-		_Output NewFork* FindFork(_Input NewCatalog* catalog,
+		_Output NFS_FORK_STRUCT* FindFork(_Input NFS_CATALOG_STRUCT* catalog,
 								  _Input const Char* name,
 								  Boolean			 dataOrRsrc);
 
-		_Output Void RemoveFork(_Input NewFork* fork);
+		_Output Void RemoveFork(_Input NFS_FORK_STRUCT* fork);
 
-		_Output Void CloseFork(_Input NewFork* fork);
+		_Output Void CloseFork(_Input NFS_FORK_STRUCT* fork);
 
-		_Output NewCatalog* FindCatalog(_Input const char* catalogName, Lba& outLba);
+		_Output NFS_CATALOG_STRUCT* FindCatalog(_Input const char* catalogName, Lba& outLba);
 
-		_Output NewCatalog* GetCatalog(_Input const char* name);
+		_Output NFS_CATALOG_STRUCT* GetCatalog(_Input const char* name);
 
-		_Output NewCatalog* CreateCatalog(_Input const char*  name,
+		_Output NFS_CATALOG_STRUCT* CreateCatalog(_Input const char*  name,
 										  _Input const Int32& flags,
 										  _Input const Int32& kind);
 
-		_Output NewCatalog* CreateCatalog(_Input const char* name);
+		_Output NFS_CATALOG_STRUCT* CreateCatalog(_Input const char* name);
 
-		bool WriteCatalog(_Input _Output NewCatalog* catalog,
+		bool WriteCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
 						  voidPtr					 data,
 						  SizeT						 sizeOfData,
 						  _Input const char*		 forkName);
 
-		VoidPtr ReadCatalog(_Input _Output NewCatalog* catalog,
+		VoidPtr ReadCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
 							SizeT					   dataSz,
 							_Input const char*		   forkName);
 
-		bool Seek(_Input _Output NewCatalog* catalog, SizeT off);
+		bool Seek(_Input _Output NFS_CATALOG_STRUCT* catalog, SizeT off);
 
-		SizeT Tell(_Input _Output NewCatalog* catalog);
+		SizeT Tell(_Input _Output NFS_CATALOG_STRUCT* catalog);
 
 		bool RemoveCatalog(_Input const Char* catalog);
 
-		bool CloseCatalog(_InOut NewCatalog* catalog);
+		bool CloseCatalog(_InOut NFS_CATALOG_STRUCT* catalog);
 
 		/// @brief Make a EPM+NewFS drive out of the disk.
 		/// @param drive The drive to write on.
diff --git a/Kernel/FirmwareKit/EPM.hxx b/Kernel/FirmwareKit/EPM.hxx
index cb3eaa11..2766abf6 100644
--- a/Kernel/FirmwareKit/EPM.hxx
+++ b/Kernel/FirmwareKit/EPM.hxx
@@ -17,36 +17,6 @@
 #define kEPMFilesystemLength (16)
 #define kEPMMagicLength		 (5)
 
-/* The first 0 > 128 addresses of a disk contains these headers. */
-
-/// @brief EPM GUID structure.
-typedef struct BlockGUID
-{
-	Kernel::UInt32 Data1;
-	Kernel::UInt16 Data2;
-	Kernel::UInt16 Data3;
-	Kernel::UInt8  Data4[8];
-} BlockGUID;
-
-/**
- * @brief The EPM boot block.
- * @note NumBlock and LbaStart are ignored on some platforms.
- */
-struct PACKED BootBlock
-{
-	Kernel::Char  Magic[kEPMMagicLength];
-	Kernel::Char  Name[kEPMNameLength];
-	BlockGUID	  Uuid;
-	Kernel::Int32 Version;
-	Kernel::Int64 NumBlocks;
-	Kernel::Int64 SectorSz;
-	Kernel::Int64 LbaStart;
-	Kernel::Int16 Kind;
-	Kernel::Int32 FsVersion;
-	Kernel::Char  Fs[kEPMFilesystemLength]; /* NewFS, ffs2... */
-	Kernel::Char  Reserved[409];			// to fill a full sector.
-};
-
 /* @brief AMD64 magic for EPM */
 #define kEPMMagic86 "EPMAM"
 
@@ -79,19 +49,6 @@ struct PACKED BootBlock
 
 #define kEPMMagicError "EPM??"
 
-///! @brief Version kind enum.
-///! @brief Use in boot block version field.
-
-enum kEPMKind
-{
-	kEPMMpUx  = 0xcf, // Bridge or other embedded OS
-	kEPMLinux = 0x8f,
-	kEPMBSD	  = 0x9f,
-	kEPMNewOS = 0x1f, // This kernel.
-};
-
-typedef struct BootBlock BootBlockType;
-
 #ifdef __NEWOS_AMD64__
 #define kEPMMagic kEPMMagic86
 #else
@@ -104,7 +61,7 @@ typedef struct BootBlock BootBlockType;
 
 ///! @brief partition must start at this address.
 ///! Anything below is reserved for Data backup by the Main OS.
-#define kEPMStartPartitionBlk (sizeof(BootBlock))
+#define kEPMStartPartitionBlk (sizeof(_BOOT_BLOCK_STRUCT))
 
 ///! @brief Current EPM revision
 #define kEPMRevision (0xAD)
@@ -113,6 +70,47 @@ typedef struct BootBlock BootBlockType;
 /// !@brief EPM base address
 #define kEpmBase (0U)
 
-/// END OF SPECS
+/* The first 0 > 128 addresses of a disk contains these headers. */
+
+/// @brief EPM GUID structure.
+typedef struct _BLOCK_GUID_STRUCT
+{
+	Kernel::UInt32 Data1;
+	Kernel::UInt16 Data2;
+	Kernel::UInt16 Data3;
+	Kernel::UInt8  Data4[8];
+} BLOCK_GUID_STRUCT;
+
+/**
+ * @brief The EPM boot block.
+ * @note NumBlock and LbaStart are ignored on some platforms.
+ */
+struct PACKED _BOOT_BLOCK_STRUCT
+{
+	Kernel::Char  Magic[kEPMMagicLength];
+	Kernel::Char  Name[kEPMNameLength];
+	BLOCK_GUID_STRUCT	  Uuid;
+	Kernel::Int32 Version;
+	Kernel::Int64 NumBlocks;
+	Kernel::Int64 SectorSz;
+	Kernel::Int64 LbaStart;
+	Kernel::Int16 Kind;
+	Kernel::Int32 FsVersion;
+	Kernel::Char  Fs[kEPMFilesystemLength]; /* NewFS, ffs2... */
+	Kernel::Char  Reserved[409];			// to fill a full sector.
+};
+
+///! @brief Version kind enum.
+///! @brief Use in boot block version field.
+
+enum
+{
+	kEPMMpUx  = 0xcf, // Bridge or other embedded OS
+	kEPMLinux = 0x8f,
+	kEPMBSD	  = 0x9f,
+	kEPMNewOS = 0x1f, // This kernel.
+};
+
+typedef struct _BOOT_BLOCK_STRUCT BOOT_BLOCK_STRUCT;
 
 #endif // ifndef __FIRMWARE_EPM_HXX__
diff --git a/Kernel/Sources/FS/NewFS.cxx b/Kernel/Sources/FS/NewFS.cxx
index f796dd97..38a417cb 100644
--- a/Kernel/Sources/FS/NewFS.cxx
+++ b/Kernel/Sources/FS/NewFS.cxx
@@ -51,8 +51,8 @@ STATIC MountpointInterface sMountpointInterface;
 /// @param catalog it's catalog
 /// @param theFork the fork itself.
 /// @return the fork
-_Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
-										 _Input NewFork&	theFork)
+_Output NFS_FORK_STRUCT* NewFSParser::CreateFork(_Input NFS_CATALOG_STRUCT* catalog,
+										 _Input NFS_FORK_STRUCT&	theFork)
 {
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
 		return nullptr;
@@ -74,8 +74,8 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime,
 					   rt_string_len("fs/newfs-packet"));
 
-		NewFork curFork{0};
-		NewFork prevFork{0};
+		NFS_FORK_STRUCT curFork{0};
+		NFS_FORK_STRUCT prevFork{0};
 		Lba		lbaOfPreviousFork = lba;
 
 		/// do not check for anything. Loop until we get what we want, that is a free fork zone.
@@ -85,7 +85,7 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 				break;
 
 			drv->fPacket.fLba			= lba;
-			drv->fPacket.fPacketSize	= sizeof(NewFork);
+			drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 			drv->fPacket.fPacketContent = &curFork;
 
 			drv->fInput(&drv->fPacket);
@@ -115,7 +115,7 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 				if (lba >= kNewFSCatalogStartAddress)
 				{
 					drv->fPacket.fLba			= lbaOfPreviousFork;
-					drv->fPacket.fPacketSize	= sizeof(NewFork);
+					drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 					drv->fPacket.fPacketContent = &prevFork;
 
 					prevFork.NextSibling = lba;
@@ -132,12 +132,12 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 			4; /// this value gives us space for the data offset.
 
 		theFork.Flags			= kNewFSFlagCreated;
-		theFork.DataOffset		= lba - sizeof(NewFork) * cForkPadding;
+		theFork.DataOffset		= lba - sizeof(NFS_FORK_STRUCT) * cForkPadding;
 		theFork.PreviousSibling = lbaOfPreviousFork;
 		theFork.NextSibling		= theFork.DataOffset - theFork.DataSize;
 
 		drv->fPacket.fLba			= lba;
-		drv->fPacket.fPacketSize	= sizeof(NewFork);
+		drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 		drv->fPacket.fPacketContent = &theFork;
 
 		drv->fOutput(&drv->fPacket);
@@ -158,19 +158,19 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 /// @param catalog the catalog.
 /// @param name the fork name.
 /// @return the fork.
-_Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog,
+_Output NFS_FORK_STRUCT* NewFSParser::FindFork(_Input NFS_CATALOG_STRUCT* catalog,
 									   _Input const Char* name,
 									   Boolean			  isDataFork)
 {
 	auto	 drv	 = sMountpointInterface.GetAddressOf(this->fDriveIndex);
-	NewFork* theFork = nullptr;
+	NFS_FORK_STRUCT* theFork = nullptr;
 
 	Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork;
 
 	while (lba != 0)
 	{
 		drv->fPacket.fLba			= lba;
-		drv->fPacket.fPacketSize	= sizeof(NewFork);
+		drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 		drv->fPacket.fPacketContent = (VoidPtr)theFork;
 
 		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime, 16);
@@ -211,7 +211,7 @@ _Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog,
 /// file.)
 /// @param name
 /// @return catalog pointer.
-_Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name)
+_Output NFS_CATALOG_STRUCT* NewFSParser::CreateCatalog(_Input const char* name)
 {
 	return this->CreateCatalog(name, 0, kNewFSCatalogKindFile);
 }
@@ -221,7 +221,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name)
 /// @param flags the flags of the catalog.
 /// @param kind the catalog kind.
 /// @return catalog pointer.
-_Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
+_Output NFS_CATALOG_STRUCT* NewFSParser::CreateCatalog(_Input const char*  name,
 											   _Input const Int32& flags,
 											   _Input const Int32& kind)
 {
@@ -240,7 +240,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		name[rt_string_len(name) - 1] == NewFilesystemHelper::Separator())
 		return nullptr;
 
-	NewCatalog* copyExists = this->FindCatalog(name, outLba);
+	NFS_CATALOG_STRUCT* copyExists = this->FindCatalog(name, outLba);
 
 	if (copyExists)
 	{
@@ -284,7 +284,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		--indexReverseCopy;
 	}
 
-	NewCatalog* catalog = this->FindCatalog(parentName, outLba);
+	NFS_CATALOG_STRUCT* catalog = this->FindCatalog(parentName, outLba);
 
 	if (catalog && catalog->Kind == kNewFSCatalogKindFile)
 	{
@@ -298,7 +298,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	constexpr SizeT cDefaultForkSize = kNewFSForkSize;
 
-	NewCatalog* catalogChild = new NewCatalog();
+	NFS_CATALOG_STRUCT* catalogChild = new NFS_CATALOG_STRUCT();
 
 	catalogChild->ResourceForkSize = cDefaultForkSize;
 	catalogChild->DataForkSize	   = cDefaultForkSize;
@@ -326,7 +326,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	drive->fInput(&drive->fPacket);
 
-	NewCatalog* nextSibling = (NewCatalog*)catalogBuf;
+	NFS_CATALOG_STRUCT* nextSibling = (NFS_CATALOG_STRUCT*)catalogBuf;
 
 	startFree = nextSibling->NextSibling;
 
@@ -337,7 +337,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	while (drive->fPacket.fPacketGood)
 	{
-		nextSibling = (NewCatalog*)catalogBuf;
+		nextSibling = (NFS_CATALOG_STRUCT*)catalogBuf;
 
 		if (startFree <= kNewFSStartLba)
 		{
@@ -360,7 +360,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 			constexpr auto cNewFSCatalogPadding = 4;
 
-			NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBufPartBlock;
+			NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBufPartBlock;
 
 			if (partBlock->FreeCatalog < 1)
 			{
@@ -373,10 +373,10 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 			catalogChild->ResourceFork = catalogChild->DataFork;
 
 			catalogChild->NextSibling =
-				startFree + (sizeof(NewCatalog) * cNewFSCatalogPadding);
+				startFree + (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 			drive->fPacket.fPacketContent = catalogChild;
-			drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+			drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 			drive->fPacket.fLba			  = startFree;
 
 			drive->fOutput(&drive->fPacket);
@@ -384,7 +384,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 			drive->fPacket.fPacketContent = catalogBuf;
 			drive->fPacket.fPacketSize	  = kNewFSSectorSz;
 			drive->fPacket.fLba =
-				startFree - (sizeof(NewCatalog) * cNewFSCatalogPadding);
+				startFree - (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 			drive->fInput(&drive->fPacket);
 
@@ -417,7 +417,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		constexpr auto cNewFSCatalogPadding = 4;
 
 		//// @note that's how we find the next catalog in the partition block.
-		startFree = startFree + (sizeof(NewCatalog) * cNewFSCatalogPadding);
+		startFree = startFree + (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 		drive->fPacket.fPacketContent = catalogBuf;
 		drive->fPacket.fPacketSize	  = kNewFSSectorSz;
@@ -459,7 +459,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 	/// disk isnt faulty and data has been fetched.
 	if (drive->fPacket.fPacketGood)
 	{
-		NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBuf;
+		NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBuf;
 
 		/// check for an empty partition here.
 		if (partBlock->PartitionName[0] == 0 &&
@@ -485,10 +485,10 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 			partBlock->Kind			= kNewFSPartitionTypeStandard;
 			partBlock->StartCatalog = kNewFSCatalogStartAddress;
 			partBlock->Flags		= kNewFSPartitionTypeStandard;
-			partBlock->CatalogCount = sectorCount / sizeof(NewCatalog);
+			partBlock->CatalogCount = sectorCount / sizeof(NFS_CATALOG_STRUCT);
 			partBlock->SectorCount	= sectorCount;
 			partBlock->DiskSize		= diskSize;
-			partBlock->FreeCatalog	= sectorCount / sizeof(NewCatalog);
+			partBlock->FreeCatalog	= sectorCount / sizeof(NFS_CATALOG_STRUCT);
 
 			drive->fPacket.fPacketContent = sectorBuf;
 			drive->fPacket.fPacketSize	  = kNewFSSectorSz;
@@ -513,7 +513,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 				// make it bootable when needed.
 				Char bufEpmHdr[kNewFSSectorSz] = {0};
 
-				BootBlockType* epmBoot = (BootBlockType*)bufEpmHdr;
+				BOOT_BLOCK_STRUCT* epmBoot = (BOOT_BLOCK_STRUCT*)bufEpmHdr;
 
 				constexpr auto cFsName	  = "NewFS";
 				constexpr auto cBlockName = "Zeta:";
@@ -551,15 +551,15 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 /// @param catalog the catalog itself
 /// @param data the data.
 /// @return if the catalog w rote the contents successfully.
-bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data, SizeT sizeOfData, _Input const char* forkName)
+bool NewFSParser::WriteCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog, voidPtr data, SizeT sizeOfData, _Input const char* forkName)
 {
 	if (sizeOfData > catalog->DataForkSize)
 		return false;
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
 		return false;
 
-	NewFork* forkData = new NewFork();
-	rt_set_memory(forkData, 0, sizeof(NewFork));
+	NFS_FORK_STRUCT* forkData = new NFS_FORK_STRUCT();
+	rt_set_memory(forkData, 0, sizeof(NFS_FORK_STRUCT));
 
 	auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
@@ -574,7 +574,7 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
 	while (startFork >= kNewFSCatalogStartAddress)
 	{
 		drive->fPacket.fPacketContent = forkData;
-		drive->fPacket.fPacketSize	  = sizeof(NewFork);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_FORK_STRUCT);
 		drive->fPacket.fLba			  = startFork;
 
 		drive->fInput(&drive->fPacket);
@@ -635,7 +635,7 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
 /// @brief
 /// @param catalogName the catalog name.
 /// @return the newly found catalog.
-_Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
+_Output NFS_CATALOG_STRUCT* NewFSParser::FindCatalog(_Input const char* catalogName,
 											 Lba&				outLba)
 {
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
@@ -643,19 +643,19 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 
 	kcout << "newoskrnl: start finding catalog...\r";
 
-	Char* sectorBuf = new Char[sizeof(NewPartitionBlock)];
+	Char* sectorBuf = new Char[sizeof(NFS_ROOT_PARTITION_BLOCK)];
 	auto  drive		= sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
 	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
 				   rt_string_len("fs/newfs-packet"));
 
 	drive->fPacket.fPacketContent = sectorBuf;
-	drive->fPacket.fPacketSize	  = sizeof(NewPartitionBlock);
+	drive->fPacket.fPacketSize	  = sizeof(NFS_ROOT_PARTITION_BLOCK);
 	drive->fPacket.fLba			  = kNewFSStartLba;
 
 	drive->fInput(&drive->fPacket);
 
-	NewPartitionBlock* part = (NewPartitionBlock*)sectorBuf;
+	NFS_ROOT_PARTITION_BLOCK* part = (NFS_ROOT_PARTITION_BLOCK*)sectorBuf;
 
 	auto	   startCatalogList	 = part->StartCatalog;
 	const auto cCtartCatalogList = part->StartCatalog;
@@ -664,7 +664,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 
 	drive->fPacket.fLba			  = startCatalogList;
 	drive->fPacket.fPacketContent = sectorBuf;
-	drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+	drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 
 	drive->fInput(&drive->fPacket);
 
@@ -691,7 +691,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 			--indexReverseCopy;
 		}
 
-		NewCatalog* parentCatalog = this->FindCatalog(parentName, outLba);
+		NFS_CATALOG_STRUCT* parentCatalog = this->FindCatalog(parentName, outLba);
 
 		if (parentCatalog &&
 			!StringBuilder::Equals(parentName, NewFilesystemHelper::Root()))
@@ -712,7 +712,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 _NewFSSearchThroughCatalogList:
 	while (drive->fPacket.fPacketGood)
 	{
-		NewCatalog* catalog = (NewCatalog*)sectorBuf;
+		NFS_CATALOG_STRUCT* catalog = (NFS_CATALOG_STRUCT*)sectorBuf;
 
 		if (StringBuilder::Equals(catalogName, catalog->Name))
 		{
@@ -722,8 +722,8 @@ _NewFSSearchThroughCatalogList:
 				goto _NewFSContinueSearch;
 			}
 
-			NewCatalog* catalogPtr = new NewCatalog();
-			rt_copy_memory(catalog, catalogPtr, sizeof(NewCatalog));
+			NFS_CATALOG_STRUCT* catalogPtr = new NFS_CATALOG_STRUCT();
+			rt_copy_memory(catalog, catalogPtr, sizeof(NFS_CATALOG_STRUCT));
 
 			kcout << "newoskrnl: found catalog at: " << hex_number(startCatalogList) << endl;
 
@@ -740,7 +740,7 @@ _NewFSSearchThroughCatalogList:
 
 		drive->fPacket.fLba			  = startCatalogList;
 		drive->fPacket.fPacketContent = sectorBuf;
-		drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 
 		drive->fInput(&drive->fPacket);
 	}
@@ -762,7 +762,7 @@ _NewFSSearchThroughCatalogList:
 /// @brief
 /// @param name
 /// @return
-_Output NewCatalog* NewFSParser::GetCatalog(_Input const char* name)
+_Output NFS_CATALOG_STRUCT* NewFSParser::GetCatalog(_Input const char* name)
 {
 	Lba unused = 0;
 	return this->FindCatalog(name, unused);
@@ -771,7 +771,7 @@ _Output NewCatalog* NewFSParser::GetCatalog(_Input const char* name)
 /// @brief
 /// @param catalog
 /// @return
-Boolean NewFSParser::CloseCatalog(_Input _Output NewCatalog* catalog)
+Boolean NewFSParser::CloseCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog)
 {
 	if (!catalog)
 		return false;
@@ -809,21 +809,21 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName)
 
 		drive->fPacket.fLba = outLba; // the catalog position.
 		drive->fPacket.fPacketSize =
-			sizeof(NewCatalog);					 // size of catalog. roughly the sector size.
+			sizeof(NFS_CATALOG_STRUCT);					 // size of catalog. roughly the sector size.
 		drive->fPacket.fPacketContent = catalog; // the catalog itself.
 
 		drive->fOutput(&drive->fPacket); // send packet.
 
-		Char partitionBlockBuf[sizeof(NewPartitionBlock)] = {0};
+		Char partitionBlockBuf[sizeof(NFS_ROOT_PARTITION_BLOCK)] = {0};
 
 		drive->fPacket.fLba			  = kNewFSStartLba;
 		drive->fPacket.fPacketContent = partitionBlockBuf;
-		drive->fPacket.fPacketSize	  = sizeof(NewPartitionBlock);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_ROOT_PARTITION_BLOCK);
 
 		drive->fInput(&drive->fPacket);
 
-		NewPartitionBlock* partBlock =
-			reinterpret_cast<NewPartitionBlock*>(partitionBlockBuf);
+		NFS_ROOT_PARTITION_BLOCK* partBlock =
+			reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(partitionBlockBuf);
 
 		++partBlock->FreeCatalog;
 		--partBlock->CatalogCount;
@@ -848,7 +848,7 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName)
 /// @return
 /***********************************************************************************/
 
-VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
+VoidPtr NewFSParser::ReadCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
 								 _Input SizeT				dataSz,
 								 _Input const char*			forkName)
 {
@@ -867,23 +867,23 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
 	kcout << "newoskrnl: catalog " << catalog->Name
 		  << ", fork: " << hex_number(dataForkLba) << endl;
 
-	Char* sectorBuf = new Char[sizeof(NewFork)];
+	Char* sectorBuf = new Char[sizeof(NFS_FORK_STRUCT)];
 	auto  drive		= sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
 	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
 				   rt_string_len("fs/newfs-packet"));
 
-	NewFork* forkData = nullptr;
+	NFS_FORK_STRUCT* forkData = nullptr;
 
 	while (dataForkLba >= kNewFSCatalogStartAddress)
 	{
 		drive->fPacket.fLba			  = dataForkLba;
-		drive->fPacket.fPacketSize	  = sizeof(NewFork);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_FORK_STRUCT);
 		drive->fPacket.fPacketContent = sectorBuf;
 
 		drive->fInput(&drive->fPacket);
 
-		forkData = (NewFork*)sectorBuf;
+		forkData = (NFS_FORK_STRUCT*)sectorBuf;
 
 		kcout << "newoskrnl: name: " << forkData->ForkName << endl;
 
@@ -928,7 +928,7 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
 /// @return if the seeking was successful.
 /***********************************************************************************/
 
-bool NewFSParser::Seek(_Input _Output NewCatalog* catalog, SizeT off)
+bool NewFSParser::Seek(_Input _Output NFS_CATALOG_STRUCT* catalog, SizeT off)
 {
 	if (!catalog)
 	{
@@ -946,7 +946,7 @@ bool NewFSParser::Seek(_Input _Output NewCatalog* catalog, SizeT off)
 /// @return The position on the file.
 /***********************************************************************************/
 
-SizeT NewFSParser::Tell(_Input _Output NewCatalog* catalog)
+SizeT NewFSParser::Tell(_Input _Output NFS_CATALOG_STRUCT* catalog)
 {
 	if (!catalog)
 	{
@@ -972,16 +972,16 @@ namespace Kernel::Detail
 
 		sMountpointInterface.A().fVerify(&sMountpointInterface.A().fPacket);
 
-		Char partitionBlockBuf[sizeof(NewPartitionBlock)] = {0};
+		Char partitionBlockBuf[sizeof(NFS_ROOT_PARTITION_BLOCK)] = {0};
 
 		sMountpointInterface.A().fPacket.fLba			= kNewFSStartLba;
 		sMountpointInterface.A().fPacket.fPacketContent = partitionBlockBuf;
-		sMountpointInterface.A().fPacket.fPacketSize	= sizeof(NewPartitionBlock);
+		sMountpointInterface.A().fPacket.fPacketSize	= sizeof(NFS_ROOT_PARTITION_BLOCK);
 
 		sMountpointInterface.A().fInput(&sMountpointInterface.A().fPacket);
 
-		NewPartitionBlock* partBlock =
-			reinterpret_cast<NewPartitionBlock*>(partitionBlockBuf);
+		NFS_ROOT_PARTITION_BLOCK* partBlock =
+			reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(partitionBlockBuf);
 
 		if (!StringBuilder::Equals(partBlock->Ident, kNewFSIdent))
 		{
diff --git a/Kernel/Sources/FileManager.cxx b/Kernel/Sources/FileManager.cxx
index 6684ce0d..dcdced27 100644
--- a/Kernel/Sources/FileManager.cxx
+++ b/Kernel/Sources/FileManager.cxx
@@ -121,8 +121,8 @@ namespace Kernel
 
 		NEWOS_UNUSED(flags);
 
-		if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
-			fImpl->WriteCatalog(reinterpret_cast<NewCatalog*>(node), data, size,
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNewFSCatalogKindFile)
+			fImpl->WriteCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), data, size,
 								name);
 	}
 
@@ -139,8 +139,8 @@ namespace Kernel
 
 		NEWOS_UNUSED(flags);
 
-		if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
-			return fImpl->ReadCatalog(reinterpret_cast<NewCatalog*>(node), sz,
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNewFSCatalogKindFile)
+			return fImpl->ReadCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), sz,
 									  name);
 
 		return nullptr;
@@ -157,7 +157,7 @@ namespace Kernel
 		if (!node || off == 0)
 			return false;
 
-		return fImpl->Seek(reinterpret_cast<NewCatalog*>(node), off);
+		return fImpl->Seek(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), off);
 	}
 
 	/// @brief Tell where the catalog is.
@@ -170,7 +170,7 @@ namespace Kernel
 		if (!node)
 			return kNPos;
 
-		return fImpl->Tell(reinterpret_cast<NewCatalog*>(node));
+		return fImpl->Tell(reinterpret_cast<NFS_CATALOG_STRUCT*>(node));
 	}
 
 	/// @brief Rewinds the catalog.
diff --git a/Kernel/Sources/Main.cxx b/Kernel/Sources/Main.cxx
index b0083730..950a8e48 100644
--- a/Kernel/Sources/Main.cxx
+++ b/Kernel/Sources/Main.cxx
@@ -80,7 +80,7 @@ namespace Kernel::Detail
 						catalogDir = fNewFS->GetParser()->CreateCatalog(cDirStr[dirIndx], 0,
 																		kNewFSCatalogKindDir);
 
-						NewFork theFork{0};
+						NFS_FORK_STRUCT theFork{0};
 
 						const Kernel::Char* cSrcName = cFolderInfo;
 
@@ -122,7 +122,7 @@ namespace Kernel::Detail
 					}
 				}
 
-				NewCatalog* catalogDisk =
+				NFS_CATALOG_STRUCT* catalogDisk =
 					this->fNewFS->GetParser()->GetCatalog("\\Mount\\SIM:");
 
 				const Kernel::Char* cSrcName = "DISK-INF";
@@ -134,7 +134,7 @@ namespace Kernel::Detail
 				else
 				{
 					catalogDisk =
-						(NewCatalog*)this->Leak()->CreateAlias("\\Mount\\SIM:");
+						(NFS_CATALOG_STRUCT*)this->Leak()->CreateAlias("\\Mount\\SIM:");
 
 					Kernel::StringView diskFolder(kNewFSSectorSz);
 
@@ -147,7 +147,7 @@ namespace Kernel::Detail
 					diskFolder += Kernel::NewFilesystemHelper::Root();
 					diskFolder += "</p>\r";
 
-					NewFork theDiskFork{0};
+					NFS_FORK_STRUCT theDiskFork{0};
 
 					Kernel::rt_copy_memory((Kernel::VoidPtr)(cSrcName), theDiskFork.ForkName,
 										   Kernel::rt_string_len(cSrcName));