Merged in MHR-18 (pull request #9)

MHR-18

13 files changed, 534 insertions, 444 deletions

diff --git a/Private/Builtins/AHCI/AHCI.hxx b/Private/Builtins/AHCI/AHCI.hxx
index f5e139ac..b79299e7 100644
--- a/Private/Builtins/AHCI/AHCI.hxx
+++ b/Private/Builtins/AHCI/AHCI.hxx
@@ -318,27 +318,34 @@ typedef struct HbaCmdTbl final {
 
 /// @brief Initializes an AHCI disk.
 /// @param PortsImplemented the amount of port that have been detected.
-/// @return 
+/// @return
 NewOS::Boolean drv_std_init(NewOS::UInt16& PortsImplemented);
 
 NewOS::Boolean drv_std_detected(NewOS::Void);
 
 /// @brief Read from disk.
-/// @param Lba 
-/// @param Buf 
-/// @param SectorSz 
-/// @param Size 
-/// @return 
+/// @param Lba
+/// @param Buf
+/// @param SectorSz
+/// @param Size
+/// @return
 NewOS::Void drv_std_read(NewOS::UInt64 Lba, NewOS::Char* Buf,
                    NewOS::SizeT SectorSz, NewOS::SizeT Size);
 
 /// @brief Write to disk.
-/// @param Lba 
-/// @param Buf 
-/// @param SectorSz 
-/// @param Size 
-/// @return 
+/// @param Lba
+/// @param Buf
+/// @param SectorSz
+/// @param Size
+/// @return
 NewOS::Void drv_std_write(NewOS::UInt64 Lba, NewOS::Char* Buf,
                     NewOS::SizeT SectorSz, NewOS::SizeT Size);
 
+/// @brief get sector count.
+NewOS::SizeT drv_std_get_sector_count();
+
+/// @brief get device size.
+NewOS::SizeT drv_std_get_drv_size();
+
+
 #endif // ifdef __KERNEL__
diff --git a/Private/FSKit/NewFS.hxx b/Private/FSKit/NewFS.hxx
index 2a783b11..619c6c6b 100644
--- a/Private/FSKit/NewFS.hxx
+++ b/Private/FSKit/NewFS.hxx
@@ -38,13 +38,13 @@ default.
 
 #define kNewFSIdentLen 8
 #define kNewFSIdent " NewFS"
-#define kNewFSPadLen 408
+#define kNewFSPadLen 400
 
 /// @brief Partition GUID on EPM and GPT disks.
 #define kNewFSUUID "@{DD997393-9CCE-4288-A8D5-C0FDE3908DBE}"
 
-#define kNewFSVersionInteger 0x122
-#define kNewFSVerionString "1.2.2"
+#define kNewFSVersionInteger 0x123
+#define kNewFSVerionString "1.23"
 
 /// @brief Standard fork types.
 #define kNewFSDataFork "data"
@@ -83,7 +83,7 @@ default.
 
 /// Start After the PM headers, pad 1024 bytes.
 #define kNewFSAddressAsLba (512)
-#define kNewFSCatalogStartAddress (1024 + sizeof(NewPartitionBlock))
+#define kNewFSCatalogStartAddress (1024 + sizeof(NewPartitionBlock) + sizeof(NewCatalog))
 
 #define kResourceTypeDialog 10
 #define kResourceTypeString 11
@@ -96,7 +96,7 @@ default.
 #define kNewFSFlagUnallocated 0x00
 #define kNewFSFlagCreated 0x0F
 
-#define kNewFSMimeNameLen (216)
+#define kNewFSMimeNameLen (200)
 
 typedef NewOS::Char NewCharType;
 
@@ -117,6 +117,12 @@ struct PACKED NewCatalog final {
   NewOS::Int32 Flags;
   NewOS::Int32 Kind;
 
+  /// Size of the data fork.
+  NewOS::Lba DataForkSize;
+
+  /// Size of all resource forks.
+  NewOS::Lba ResourceForkOverallSize;
+
   NewOS::Lba DataFork;
   NewOS::Lba ResourceFork;
 
@@ -164,6 +170,8 @@ struct PACKED NewPartitionBlock final {
   NewOS::SizeT SectorCount;
   NewOS::SizeT SectorSize;
 
+  NewOS::UInt64 Version;
+
   NewOS::Char Pad[kNewFSPadLen];
 };
 
@@ -214,7 +222,7 @@ class NewFSParser final {
 
   _Output Void CloseFork(_Input NewFork* fork);
 
-  _Output NewCatalog* FindCatalog(_Input const char* catalogName);
+  _Output NewCatalog* FindCatalog(_Input const char* catalogName, Lba& outLba);
 
   _Output NewCatalog* GetCatalog(_Input const char* name);
 
@@ -224,7 +232,8 @@ class NewFSParser final {
 
   _Output NewCatalog* CreateCatalog(_Input const char* name);
 
-  bool WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data);
+  bool WriteCatalog(_Input _Output NewCatalog* catalog,
+                    voidPtr data, SizeT sizeOfData);
 
   VoidPtr ReadCatalog(_Input _Output NewCatalog* catalog,
                               SizeT dataSz);
diff --git a/Private/HALKit/AMD64/Storage/ATA-PIO.cxx b/Private/HALKit/AMD64/Storage/ATA-PIO.cxx
index 6fe1e29a..9b37e248 100644
--- a/Private/HALKit/AMD64/Storage/ATA-PIO.cxx
+++ b/Private/HALKit/AMD64/Storage/ATA-PIO.cxx
@@ -106,7 +106,8 @@ Void drv_std_read(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf,
 
   Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F));
 
-  Out8(IO + ATA_REG_SEC_COUNT0, 2);
+  /// Compute sector count.
+  Out8(IO + ATA_REG_SEC_COUNT0, SectorSz / (SectorSz / 2));
 
   Out8(IO + ATA_REG_LBA0, (Lba));
   Out8(IO + ATA_REG_LBA1, (Lba) >> 8);
@@ -133,9 +134,10 @@ Void drv_std_write(UInt64 Lba, UInt16 IO, UInt8 Master, Char* Buf,
   drv_std_wait_io(IO);
   drv_std_select(IO);
 
+  /// Compute sector count.
   Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F));
 
-  Out8(IO + ATA_REG_SEC_COUNT0, 2);
+  Out8(IO + ATA_REG_SEC_COUNT0, SectorSz / (SectorSz / 2));
 
   Out8(IO + ATA_REG_LBA0, (Lba));
   Out8(IO + ATA_REG_LBA1, (Lba) >> 8);
diff --git a/Private/KernelKit/FileManager.hpp b/Private/KernelKit/FileManager.hpp
index 603ee06b..ab65bbe1 100644
--- a/Private/KernelKit/FileManager.hpp
+++ b/Private/KernelKit/FileManager.hpp
@@ -86,7 +86,7 @@ class FilesystemManagerInterface {
 
  public:
   virtual Void Write(_Input NodePtr node, _Input VoidPtr data,
-                     _Input Int32 flags) = 0;
+                     _Input Int32 flags, _Input SizeT size) = 0;
   virtual _Output VoidPtr Read(_Input NodePtr node, _Input Int32 flags,
                                _Input SizeT sz) = 0;
 
@@ -122,7 +122,7 @@ class NewFilesystemManager final : public FilesystemManagerInterface {
  public:
   bool Remove(const char *path) override;
   NodePtr Open(const char *path, const char *r) override;
-  Void Write(NodePtr node, VoidPtr data, Int32 flags) override;
+  Void Write(NodePtr node, VoidPtr data, Int32 flags, SizeT sz) override;
   VoidPtr Read(NodePtr node, Int32 flags, SizeT sz) override;
   bool Seek(NodePtr node, SizeT off);
   SizeT Tell(NodePtr node) override;
diff --git a/Private/KernelKit/PEF.hpp b/Private/KernelKit/PEF.hpp
index 9fabb189..fe7430ab 100644
--- a/Private/KernelKit/PEF.hpp
+++ b/Private/KernelKit/PEF.hpp
@@ -103,4 +103,7 @@ enum {
 
 #define kPefStart "__ImageStart"
 
+#define kPefForkKind "PEF!"
+#define kPefForkKindFAT "FEP!"
+
 #endif /* ifndef __PEF__ */
diff --git a/Private/NewBoot/BootKit/BootKit.hxx b/Private/NewBoot/BootKit/BootKit.hxx
index c3e438ae..ca6f56ac 100644
--- a/Private/NewBoot/BootKit/BootKit.hxx
+++ b/Private/NewBoot/BootKit/BootKit.hxx
@@ -186,16 +186,9 @@ public:
         Char fForkName[kNewFSNodeNameLen];
 
         Int32 fKind;
-        Int64 fLba;
 
         VoidPtr fBlob;
         SizeT fBlobSz;
-
-        bool IsCatalogValid() { return fLba != 0 && fLba >= kNewFSCatalogStartAddress; }
-
-        struct BFileDescriptor* fParent;
-        struct BFileDescriptor* fPrev;
-        struct BFileDescriptor* fNext;
     };
 
 public:
@@ -236,7 +229,8 @@ public:
 
         if (blockPart->DiskSize != this->fDiskDev.GetDiskSize() ||
             blockPart->DiskSize < 1 ||
-            blockPart->SectorSize != BootDev::kSectorSize) {
+            blockPart->SectorSize != BootDev::kSectorSize ||
+            blockPart->Version != kNewFSVersionInteger) {
             EFI::ThrowError(L"Invalid-Disk-Geometry", L"Invalid disk geometry.");
         } else if (blockPart->PartitionName[0] == 0) {
             EFI::ThrowError(L"Invalid-Partition-Name", L"Invalid disk partition.");
@@ -252,7 +246,7 @@ private:
     /// @param fileBlobs the blobs.
     /// @param blobCount the number of blobs to write.
     /// @param partBlock the NewFS partition block.
-    Boolean FormatCatalog(BFileDescriptor* fileBlobs, SizeT blobCount,
+    Boolean WriteRootCatalog(BFileDescriptor* fileBlobs, SizeT blobCount,
                         NewPartitionBlock& partBlock) {
         if (partBlock.SectorSize != BootDev::kSectorSize) return false;
 
@@ -263,103 +257,95 @@ private:
         Char bufCatalog[sizeof(NewCatalog)] = { 0 };
         Char bufFork[sizeof(NewFork)] = { 0 };
 
-        while (blob) {
-            NewCatalog* catalogKind = (NewCatalog*)bufCatalog;
-
-            blob->fLba = startLba;
-
-            if (!blob->fParent)
-                catalogKind->PrevSibling = startLba;
-            else {
-                if (blob->IsCatalogValid()) {
-                    catalogKind->PrevSibling = blob->fParent->fLba;
-                } else {
-                    EFI::ThrowError(L"Invalid-Catalog-Location", L"Invalid catalog location.");
-                }
-            }
-
-            /// Fill catalog kind.
-            catalogKind->Kind = blob->fKind;
+        NewCatalog* catalogKind = (NewCatalog*)bufCatalog;
+        catalogKind->PrevSibling = startLba;
+        catalogKind->NextSibling = (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
 
-            /// Allocate fork for blob.
-            if (catalogKind->Kind == kNewFSDataForkKind) {
-                catalogKind->DataFork = (startLba + sizeof(NewCatalog));
-            } else {
-                catalogKind->ResourceFork = (startLba + sizeof(NewCatalog));
-            }
+        /// Fill catalog kind.
+        catalogKind->Kind = blob->fKind;
 
-            NewFork* forkKind = (NewFork*)bufFork;
+        /// Allocate fork for blob.
+        if (catalogKind->Kind == kNewFSDataForkKind) {
+            catalogKind->DataFork = (startLba + sizeof(NewCatalog));
+            catalogKind->DataForkSize += blob->fBlobSz;
+        } else {
+            catalogKind->ResourceFork = (startLba + sizeof(NewCatalog));
+            catalogKind->ResourceForkOverallSize += blob->fBlobSz;
+        }
 
-            memcpy(forkKind->Name, blob->fForkName, strlen(blob->fForkName));
-            forkKind->Kind = (forkKind->Name[0] == kNewFSDataFork[0]) ? kNewFSDataForkKind : kNewFSRsrcForkKind;
-            forkKind->Flags = kNewFSFlagCreated;
+        /// before going to forks, we must check for the catalog name first.
+        if (blob->fKind == kNewFSCatalogKindDir &&
+            blob->fFileName[strlen(blob->fFileName) - 1] != '/') {
+            EFI::ThrowError(L"Developer-Error", L"This is caused by the developer of the bootloader.");
+        }
 
-            /// We don't know.
-            forkKind->ResourceFlags = 0;
-            forkKind->ResourceId = 0;
-            forkKind->ResourceKind = 0;
+        NewFork* forkKind = (NewFork*)bufFork;
 
-            /// We're the only fork here.
-            forkKind->NextSibling = forkKind->Kind == kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
-            forkKind->PreviousSibling = kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
+        memcpy(forkKind->Name, blob->fForkName, strlen(blob->fForkName));
+        forkKind->Kind = (forkKind->Name[0] == kNewFSDataFork[0]) ? kNewFSDataForkKind : kNewFSRsrcForkKind;
+        forkKind->Flags = kNewFSFlagCreated;
 
-            forkKind->DataOffset = (startLba + sizeof(NewCatalog) + sizeof(NewFork));
-            forkKind->DataSize = blob->fBlobSz;
+        /// We don't know.
+        forkKind->ResourceFlags = 0;
+        forkKind->ResourceId = 0;
+        forkKind->ResourceKind = 0;
 
-            SizeT cur = 0UL;
+        /// We're the only fork here.
+        forkKind->NextSibling = forkKind->Kind == kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
+        forkKind->PreviousSibling = kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
 
-            writer.Write((catalogKind->Kind == kNewFSCatalogKindFile) ? L"New Boot: Write-File: " :
-                            L"New Boot: Write-Directory: " ).Write(blob->fFileName).Write(L"\r\n");
+        forkKind->DataOffset = (startLba + sizeof(NewCatalog) + sizeof(NewFork));
+        forkKind->DataSize = blob->fBlobSz;
 
-            /// Set disk cursor here.
+        SizeT cur = 0UL;
 
-            fDiskDev.Leak().mBase = startLba + sizeof(NewCatalog);
-            fDiskDev.Leak().mSize = sizeof(NewFork);
+        writer.Write((catalogKind->Kind == kNewFSCatalogKindFile) ? L"New Boot: Write-File: " :
+                        L"New Boot: Write-Directory: " ).Write(blob->fFileName).Write(L"\r\n");
 
-            fDiskDev.Write((Char*)bufFork, sizeof(NewFork));
+        /// Set disk cursor here.
 
-            do {
-                this->fDiskDev.Leak().mSize = BootDev::kSectorSize;
-                this->fDiskDev.Leak().mBase = (forkKind->DataOffset + cur);
+        fDiskDev.Leak().mBase = startLba + sizeof(NewCatalog);
+        fDiskDev.Leak().mSize = sizeof(NewFork);
 
-                this->fDiskDev.Write((Char*)(blob->fBlob) + cur, BootDev::kSectorSize);
+        fDiskDev.Write((Char*)bufFork, sizeof(NewFork));
 
-                cur += BootDev::kSectorSize;
-            } while (cur < forkKind->DataSize);
+        do {
+            this->fDiskDev.Leak().mSize = BootDev::kSectorSize;
+            this->fDiskDev.Leak().mBase = (forkKind->DataOffset + cur);
 
-            /// Fork is done.
+            this->fDiskDev.Write((Char*)(blob->fBlob) + cur, BootDev::kSectorSize);
 
-            catalogKind->Kind = blob->fKind;
-            catalogKind->Flags |= kNewFSFlagCreated;
+            cur += BootDev::kSectorSize;
+        } while (cur < forkKind->DataSize);
 
-            //// Now write catalog as well..
+        /// Fork is done.
 
-            /// this mime only applies to file.
-            if (catalogKind->Kind == kNewFSCatalogKindFile) {
-                memcpy(catalogKind->Mime, kBKBootFileMime, strlen(kBKBootFileMime));
-            } else  {
-                memcpy(catalogKind->Mime, kBKBootDirMime, strlen(kBKBootDirMime));
-            }
+        catalogKind->Kind = blob->fKind;
+        catalogKind->Flags = kNewFSFlagCreated;
 
-            memcpy(catalogKind->Name, blob->fFileName, strlen(blob->fFileName));
+        //// Now write catalog as well..
 
-            catalogKind->NextSibling = startLba + (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
+        /// this mime only applies to file.
+        if (catalogKind->Kind == kNewFSCatalogKindFile) {
+            memcpy(catalogKind->Mime, kBKBootFileMime, strlen(kBKBootFileMime));
+        } else  {
+            memcpy(catalogKind->Mime, kBKBootDirMime, strlen(kBKBootDirMime));
+        }
 
-            fDiskDev.Leak().mBase = startLba;
-            fDiskDev.Leak().mSize = sizeof(NewCatalog);
+        memcpy(catalogKind->Name, blob->fFileName, strlen(blob->fFileName));
 
-            fDiskDev.Write((Char*)bufCatalog, sizeof(NewCatalog));
+        fDiskDev.Leak().mBase = startLba;
+        fDiskDev.Leak().mSize = sizeof(NewCatalog);
 
-            startLba += (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
+        fDiskDev.Write((Char*)bufCatalog, sizeof(NewCatalog));
 
-            --partBlock.FreeCatalog;
-            --partBlock.FreeSectors;
+        startLba += (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
 
-            memset(bufFork, 0, sizeof(NewFork));
-            memset(bufCatalog, 0, sizeof(NewCatalog));
+        --partBlock.FreeCatalog;
+        --partBlock.FreeSectors;
 
-            blob = blob->fNext;
-        }
+        memset(bufFork, 0, sizeof(NewFork));
+        memset(bufCatalog, 0, sizeof(NewCatalog));
 
         return true;
     }
@@ -391,16 +377,19 @@ inline Boolean BDiskFormatFactory<BootDev>::Format(const char* partName,
 
     /// @note A catalog roughly equal to a sector.
 
+    partBlock->Version = kNewFSVersionInteger;
     partBlock->CatalogCount = blobCount;
     partBlock->Kind = kNewFSHardDrive;
     partBlock->SectorSize = sectorSz;
-    partBlock->FreeCatalog = fDiskDev.GetSectorsCount();
+    partBlock->FreeCatalog = fDiskDev.GetSectorsCount() / sizeof(NewCatalog);
     partBlock->SectorCount = fDiskDev.GetSectorsCount();
     partBlock->FreeSectors = fDiskDev.GetSectorsCount();
     partBlock->StartCatalog = kNewFSCatalogStartAddress;
     partBlock->DiskSize = fDiskDev.GetDiskSize();
+    partBlock->Flags |= kNewFSPartitionTypeBoot;
 
-    if (this->FormatCatalog(fileBlobs, blobCount, *partBlock)) {
+    /// if we can write a root catalog, then write the partition block.
+    if (this->WriteRootCatalog(fileBlobs, blobCount, *partBlock)) {
         fDiskDev.Leak().mBase = kNewFSAddressAsLba;
         fDiskDev.Leak().mSize = sectorSz;
 
diff --git a/Private/NewBoot/BootKit/Vendor/Support.hxx b/Private/NewBoot/BootKit/Vendor/Support.hxx
index b4ba4f68..fe3d35c3 100644
--- a/Private/NewBoot/BootKit/Vendor/Support.hxx
+++ b/Private/NewBoot/BootKit/Vendor/Support.hxx
@@ -15,7 +15,8 @@
 
 #define SetMem(dst, c, sz) memset(dst, c, sz)
 #define MoveMem(dst, src, sz) memcpy(dst, src, sz)
-#define CopyMem(dst, src, sz) memcpy(dst,src, sz)
+#define CopyMem(dst, src, sz) memcpy(dst, src, sz)
+#define StrLen(src) strlen(src)
 
 inline int isspace(int c) { return c == ' '; }
 
diff --git a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
index 2939c182..96999df8 100644
--- a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
+++ b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
@@ -168,61 +168,19 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle,
   if (!diskFormatter.IsPartitionValid()) {
     BDiskFormatFactory<BootDeviceATA>::BFileDescriptor rootDesc{0};
 
-    memcpy(rootDesc.fFileName, "/", strlen("/"));
-    memcpy(rootDesc.fForkName, kNewFSResourceFork, strlen(kNewFSResourceFork));
+    CopyMem(rootDesc.fFileName, "/", StrLen("/"));
+    CopyMem(rootDesc.fForkName, kNewFSResourceFork, StrLen(kNewFSResourceFork));
 
     rootDesc.fBlobSz = BootDeviceATA::kSectorSize;
     rootDesc.fBlob = new Char[rootDesc.fBlobSz];
-    rootDesc.fParent = &rootDesc;
 
-    memset(rootDesc.fBlob, 0, rootDesc.fBlobSz);
-
-    memcpy(rootDesc.fBlob, kMachineModel " startup disk.",
+    SetMem(rootDesc.fBlob, 0, rootDesc.fBlobSz);
+    CopyMem(rootDesc.fBlob, kMachineModel " startup disk.",
             strlen(kMachineModel " startup disk."));
 
     rootDesc.fKind = kNewFSCatalogKindDir;
 
-    BDiskFormatFactory<BootDeviceATA>::BFileDescriptor bootDesc{0};
-
-    bootDesc.fKind = kNewFSCatalogKindDir;
-
-    memcpy(bootDesc.fFileName, "/Boot", strlen("/Boot"));
-    memcpy(bootDesc.fForkName, kNewFSResourceFork, strlen(kNewFSResourceFork));
-
-    bootDesc.fBlobSz = BootDeviceATA::kSectorSize;
-    bootDesc.fBlob = new Char[bootDesc.fBlobSz];
-    bootDesc.fParent = &rootDesc;
-
-    memset(bootDesc.fBlob, 0, bootDesc.fBlobSz);
-
-    memcpy(bootDesc.fBlob, kMachineModel " startup folder.",
-            strlen(kMachineModel " startup folder."));
-
-    rootDesc.fNext = &bootDesc;
-    rootDesc.fNext->fPrev = nullptr;
-
-    BDiskFormatFactory<BootDeviceATA>::BFileDescriptor appDesc{0};
-
-    appDesc.fKind = kNewFSCatalogKindDir;
-
-    memcpy(appDesc.fFileName, "/Applications", strlen("/Applications"));
-    memcpy(appDesc.fForkName, kNewFSResourceFork, strlen(kNewFSResourceFork));
-
-    appDesc.fBlobSz = BootDeviceATA::kSectorSize;
-    appDesc.fBlob = new Char[appDesc.fBlobSz];
-    appDesc.fParent = &rootDesc;
-
-    memset(appDesc.fBlob, 0, appDesc.fBlobSz);
-
-    memcpy(appDesc.fBlob, kMachineModel " applications folder.",
-            strlen(kMachineModel " applications folder."));
-
-    appDesc.fNext = nullptr;
-    appDesc.fNext->fPrev = &bootDesc;
-
-    bootDesc.fNext = &appDesc;
-
-    diskFormatter.Format(kMachineModel, &rootDesc, 3);
+    diskFormatter.Format(kMachineModel, &rootDesc, 1);
   }
 
   EFI::ExitBootServices(*MapKey, ImageHandle);
diff --git a/Private/NewBoot/Source/makefile b/Private/NewBoot/Source/makefile
index 9f70d903..9018623f 100644
--- a/Private/NewBoot/Source/makefile
+++ b/Private/NewBoot/Source/makefile
@@ -75,7 +75,7 @@ run-efi-amd64:
 
 .PHONY: epm-img
 epm-img:
-	qemu-img create -f raw $(IMG) 512M
+	qemu-img create -f raw $(IMG) 1G
 	qemu-img create -f raw $(IMG_2) 512M
 
 .PHONY: download-edk
diff --git a/Private/NewKit/Defines.hpp b/Private/NewKit/Defines.hpp
index a3b86234..bed02081 100644
--- a/Private/NewKit/Defines.hpp
+++ b/Private/NewKit/Defines.hpp
@@ -66,7 +66,7 @@ using Utf32Char = char32_t;
 
 using Void = void;
 
-using Lba = SSizeT;
+using Lba = UInt64;
 
 enum class Endian : UChar { kEndianLittle, kEndianBig, kEndianMixed, kCount };
 
@@ -135,4 +135,4 @@ public:
 #undef INIT
 #endif  // ifdef INIT
 
-#define INIT(OBJ, TYPE, ...) TYPE OBJ = TYPE(__VA_ARGS__)
\ No newline at end of file
+#define INIT(OBJ, TYPE, ...) TYPE OBJ = TYPE(__VA_ARGS__)
diff --git a/Private/Source/AppMain.cxx b/Private/Source/AppMain.cxx
index 8fa74459..6a23e20d 100644
--- a/Private/Source/AppMain.cxx
+++ b/Private/Source/AppMain.cxx
@@ -10,10 +10,12 @@
 #include <KernelKit/FileManager.hpp>
 #include <KernelKit/Framebuffer.hpp>
 #include <KernelKit/KernelHeap.hpp>
+#include <KernelKit/PEF.hpp>
 #include <KernelKit/PEFCodeManager.hxx>
 #include <KernelKit/ProcessScheduler.hpp>
 #include <KernelKit/UserHeap.hpp>
 #include <NewKit/Json.hpp>
+#include <NewKit/Utils.hpp>
 
 /// @file Main microkernel entrypoint.
 
@@ -24,14 +26,52 @@ EXTERN_C NewOS::Void AppMain(NewOS::Void) {
   NewOS::FilesystemManagerInterface::Mount(newFS);
 
   if (newFS->GetImpl()) {
-      auto catalog = newFS->GetImpl()->GetCatalog("/Boot");
-      if (catalog) {
-          NewOS::kcout << "Catalog-Path-Name: " << catalog->Name << NewOS::endl;
-          delete catalog;
-      }
+    NewCatalog* mountCatalog = newFS->GetImpl()->GetCatalog("/Boot/");
+
+    if (mountCatalog) {
+      delete newFS->GetImpl()->CreateCatalog("/Boot/System/", 0,
+                                             kNewFSCatalogKindDir);
+      NewCatalog* newKernelCatalog =
+          newFS->GetImpl()->CreateCatalog("/Boot/System/ExampleTextFile");
+
+      if (newKernelCatalog)
+        NewOS::kcout << "Catalog-Path-Name: " << newKernelCatalog->Name
+                     << NewOS::endl;
+
+      NewOS::kcout << "Catalog-Path-Name: " << mountCatalog->Name
+                   << NewOS::endl;
+
+      constexpr auto cDataSz = 512;
+      NewOS::Char theData[cDataSz] = {
+          "THIS FORK\rCONTAINS DATA\rAS\rYOU\rCAN\rSEE...THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE..THIS FORK\rCONTAINS "
+          "DATA\rAS\rYOU\rCAN\rSEE.."};
+
+      NewFork theFork{0};
+      NewOS::rt_copy_memory((NewOS::VoidPtr) "EditableText",
+                            (NewOS::VoidPtr)theFork.Name,
+                            NewOS::rt_string_len("EditableText"));
+
+      theFork.Kind = NewOS::kNewFSDataForkKind;
+      theFork.DataSize = cDataSz;
+
+      newFS->GetImpl()->CreateFork(newKernelCatalog, theFork);
+      newFS->GetImpl()->WriteCatalog(newKernelCatalog, theData, cDataSz);
+
+      delete newKernelCatalog;
+      delete mountCatalog;
+    } else {
+      delete newFS->GetImpl()->CreateCatalog("/Boot/", 0, kNewFSCatalogKindDir);
+    }
   }
 
-  while (NewOS::ProcessScheduler::Shared().Leak().Run() > 0);
+  while (NewOS::ProcessScheduler::Shared().Leak().Run() > 0)
+    ;
 
   delete newFS;
 }
diff --git a/Private/Source/FS/NewFS.cxx b/Private/Source/FS/NewFS.cxx
index a5dfe45b..57f61cd2 100644
--- a/Private/Source/FS/NewFS.cxx
+++ b/Private/Source/FS/NewFS.cxx
@@ -6,21 +6,16 @@
 
 #ifdef __FSKIT_NEWFS__
 
+#include <Builtins/AHCI/AHCI.hxx>
+#include <Builtins/ATA/ATA.hxx>
 #include <FSKit/NewFS.hxx>
 #include <KernelKit/HError.hpp>
 #include <NewKit/Crc32.hpp>
-#include <NewKit/Utils.hpp>
 #include <NewKit/String.hpp>
-#include <Builtins/ATA/ATA.hxx>
-#include <Builtins/AHCI/AHCI.hxx>
+#include <NewKit/Utils.hpp>
 
 using namespace NewOS;
 
-/// forward decl.
-
-STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean isDataFork);
-STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv);
-
 STATIC MountpointInterface sMountpointInterface;
 
 /// @brief Creates a new fork inside the New filesystem partition.
@@ -30,67 +25,39 @@ STATIC MountpointInterface sMountpointInterface;
 _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
                                          _Input NewFork& theFork) {
   if (catalog && theFork.Name[0] != 0 && theFork.DataSize > 0) {
-    Lba whereFork = 0;
-
-    theFork.DataOffset =
-        ke_find_free_fork(theFork.DataSize, this->fDriveIndex, catalog, theFork.Kind == kNewFSDataForkKind);
-    theFork.Flags |= kNewFSFlagCreated;
-    Lba lba = theFork.Kind == kNewFSDataForkKind ? catalog->DataFork : catalog->ResourceFork;
-
-    if (lba == 0) {
-      lba = whereFork;
-    } else {
-      if (lba == 0) {
-        theFork.PreviousSibling = lba;
-      }
-    }
+    theFork.Flags = kNewFSFlagCreated;
+    Lba lba = (theFork.Kind == kNewFSDataForkKind) ? catalog->DataFork
+                                                   : catalog->ResourceFork;
 
-    if (theFork.Kind == kNewFSDataForkKind) {
-        if (catalog->DataFork == 0) {
-          catalog->DataFork = whereFork;
-        } else {
-          theFork.PreviousSibling = catalog->DataFork;
-        }
-    } else {
-        if (catalog->ResourceFork == 0) {
-          catalog->ResourceFork = whereFork;
-        } else {
-          theFork.PreviousSibling = catalog->ResourceFork;
-        }
-    }
+    if (lba <= kNewFSCatalogStartAddress) return nullptr;
 
-    if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
-      return nullptr;
+    theFork.DataOffset = lba + sizeof(NewFork);
+
+    if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr;
 
     auto drv = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
-    drv->fPacket.fLba = whereFork;
-    drv->fPacket.fPacketSize = theFork.DataSize;
-    drv->fPacket.fPacketContent = (VoidPtr)&theFork;
+    Char cpyFork[sizeof(NewFork)] = {0};
 
-    rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime, 16);
+    drv->fPacket.fLba = lba + sizeof(NewCatalog);
+    drv->fPacket.fPacketSize = sizeof(NewFork);
+    drv->fPacket.fPacketContent = (VoidPtr)cpyFork;
 
-    if (auto res =
-            fs_newfs_write(&sMountpointInterface, *drv, this->fDriveIndex);
-        res) {
-      switch (res) {
-        case 1:
-          DbgLastError() = kErrorDiskReadOnly;
-          break;
-        case 2:
-          DbgLastError() = kErrorDiskIsFull;
-          break;
-          DbgLastError() = kErrorNoSuchDisk;
-          break;
+    drv->fInput(&drv->fPacket);
 
-        default:
-          break;
-      }
-      return nullptr;
-    }
+    NewFork* cpyForkStruct = (NewFork*)cpyFork;
+
+    if (cpyForkStruct->Flags == kNewFSFlagCreated) return nullptr;
+
+    /// special treatment.
+    rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime,
+                   rt_string_len("fs/newfs-packet"));
+
+    drv->fPacket.fLba = lba;
+    drv->fPacket.fPacketSize = sizeof(NewFork);
+    drv->fPacket.fPacketContent = (VoidPtr)&theFork;
 
-    /// Also update catalog.
-    this->WriteCatalog(catalog, nullptr);
+    drv->fOutput(&drv->fPacket);
 
     return &theFork;
   }
@@ -103,7 +70,8 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 /// @param name the fork name.
 /// @return the fork.
 _Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog,
-                                       _Input const Char* name, Boolean isDataFork) {
+                                       _Input const Char* name,
+                                       Boolean isDataFork) {
   auto drv = sMountpointInterface.GetAddressOf(this->fDriveIndex);
   NewFork* theFork = nullptr;
   Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork;
@@ -160,6 +128,186 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name) {
 _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
                                                _Input const Int32& flags,
                                                _Input const Int32& kind) {
+  if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr;
+
+  Lba outLba = 0UL;
+
+  if (kind == kNewFSCatalogKindDir &&
+      name[rt_string_len(name) - 1] != NewFilesystemHelper::Separator())
+    return nullptr;
+
+  /// as well as this, we don't want that.
+  if (kind != kNewFSCatalogKindDir &&
+      name[rt_string_len(name) - 1] == NewFilesystemHelper::Separator())
+    return nullptr;
+
+  NewCatalog* checkForCpy = this->FindCatalog(name, outLba);
+
+  if (checkForCpy) {
+    return checkForCpy;
+  }
+
+  char copyName[kNewFSNodeNameLen] = {0};
+
+  for (SizeT indexName = 0UL; indexName < rt_string_len(name); ++indexName) {
+    copyName[indexName] = name[indexName];
+  }
+
+  if (*copyName == 0) {
+    DbgLastError() = kErrorFileNotFound;
+    return nullptr;
+  }
+
+  for (SizeT indexFill = 0; indexFill < rt_string_len(name); ++indexFill) {
+    copyName[indexFill] = name[indexFill];
+  }
+
+  SizeT indexReverseCopy = rt_string_len(copyName);
+
+  // zero character.
+  copyName[--indexReverseCopy] = 0;
+
+  // mandatory / character.
+  copyName[--indexReverseCopy] = 0;
+
+  while (copyName[indexReverseCopy] != '/') {
+    copyName[indexReverseCopy] = 0;
+    --indexReverseCopy;
+  }
+
+  NewCatalog* catalog = this->FindCatalog(copyName, outLba);
+
+  if (!catalog) {
+    return nullptr;
+  }
+
+  if (catalog->Kind == kNewFSCatalogKindFile) {
+    delete catalog;
+    return nullptr;
+  }
+
+  constexpr SizeT cDefaultForkSize = 8192;
+
+  NewCatalog* catalogChild = new NewCatalog();
+
+  catalogChild->ResourceForkOverallSize = cDefaultForkSize;
+  catalogChild->DataForkSize = cDefaultForkSize;
+
+  catalogChild->NextSibling = 0UL;
+  catalogChild->PrevSibling = outLba;
+  catalogChild->Flags = flags;
+  catalogChild->Kind = kind;
+  catalogChild->Flags |= kNewFSFlagCreated;
+
+  rt_copy_memory((VoidPtr)name, (VoidPtr)catalogChild->Name,
+                 rt_string_len(name));
+
+  UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0};
+
+  auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
+
+  Lba startFree = catalogChild->PrevSibling + catalog->NextSibling;
+
+  kcout << "Next-Catalog: " << hex_number(startFree) << endl;
+
+  drive->fPacket.fPacketContent = sectorBuf;
+  drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+  drive->fPacket.fLba = startFree;
+
+  drive->fInput(&drive->fPacket);
+
+  while (drive->fPacket.fPacketGood) {
+    NewCatalog* nextSibling = (NewCatalog*)sectorBuf;
+
+    if (startFree <= kNewFSAddressAsLba) {
+      delete catalogChild;
+      delete catalog;
+
+      return nullptr;
+    }
+
+    /// allocation or reallocation or catalog...
+    if ((nextSibling->Name[0] == 0 &&
+         nextSibling->Flags != kNewFSFlagCreated)) {
+      catalogChild->DataFork = startFree + sizeof(NewCatalog);
+      catalogChild->ResourceFork =
+          startFree + sizeof(NewCatalog) + catalogChild->DataForkSize;
+
+      if ((nextSibling->Flags != kNewFSFlagCreated)) {
+        nextSibling->Flags = kNewFSFlagCreated;
+
+        drive->fPacket.fPacketContent = catalogChild;
+        drive->fPacket.fPacketSize = sizeof(NewCatalog);
+        drive->fPacket.fLba = startFree;
+
+        if (catalogChild->Kind == kNewFSCatalogKindFile) {
+          rt_copy_memory((VoidPtr) "x-kind/file", (VoidPtr)catalogChild->Mime,
+                         rt_string_len("x-kind/file"));
+        } else {
+          rt_copy_memory((VoidPtr) "x-kind/dir", (VoidPtr)catalogChild->Mime,
+                         rt_string_len("x-kind/dir"));
+        }
+
+        catalogChild->NextSibling = sizeof(NewCatalog) +
+                                    catalogChild->DataForkSize +
+                                    catalogChild->ResourceForkOverallSize;
+
+        drive->fOutput(&drive->fPacket);
+
+        kcout << "New OS: Create new catalog successfully!\r\n";
+
+        Char sectBuf[sizeof(NewCatalog)] = {0};
+
+        drive->fPacket.fPacketContent = sectBuf;
+        drive->fPacket.fPacketSize = sizeof(NewCatalog);
+        drive->fPacket.fLba = catalogChild->PrevSibling;
+
+        drive->fInput(&drive->fPacket);
+
+        NewCatalog* prevCatalog = (NewCatalog*)sectBuf;
+        prevCatalog->NextSibling = startFree;
+
+        drive->fOutput(&drive->fPacket);
+
+        kcout << "Edit-Catalog: " << prevCatalog->Name << endl;
+
+        Char sectorBufPartBlock[kNewFSMinimumSectorSz] = {0};
+
+        drive->fPacket.fPacketContent = sectorBufPartBlock;
+        drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+        drive->fPacket.fLba = kNewFSAddressAsLba;
+
+        drive->fInput(&drive->fPacket);
+
+        NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBufPartBlock;
+
+        partBlock->SectorCount -= 1;
+        partBlock->CatalogCount += 1;
+        partBlock->FreeCatalog -= 1;
+
+        drive->fOutput(&drive->fPacket);
+
+        delete catalog;
+        return catalogChild;
+      } else {
+        delete catalog;
+        return nullptr;
+      }
+    }
+
+    //// @note that's how we find the next catalog in the partition block.
+    startFree += sizeof(NewFork) + sizeof(NewCatalog) +
+                 nextSibling->DataForkSize +
+                 nextSibling->ResourceForkOverallSize;
+
+    drive->fPacket.fPacketContent = sectorBuf;
+    drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+    drive->fPacket.fLba = startFree;
+
+    drive->fInput(&drive->fPacket);
+  }
+
+  delete catalog;
   return nullptr;
 }
 
@@ -176,7 +324,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
     return false;
   }
 
-  UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0};
+  Char sectorBuf[kNewFSMinimumSectorSz] = {0};
 
   drive->fPacket.fPacketContent = sectorBuf;
   drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
@@ -193,18 +341,24 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
         rt_string_cmp(partBlock->Ident, kNewFSIdent, kNewFSIdentLen)) {
       /// partition is free and valid.
 
+      partBlock->Version = kNewFSVersionInteger;
+
+      const auto cUntitledHD = "New OS HD\0";
+
       rt_copy_memory((VoidPtr)kNewFSIdent, (VoidPtr)partBlock->Ident,
                      kNewFSIdentLen);
-      rt_copy_memory((VoidPtr) "Untitled HD\0", (VoidPtr)partBlock->PartitionName,
-                     rt_string_len("Untitled HD\0"));
+
+      rt_copy_memory((VoidPtr)cUntitledHD, (VoidPtr)partBlock->PartitionName,
+                     rt_string_len(cUntitledHD));
 
       SizeT catalogCount = 0;
       SizeT sectorCount = drv_std_get_sector_count();
       SizeT diskSize = drv_std_get_drv_size();
 
       partBlock->Kind = kNewFSPartitionTypeStandard;
-      partBlock->StartCatalog = kNewFSCatalogStartAddress;;
-      partBlock->CatalogCount = catalogCount;
+      partBlock->StartCatalog = kNewFSCatalogStartAddress;
+      partBlock->Flags |= kNewFSPartitionTypeStandard;
+      partBlock->CatalogCount = sectorCount / sizeof(NewCatalog);
       partBlock->SectorCount = sectorCount;
       partBlock->DiskSize = diskSize;
       partBlock->FreeCatalog = partBlock->StartCatalog;
@@ -218,7 +372,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
       return true;
     }
 
-    kcout << "New OS: Partition already exists.\r\n";
+    kcout << "New OS: PartitionBlock already exists.\r\n";
 
     /// return success as well, do not ignore that partition.
     return true;
@@ -227,92 +381,141 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
   return false;
 }
 
-/// @brief
-/// @param catalog
-/// @param data
-/// @return
-bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog,
-                               voidPtr data) {
+/// @brief Writes the data fork into a specific catalog.
+/// @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) {
+  if (sizeOfData > catalog->DataForkSize) return false;
+  if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return false;
+
+  NewFork* forkData = new NewFork();
+
+  auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
+
+  auto startFork = catalog->DataFork;
+
+  /// sanity check of the fork position as the condition to run the loop.
+  if (startFork >= kNewFSCatalogStartAddress) {
+    drive->fPacket.fPacketContent = forkData;
+    drive->fPacket.fPacketSize = sizeof(NewFork);
+    drive->fPacket.fLba = startFork;
+
+    drive->fInput(&drive->fPacket);
+
+    /// check if fork even exists.
+    if (forkData->Flags != kNewFSFlagCreated) {
+      DbgLastError() = kErrorDiskIsCorrupted;
+
+      delete forkData;
+      return false;
+    }
+
+    /// sanity check the fork.
+    if (forkData->DataOffset <= kNewFSCatalogStartAddress) {
+      DbgLastError() = kErrorDiskIsCorrupted;
+
+      delete forkData;
+      return false;
+    }
+
+    drive->fPacket.fPacketContent = data;
+    drive->fPacket.fPacketSize = sizeOfData;
+    drive->fPacket.fLba = forkData->DataOffset;
+
+    drive->fOutput(&drive->fPacket);
+
+    return true;
+  }
+
   return false;
 }
 
 /// @brief
 /// @param catalogName
 /// @return
-_Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName) {
-    if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr;
+_Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
+                                             Lba& outLba) {
+  if (!sMountpointInterface.GetAddressOf(this->fDriveIndex)) return nullptr;
 
-    Char* sectorBuf = new Char[sizeof(NewPartitionBlock)];
-    auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
+  Char* sectorBuf = new Char[sizeof(NewPartitionBlock)];
+  auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
-    drive->fPacket.fPacketContent = sectorBuf;
-    drive->fPacket.fPacketSize = sizeof(NewPartitionBlock);
-    drive->fPacket.fLba = kNewFSAddressAsLba;
+  drive->fPacket.fPacketContent = sectorBuf;
+  drive->fPacket.fPacketSize = sizeof(NewPartitionBlock);
+  drive->fPacket.fLba = kNewFSAddressAsLba;
 
-    drive->fInput(&drive->fPacket);
+  drive->fInput(&drive->fPacket);
 
-    NewPartitionBlock* part = (NewPartitionBlock*)sectorBuf;
+  NewPartitionBlock* part = (NewPartitionBlock*)sectorBuf;
 
-    kcout << "Drive-Kind: " << drive->fDriveKind() << endl;
+  kcout << "Drive-Kind: " << drive->fDriveKind() << endl;
 
-    kcout << "Partition-Name: " << part->PartitionName << endl;
-    kcout << "Start-Catalog: " << number(part->StartCatalog) << endl;
-    kcout << "Catalog-Count: " << number(part->CatalogCount) << endl;
-    kcout << "Free-Catalog: " << number(part->FreeCatalog) << endl;
-    kcout << "Free-Sectors: " << number(part->FreeSectors) << endl;
-    kcout << "Sector-Size: " << number(part->SectorSize) << endl;
+  kcout << "Partition-Name: " << part->PartitionName << endl;
+  kcout << "Start-Catalog: " << number(part->StartCatalog) << endl;
+  kcout << "Catalog-Count: " << number(part->CatalogCount) << endl;
+  kcout << "Free-Catalog: " << number(part->FreeCatalog) << endl;
+  kcout << "Free-Sectors: " << number(part->FreeSectors) << endl;
+  kcout << "Sector-Size: " << number(part->SectorSize) << endl;
 
-    auto start = part->StartCatalog;
+  auto start = part->StartCatalog;
 
-    drive->fPacket.fLba = start;
-    drive->fPacket.fPacketContent = sectorBuf;
-    drive->fPacket.fPacketSize = sizeof(NewCatalog);
+  drive->fPacket.fLba = start;
+  drive->fPacket.fPacketContent = sectorBuf;
+  drive->fPacket.fPacketSize = sizeof(NewCatalog);
 
-    drive->fInput(&drive->fPacket);
+  drive->fInput(&drive->fPacket);
 
-    while (drive->fPacket.fPacketGood) {
-        NewCatalog* catalog = (NewCatalog*)sectorBuf;
+  while (drive->fPacket.fPacketGood) {
+    NewCatalog* catalog = (NewCatalog*)sectorBuf;
 
-        if (StringBuilder::Equals(catalogName, catalog->Name)) {
-            NewCatalog* catalogPtr = new NewCatalog();
-            rt_copy_memory(catalog, catalogPtr, sizeof(NewCatalog));
+    if (StringBuilder::Equals(catalogName, catalog->Name)) {
+      NewCatalog* catalogPtr = new NewCatalog();
+      rt_copy_memory(catalog, catalogPtr, sizeof(NewCatalog));
 
-            delete[] sectorBuf;
-            return catalogPtr;
-        }
+      outLba = start;
+      delete[] sectorBuf;
+      return catalogPtr;
+    }
 
-        if (catalog->NextSibling == 0)
-            break;
+    start = catalog->NextSibling;
 
-        drive->fPacket.fLba = catalog->NextSibling;
-        drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
-        drive->fInput(&drive->fPacket);
-    }
+    if (start <= kNewFSAddressAsLba) break;
+
+    drive->fPacket.fLba = start;
+    drive->fPacket.fPacketContent = sectorBuf;
+    drive->fPacket.fPacketSize = sizeof(NewCatalog);
 
-    delete[] sectorBuf;
+    drive->fInput(&drive->fPacket);
+  }
 
-    return nullptr;
+  outLba = 0UL;
+  delete[] sectorBuf;
+
+  return nullptr;
 }
 
 /// @brief
 /// @param name
 /// @return
 _Output NewCatalog* NewFSParser::GetCatalog(_Input const char* name) {
-  return this->FindCatalog(name);
+  Lba unused = 0;
+  return this->FindCatalog(name, unused);
 }
 
 /// @brief
 /// @param catalog
 /// @return
 Boolean NewFSParser::CloseCatalog(_Input _Output NewCatalog* catalog) {
-    if (this->WriteCatalog(catalog, nullptr)) {
-        delete catalog;
-        catalog = nullptr;
+  if (this->WriteCatalog(catalog, nullptr, 0)) {
+    delete catalog;
+    catalog = nullptr;
 
-        return true;
-    }
+    return true;
+  }
 
-    return false;
+  return false;
 }
 
 /// @brief Mark catalog as removed.
@@ -320,12 +523,12 @@ Boolean NewFSParser::CloseCatalog(_Input _Output NewCatalog* catalog) {
 /// @return
 Boolean NewFSParser::RemoveCatalog(_Input _Output NewCatalog* catalog) {
   if (!catalog) {
-      DbgLastError() = kErrorFileNotFound;
-      return false;
+    DbgLastError() = kErrorFileNotFound;
+    return false;
   }
 
   catalog->Flags |= kNewFSFlagDeleted;
-  this->WriteCatalog(catalog, nullptr);
+  this->WriteCatalog(catalog, nullptr, 0);
 
   return false;
 }
@@ -340,12 +543,12 @@ Boolean NewFSParser::RemoveCatalog(_Input _Output NewCatalog* catalog) {
 /// @return
 VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
                                  SizeT dataSz) {
-    if (!catalog) {
-        DbgLastError() = kErrorFileNotFound;
-        return nullptr;
-    }
-
+  if (!catalog) {
+    DbgLastError() = kErrorFileNotFound;
     return nullptr;
+  }
+
+  return nullptr;
 }
 
 /// @brief Seek in the data fork.
@@ -353,143 +556,21 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
 /// @param off
 /// @return
 bool NewFSParser::Seek(_Input _Output NewCatalog* catalog, SizeT off) {
-    if (!catalog) {
-        DbgLastError() = kErrorFileNotFound;
-        return false;
-    }
-
+  if (!catalog) {
+    DbgLastError() = kErrorFileNotFound;
     return false;
+  }
+
+  return false;
 }
 
 /// @brief Tell where we are inside the data fork.
 /// @param catalog
 /// @return
 SizeT NewFSParser::Tell(_Input _Output NewCatalog* catalog) {
-    if (!catalog) {
-        DbgLastError() = kErrorFileNotFound;
-        return false;
-    }
-
-    return 0;
-}
-
-/// @brief Find a free fork inside the filesystem.
-/// @param sz the size of the fork to set.
-/// @return the valid lba.
-STATIC Lba ke_find_free_fork(SizeT sz, Int32 drv, NewCatalog* catalog, Boolean isDataFork) {
-
-  if (sMountpointInterface.GetAddressOf(drv)) {
-    auto drive = *sMountpointInterface.GetAddressOf(drv);
-
-    /// prepare packet.
-    bool done = false;
-    bool error = false;
-
-    Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork;
-
-    while (!done) {
-      UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0};
-
-      drive.fPacket.fPacketContent = sectorBuf;
-      drive.fPacket.fPacketSize = kNewFSMinimumSectorSz;
-      drive.fPacket.fLba = lba;
-
-      drive.fInput(&drive.fPacket);
-
-      if (!drive.fPacket.fPacketGood) {
-        ///! not a lot of choices, disk has become unreliable.
-        if (ke_calculate_crc32((Char*)sectorBuf, kNewFSMinimumSectorSz) !=
-            drive.fPacket.fPacketCRC32) {
-          DbgLastError() = kErrorDiskIsCorrupted;
-        }
-
-        error = true;
-        break;
-      }
-
-      NewFork* fork = (NewFork*)sectorBuf;
-
-      if (fork->DataSize == 0 && fork->Name[0] == 0 &&
-          (fork->Flags == kNewFSFlagDeleted ||
-           fork->Flags == kNewFSFlagUnallocated)) {
-        fork->DataSize = sz;
-        fork->Flags |= kNewFSFlagCreated;
-
-        drive.fOutput(&drive.fPacket);
-
-        /// here it's either a read-only filesystem or something bad happened.'
-        if (!drive.fPacket.fPacketGood) {
-          DbgLastError() = kErrorDiskReadOnly;
-
-          return 0;
-        }
-
-        return lba;
-      }
-
-      lba += sizeof(NewFork);
-    }
-
-    if (error) {
-      DbgLastError() = kErrorDisk;
-      return 0;
-    }
-  }
-
-  return 0;
-}
-
-/// @brief find a free catalog.
-/// @param kind the catalog kind.
-/// @return the valid lba.
-STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv) {
-
-  if (sMountpointInterface.GetAddressOf(drv)) {
-    auto drive = *sMountpointInterface.GetAddressOf(drv);
-    UInt16 sectorBuf[kNewFSMinimumSectorSz] = {0};
-
-    /// prepare packet.
-
-    drive.fPacket.fPacketContent = sectorBuf;
-    drive.fPacket.fPacketSize = kNewFSMinimumSectorSz;
-    drive.fPacket.fLba = kNewFSAddressAsLba;
-
-    drive.fInput(&drive.fPacket);
-
-    NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBuf;
-
-    /// check for a valid partition.
-    if (partBlock->PartitionName[0] != 0 &&
-        rt_string_cmp(partBlock->Ident, kNewFSIdent, kNewFSIdentLen) == 0) {
-      auto startLba = partBlock->FreeCatalog;
-
-      if (startLba == 0) {
-        DbgLastError() = kErrorDiskIsFull;
-        return 1;
-      } else {
-        while (startLba != 0) {
-          drive.fPacket.fPacketContent = sectorBuf;
-          drive.fPacket.fPacketSize = kNewFSMinimumSectorSz;
-          drive.fPacket.fLba = startLba;
-
-          drive.fInput(&drive.fPacket);
-
-          NewCatalog* catalog = (NewCatalog*)sectorBuf;
-
-          if (catalog->Flags == kNewFSFlagUnallocated ||
-              catalog->Flags == kNewFSFlagDeleted) {
-            catalog->Flags |= kNewFSFlagCreated;
-            catalog->Kind |= kind;
-
-            return startLba;
-          }
-
-          startLba = catalog->NextSibling;
-        }
-
-        return 0;
-      }
-    }
+  if (!catalog) {
+    DbgLastError() = kErrorFileNotFound;
+    return false;
   }
 
   return 0;
@@ -497,14 +578,14 @@ STATIC Lba ke_find_free_catalog(SizeT kind, Int32 drv) {
 
 namespace NewOS::Detail {
 Boolean fs_init_newfs(Void) noexcept {
-    sMountpointInterface.A() = construct_main_drive();
-    sMountpointInterface.B() = construct_drive();
-    sMountpointInterface.C() = construct_drive();
-    sMountpointInterface.D() = construct_drive();
+  sMountpointInterface.A() = construct_main_drive();
+  sMountpointInterface.B() = construct_drive();
+  sMountpointInterface.C() = construct_drive();
+  sMountpointInterface.D() = construct_drive();
 
-    sMountpointInterface.A().fVerify(&sMountpointInterface.A().fPacket);
+  sMountpointInterface.A().fVerify(&sMountpointInterface.A().fPacket);
 
-    return true;
+  return true;
 }
 }  // namespace NewOS::Detail
 
diff --git a/Private/Source/FileManager.cxx b/Private/Source/FileManager.cxx
index 4742769c..aab3cff0 100644
--- a/Private/Source/FileManager.cxx
+++ b/Private/Source/FileManager.cxx
@@ -47,9 +47,9 @@ bool FilesystemManagerInterface::Mount(FilesystemManagerInterface* mountPtr) {
 
 #ifdef __FSKIT_NEWFS__
 /// @brief Opens a new file.
-/// @param path 
-/// @param r 
-/// @return 
+/// @param path
+/// @param r
+/// @return
 NodePtr NewFilesystemManager::Open(const char* path, const char* r) {
   if (!path || *path == 0) return nullptr;
 
@@ -66,14 +66,14 @@ NodePtr NewFilesystemManager::Open(const char* path, const char* r) {
 }
 
 /// @brief Writes to a catalog
-/// @param node 
-/// @param data 
-/// @param flags 
-/// @return 
+/// @param node
+/// @param data
+/// @param flags
+/// @return
 Void NewFilesystemManager::Write(NodePtr node, VoidPtr data,
-                                       Int32 flags) {
+                                       Int32 flags, SizeT size) {
   if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
-    fImpl->WriteCatalog(reinterpret_cast<NewCatalog*>(node), data);
+    fImpl->WriteCatalog(reinterpret_cast<NewCatalog*>(node), data, size);
 }
 
 /**
@@ -82,10 +82,10 @@ Void NewFilesystemManager::Write(NodePtr node, VoidPtr data,
  */
 
 /// @brief Reads from filesystem.
-/// @param node 
-/// @param flags 
-/// @param sz 
-/// @return 
+/// @param node
+/// @param flags
+/// @param sz
+/// @return
 VoidPtr NewFilesystemManager::Read(NodePtr node, Int32 flags, SizeT sz) {
   if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
     return fImpl->ReadCatalog(reinterpret_cast<NewCatalog*>(node), sz);
@@ -94,18 +94,18 @@ VoidPtr NewFilesystemManager::Read(NodePtr node, Int32 flags, SizeT sz) {
 }
 
 /// @brief Seek from Catalog.
-/// @param node 
-/// @param off 
-/// @return 
+/// @param node
+/// @param off
+/// @return
 bool NewFilesystemManager::Seek(NodePtr node, SizeT off) {
   if (!node || off == 0) return false;
-  
+
   return fImpl->Seek(reinterpret_cast<NewCatalog*>(node), off);
 }
 
 /// @brief Tell where the catalog is/
-/// @param node 
-/// @return 
+/// @param node
+/// @return
 SizeT NewFilesystemManager::Tell(NodePtr node) {
   if (!node) return kNPos;
 
@@ -113,8 +113,8 @@ SizeT NewFilesystemManager::Tell(NodePtr node) {
 }
 
 /// @brief Rewind the catalog.
-/// @param node 
-/// @return 
+/// @param node
+/// @return
 bool NewFilesystemManager::Rewind(NodePtr node) {
   if (!node) return false;
 
@@ -122,7 +122,7 @@ bool NewFilesystemManager::Rewind(NodePtr node) {
 }
 
 /// @brief The filesystem implementation.
-/// @return 
+/// @return
 NewFSParser* NewFilesystemManager::GetImpl() noexcept { return fImpl; }
 #endif // __FSKIT_NEWFS__
 }  // namespace NewOS