Kernel: Fix NewFS catalog creation.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

5 files changed, 109 insertions, 185 deletions

diff --git a/Private/FSKit/NewFS.hxx b/Private/FSKit/NewFS.hxx
index 4a298c96..2cc08cd6 100644
--- a/Private/FSKit/NewFS.hxx
+++ b/Private/FSKit/NewFS.hxx
@@ -9,7 +9,7 @@
 
     ?/?/?: Added file (amlel)
     12/02/24: Add UUID macro for EPM and GPT partition schemes.
-    3/16/24: Add mandatory sector size, kNewFSMinimumSectorSz is set to 2048 by
+    3/16/24: Add mandatory sector size, kNewFSSectorSz is set to 2048 by
 default.
 
 ------------------------------------------- */
@@ -30,7 +30,7 @@ default.
 #define kNewFSInvalidCatalog -1
 #define kNewFSNodeNameLen 256
 
-#define kNewFSMinimumSectorSz (512)
+#define kNewFSSectorSz (512)
 
 #define kNewFSIdentLen 8
 #define kNewFSIdent " NewFS"
diff --git a/Private/NewBoot/BootKit/BootKit.hxx b/Private/NewBoot/BootKit/BootKit.hxx
index 7b3c1d93..212e8914 100644
--- a/Private/NewBoot/BootKit/BootKit.hxx
+++ b/Private/NewBoot/BootKit/BootKit.hxx
@@ -183,12 +183,7 @@ public:
     /// @brief File entry for **BDiskFormatFactory**.
     struct BFileDescriptor final {
         Char fFileName[kNewFSNodeNameLen];
-        Char fForkName[kNewFSNodeNameLen];
-
         Int32 fKind;
-
-        VoidPtr fBlob;
-        SizeT fBlobSz;
     };
 
 public:
@@ -255,23 +250,14 @@ private:
         BTextWriter writer;
 
         Char bufCatalog[sizeof(NewCatalog)] = { 0 };
-        Char bufFork[sizeof(NewFork)] = { 0 };
 
         NewCatalog* catalogKind = (NewCatalog*)bufCatalog;
         catalogKind->PrevSibling = startLba;
-        catalogKind->NextSibling = (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
+        catalogKind->NextSibling = (startLba + sizeof(NewCatalog));
 
         /// Fill catalog kind.
         catalogKind->Kind = blob->fKind;
-
-        /// Allocate fork for blob.
-        if (catalogKind->Kind == kNewFSDataForkKind) {
-            catalogKind->DataFork = (startLba + sizeof(NewCatalog));
-            catalogKind->DataForkSize += blob->fBlobSz;
-        } else {
-            catalogKind->ResourceFork = (startLba + sizeof(NewCatalog));
-            catalogKind->ResourceForkSize += blob->fBlobSz;
-        }
+        catalogKind->Flags = kNewFSFlagCreated;
 
         /// before going to forks, we must check for the catalog name first.
         if (blob->fKind == kNewFSCatalogKindDir &&
@@ -279,58 +265,9 @@ private:
             EFI::ThrowError(L"Developer-Error", L"This is caused by the developer of the bootloader.");
         }
 
-        NewFork* forkKind = (NewFork*)bufFork;
-
-        memcpy(forkKind->Name, blob->fForkName, strlen(blob->fForkName));
-        forkKind->Kind = (forkKind->Name[0] == kNewFSDataFork[0]) ? kNewFSDataForkKind : kNewFSRsrcForkKind;
-        forkKind->Flags = kNewFSFlagCreated;
-
-        /// We don't know.
-        forkKind->ResourceFlags = 0;
-        forkKind->ResourceId = 0;
-        forkKind->ResourceKind = 0;
-
-        /// We're the only fork here.
-        forkKind->NextSibling = forkKind->Kind == kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
-        forkKind->PreviousSibling = kNewFSDataForkKind ? catalogKind->DataFork : catalogKind->ResourceFork;
-
-        forkKind->DataOffset = (startLba + sizeof(NewCatalog) + sizeof(NewFork));
-        forkKind->DataSize = blob->fBlobSz;
-
-        SizeT cur = 0UL;
-
         writer.Write((catalogKind->Kind == kNewFSCatalogKindFile) ? L"New Boot: Write-File: " :
                         L"New Boot: Write-Directory: " ).Write(blob->fFileName).Write(L"\r");
 
-        /// Set disk cursor here.
-
-        fDiskDev.Leak().mBase = startLba + sizeof(NewCatalog);
-        fDiskDev.Leak().mSize = sizeof(NewFork);
-
-        fDiskDev.Write((Char*)bufFork, sizeof(NewFork));
-
-        do {
-            this->fDiskDev.Leak().mSize = BootDev::kSectorSize;
-            this->fDiskDev.Leak().mBase = (forkKind->DataOffset + cur);
-
-            this->fDiskDev.Write((Char*)(blob->fBlob) + cur, BootDev::kSectorSize);
-
-            cur += BootDev::kSectorSize;
-        } while (cur < forkKind->DataSize);
-
-        /// Fork is done.
-
-        catalogKind->Kind = blob->fKind;
-        catalogKind->Flags = kNewFSFlagCreated;
-
-        //// Now write catalog as well..
-
-        /// this mime only applies to file.
-        if (catalogKind->Kind == kNewFSCatalogKindFile) {
-            memcpy(catalogKind->Mime, kBKBootFileMime, strlen(kBKBootFileMime));
-        } else  {
-            memcpy(catalogKind->Mime, kBKBootDirMime, strlen(kBKBootDirMime));
-        }
 
         memcpy(catalogKind->Name, blob->fFileName, strlen(blob->fFileName));
 
@@ -339,12 +276,9 @@ private:
 
         fDiskDev.Write((Char*)bufCatalog, sizeof(NewCatalog));
 
-        startLba += (sizeof(NewCatalog) + sizeof(NewFork) + blob->fBlobSz);
-
         --partBlock.FreeCatalog;
         --partBlock.FreeSectors;
 
-        memset(bufFork, 0, sizeof(NewFork));
         memset(bufCatalog, 0, sizeof(NewCatalog));
 
         return true;
diff --git a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
index 1462115a..0cbeadfa 100644
--- a/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
+++ b/Private/NewBoot/Source/HEL/AMD64/BootMain.cxx
@@ -168,16 +168,7 @@ EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr ImageHandle,
   if (!diskFormatter.IsPartitionValid()) {
     BDiskFormatFactory<BootDeviceATA>::BFileDescriptor rootDesc{0};
 
-    CopyMem(rootDesc.fFileName, "/", StrLen("/"));
-    CopyMem(rootDesc.fForkName, kNewFSResourceFork, StrLen(kNewFSResourceFork));
-
-    rootDesc.fBlobSz = BootDeviceATA::kSectorSize;
-    rootDesc.fBlob = new Char[rootDesc.fBlobSz];
-
-    SetMem(rootDesc.fBlob, 0, rootDesc.fBlobSz);
-    CopyMem(rootDesc.fBlob, kMachineModel " startup disk.",
-            strlen(kMachineModel " startup disk."));
-
+    CopyMem(rootDesc.fFileName, kNewFSRoot, StrLen(kNewFSRoot));
     rootDesc.fKind = kNewFSCatalogKindDir;
 
     diskFormatter.Format(kMachineModel, &rootDesc, 1);
diff --git a/Private/Source/AppMain.cxx b/Private/Source/AppMain.cxx
index 633178c9..c4ceb55e 100644
--- a/Private/Source/AppMain.cxx
+++ b/Private/Source/AppMain.cxx
@@ -64,7 +64,11 @@ class FilesystemAutomountProvider final {
           sanitizerFork.Kind = NewOS::kNewFSDataForkKind;
           sanitizerFork.DataSize = kNewFSForkSize;
 
-          fNewFS->GetImpl()->CreateCatalog("/System/", 0, kNewFSCatalogKindDir);
+          delete fNewFS->GetImpl()->CreateCatalog("/System/", 0, kNewFSCatalogKindDir);
+          delete fNewFS->GetImpl()->CreateCatalog("/Boot/", 0, kNewFSCatalogKindDir);
+          delete fNewFS->GetImpl()->CreateCatalog("/Support/", 0, kNewFSCatalogKindDir);
+          delete fNewFS->GetImpl()->CreateCatalog("/Applications/", 0, kNewFSCatalogKindDir);
+
           sanitizerCatalog =
               fNewFS->GetImpl()->CreateCatalog("/System/%NKSYSSAN%");
 
@@ -80,6 +84,12 @@ class FilesystemAutomountProvider final {
             fNewFS->GetImpl()->GetCatalog("/System/%NKSYSSAN%"), 512,
             "/System/%NKSYSSAN%$RawExecutable");
 
+        if (!buf) {
+            NewOS::kcout << "Bad-Ptr: " << NewOS::hex_number((NewOS::UIntPtr)buf)
+                           << NewOS::endl;
+              NewOS::ke_stop(RUNTIME_CHECK_BAD_BEHAVIOR);
+        }
+
         for (NewOS::SizeT index = 0UL; index < sanitizerSize; ++index) {
           if (buf[index] != sanitizerBytes[index]) {
             NewOS::kcout << "Diff-Detected: " << NewOS::hex_number(buf[index])
diff --git a/Private/Source/FS/NewFS.cxx b/Private/Source/FS/NewFS.cxx
index 0057af20..e96402e2 100644
--- a/Private/Source/FS/NewFS.cxx
+++ b/Private/Source/FS/NewFS.cxx
@@ -41,41 +41,41 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
     rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime,
                    rt_string_len("fs/newfs-packet"));
 
-    NewFork cpyFork{ 0 };
+    NewFork cpyFork{0};
     NewFork prevFork{0};
     Lba lbaOfPreviousFork = lba;
 
     while (cpyFork.Name[0] == 0) {
-        if (lba <= kNewFSCatalogStartAddress) break;
+      if (lba <= kNewFSCatalogStartAddress) break;
 
-        drv->fPacket.fLba = lba;
-        drv->fPacket.fPacketSize = sizeof(NewFork);
-        drv->fPacket.fPacketContent = &cpyFork;
+      drv->fPacket.fLba = lba;
+      drv->fPacket.fPacketSize = sizeof(NewFork);
+      drv->fPacket.fPacketContent = &cpyFork;
 
-        drv->fInput(&drv->fPacket);
+      drv->fInput(&drv->fPacket);
 
-        kcout << "New OS: Next-Fork: " << hex_number(cpyFork.NextSibling) << endl;
+      kcout << "New OS: Next-Fork: " << hex_number(cpyFork.NextSibling) << endl;
 
-        if (cpyFork.Flags == kNewFSFlagCreated) {
-            kcout << "New OS: Fork already exists.\r";
-            if (StringBuilder::Equals(cpyFork.Name, theFork.Name))
-                return nullptr;
+      if (cpyFork.Flags == kNewFSFlagCreated) {
+        kcout << "New OS: Fork already exists.\r";
+        if (StringBuilder::Equals(cpyFork.Name, theFork.Name)) return nullptr;
 
-            lbaOfPreviousFork = lba;
-            lba = cpyFork.NextSibling;
+        lbaOfPreviousFork = lba;
+        lba = cpyFork.NextSibling;
 
-            prevFork = cpyFork;
-        } else {
-            /// This is a check that we have, in order to link the previous fork entry.
-            if (lba >= kNewFSCatalogStartAddress) {
-                prevFork.NextSibling = lba;
-
-                /// write to disk.
-                drv->fOutput(&drv->fPacket);
-            }
+        prevFork = cpyFork;
+      } else {
+        /// This is a check that we have, in order to link the previous fork
+        /// entry.
+        if (lba >= kNewFSCatalogStartAddress) {
+          prevFork.NextSibling = lba;
 
-            break;
+          /// write to disk.
+          drv->fOutput(&drv->fPacket);
         }
+
+        break;
+      }
     }
 
     constexpr auto cForkPadding = 4;
@@ -92,7 +92,8 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
     drv->fOutput(&drv->fPacket);
 
     /// log what we have now.
-    kcout << "New OS: Wrote fork data at: " << hex_number(theFork.DataOffset) << endl;
+    kcout << "New OS: Wrote fork data at: " << hex_number(theFork.DataOffset)
+          << endl;
     kcout << "New OS: Wrote fork at: " << hex_number(lba) << endl;
 
     return &theFork;
@@ -214,13 +215,11 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
 
   NewCatalog* catalog = this->FindCatalog(parentName, outLba);
 
-  if (!catalog) {
-    return nullptr;
-  }
-
-  if (catalog->Kind == kNewFSCatalogKindFile) {
+  if (catalog && catalog->Kind == kNewFSCatalogKindFile) {
     delete catalog;
     return nullptr;
+  } else if (!catalog) {
+      outLba = kNewFSCatalogStartAddress;
   }
 
   constexpr SizeT cDefaultForkSize = kNewFSForkSize;
@@ -230,7 +229,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
   catalogChild->ResourceForkSize = cDefaultForkSize;
   catalogChild->DataForkSize = cDefaultForkSize;
 
-  catalogChild->NextSibling = 0UL;
+  catalogChild->NextSibling = outLba;
   catalogChild->PrevSibling = outLba;
   catalogChild->Kind = kind;
   catalogChild->Flags = kNewFSFlagCreated;
@@ -238,23 +237,32 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
   rt_copy_memory((VoidPtr)name, (VoidPtr)catalogChild->Name,
                  rt_string_len(name));
 
-  UInt16 catalogBuf[kNewFSMinimumSectorSz] = {0};
+  UInt16 catalogBuf[kNewFSSectorSz] = {0};
 
   auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
-  Lba startFree = catalogChild->PrevSibling + catalog->NextSibling;
+  Lba startFree = outLba;
 
   rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
                  rt_string_len("fs/newfs-packet"));
 
   drive->fPacket.fPacketContent = catalogBuf;
-  drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+  drive->fPacket.fPacketSize = kNewFSSectorSz;
   drive->fPacket.fLba = startFree;
 
   drive->fInput(&drive->fPacket);
 
+  NewCatalog* nextSibling = (NewCatalog*)catalogBuf;
+
+  startFree = nextSibling->NextSibling;
+
+  catalogChild->PrevSibling = outLba;
+
+  drive->fPacket.fLba = startFree;
+  drive->fInput(&drive->fPacket);
+
   while (drive->fPacket.fPacketGood) {
-    NewCatalog* nextSibling = (NewCatalog*)catalogBuf;
+    nextSibling = (NewCatalog*)catalogBuf;
 
     if (startFree <= kNewFSAddressAsLba) {
       delete catalogChild;
@@ -265,10 +273,10 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
 
     /// allocation or reallocation or catalog...
     if (nextSibling->Flags != kNewFSFlagCreated) {
-      Char sectorBufPartBlock[kNewFSMinimumSectorSz] = {0};
+      Char sectorBufPartBlock[kNewFSSectorSz] = {0};
 
       drive->fPacket.fPacketContent = sectorBufPartBlock;
-      drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+      drive->fPacket.fPacketSize = kNewFSSectorSz;
       drive->fPacket.fLba = kNewFSAddressAsLba;
 
       drive->fInput(&drive->fPacket);
@@ -277,46 +285,32 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
 
       catalogChild->DataFork = partBlock->DiskSize - partBlock->StartCatalog;
 
-      kcout << "DataFork: " << hex_number(catalogChild->DataFork) << endl;
-
       catalogChild->ResourceFork = catalogChild->DataFork;
 
-      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);
-
-      rt_copy_memory(catalogChild, catalogBuf, sizeof(NewCatalog));
+      catalogChild->NextSibling = startFree + sizeof(NewCatalog);
 
-      drive->fPacket.fPacketContent = catalogBuf;
+      drive->fPacket.fPacketContent = catalogChild;
       drive->fPacket.fPacketSize = sizeof(NewCatalog);
       drive->fPacket.fLba = startFree;
 
       drive->fOutput(&drive->fPacket);
 
-      kcout << "New OS: Create new catalog, status: "
-            << hex_number(nextSibling->Flags) << endl;
-
-      Char sectBuf[sizeof(NewCatalog)] = {0};
-
-      drive->fPacket.fPacketContent = sectBuf;
-      drive->fPacket.fPacketSize = sizeof(NewCatalog);
-      drive->fPacket.fLba = catalogChild->PrevSibling;
+      drive->fPacket.fPacketContent = catalogBuf;
+      drive->fPacket.fPacketSize = kNewFSSectorSz;
+      drive->fPacket.fLba = outLba;
 
       drive->fInput(&drive->fPacket);
 
-      NewCatalog* prevCatalog = (NewCatalog*)sectBuf;
-      prevCatalog->NextSibling = startFree;
+      nextSibling->NextSibling = startFree;
 
       drive->fOutput(&drive->fPacket);
 
+      kcout << "New OS: Create new catalog, status: "
+            << hex_number(catalogChild->Flags) << endl;
+      kcout << "New OS: Create new catalog, status: " << catalogChild->Name << endl;
+
       drive->fPacket.fPacketContent = sectorBufPartBlock;
-      drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+      drive->fPacket.fPacketSize = kNewFSSectorSz;
       drive->fPacket.fLba = kNewFSAddressAsLba;
 
       drive->fInput(&drive->fPacket);
@@ -332,10 +326,10 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name,
     }
 
     //// @note that's how we find the next catalog in the partition block.
-    startFree += sizeof(NewFork) + sizeof(NewCatalog) + cDefaultForkSize;
+    startFree = startFree + 1;
 
     drive->fPacket.fPacketContent = catalogBuf;
-    drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+    drive->fPacket.fPacketSize = kNewFSSectorSz;
     drive->fPacket.fLba = startFree;
 
     drive->fInput(&drive->fPacket);
@@ -353,7 +347,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
   drive->fVerify(&drive->fPacket);
 
   rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
-                   rt_string_len("fs/newfs-packet"));
+                 rt_string_len("fs/newfs-packet"));
 
   /// if disk isn't good, then error out.
   if (false == drive->fPacket.fPacketGood) {
@@ -361,10 +355,10 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
     return false;
   }
 
-  Char sectorBuf[kNewFSMinimumSectorSz] = {0};
+  Char sectorBuf[kNewFSSectorSz] = {0};
 
   drive->fPacket.fPacketContent = sectorBuf;
-  drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+  drive->fPacket.fPacketSize = kNewFSSectorSz;
   drive->fPacket.fLba = kNewFSAddressAsLba;
 
   drive->fInput(&drive->fPacket);
@@ -401,7 +395,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive) {
       partBlock->FreeCatalog = partBlock->StartCatalog;
 
       drive->fPacket.fPacketContent = sectorBuf;
-      drive->fPacket.fPacketSize = kNewFSMinimumSectorSz;
+      drive->fPacket.fPacketSize = kNewFSSectorSz;
       drive->fPacket.fLba = kNewFSAddressAsLba;
 
       drive->fOutput(&drive->fPacket);
@@ -442,7 +436,7 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
   auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
   rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
-                   rt_string_len("fs/newfs-packet"));
+                 rt_string_len("fs/newfs-packet"));
 
   auto startFork = catalog->DataFork;
 
@@ -465,19 +459,19 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
       return false;
     }
 
-   if (forkData->Flags != kNewFSFlagUnallocated &&
-       forkData->Flags != kNewFSFlagDeleted &&
-       StringBuilder::Equals(forkData->Name, forkName)) {
-       drive->fPacket.fPacketContent = data;
-       drive->fPacket.fPacketSize = sizeOfData;
-       drive->fPacket.fLba = forkData->DataOffset;
-       kcout << "Fork-Offset: " << hex_number(forkData->DataOffset) << endl;
+    if (forkData->Flags != kNewFSFlagUnallocated &&
+        forkData->Flags != kNewFSFlagDeleted &&
+        StringBuilder::Equals(forkData->Name, forkName)) {
+      drive->fPacket.fPacketContent = data;
+      drive->fPacket.fPacketSize = sizeOfData;
+      drive->fPacket.fLba = forkData->DataOffset;
+      kcout << "Fork-Offset: " << hex_number(forkData->DataOffset) << endl;
 
-       drive->fOutput(&drive->fPacket);
+      drive->fOutput(&drive->fPacket);
 
-       delete forkData;
-       return true;
-   }
+      delete forkData;
+      return true;
+    }
 
     startFork = forkData->NextSibling;
   }
@@ -497,7 +491,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
   auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
   rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
-                   rt_string_len("fs/newfs-packet"));
+                 rt_string_len("fs/newfs-packet"));
 
   drive->fPacket.fPacketContent = sectorBuf;
   drive->fPacket.fPacketSize = sizeof(NewPartitionBlock);
@@ -518,9 +512,6 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
   while (drive->fPacket.fPacketGood) {
     NewCatalog* catalog = (NewCatalog*)sectorBuf;
 
-    kcout << "Catalog-Name: " << catalog->Name << endl;
-    kcout << "Catalog-Flags: " << hex_number(catalog->Flags) << endl;
-
     if (StringBuilder::Equals(catalogName, catalog->Name)) {
       /// ignore unallocated catalog, break
       if (catalog->Flags != kNewFSFlagCreated) {
@@ -540,8 +531,6 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
   _NewFSContinueSearch:
     start = catalog->NextSibling;
 
-    kcout << "Catalog-Next: " << hex_number(start) << endl;
-
     if (start <= kNewFSAddressAsLba) break;
 
     drive->fPacket.fLba = start;
@@ -596,7 +585,7 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName) {
     auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
     rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
-                     rt_string_len("fs/newfs-packet"));
+                   rt_string_len("fs/newfs-packet"));
 
     drive->fPacket.fLba = outLba;  // the catalog position.
     drive->fPacket.fPacketSize =
@@ -621,7 +610,8 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName) {
 /// @param dataSz
 /// @return
 VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
-                                 _Input SizeT dataSz, _Input const char* forkName) {
+                                 _Input SizeT dataSz,
+                                 _Input const char* forkName) {
   if (!catalog) {
     DbgLastError() = kErrorFileNotFound;
     return nullptr;
@@ -639,38 +629,37 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
   auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
   rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
-                   rt_string_len("fs/newfs-packet"));
+                 rt_string_len("fs/newfs-packet"));
 
   NewFork* forkData = nullptr;
 
   while (dataForkLba >= kNewFSCatalogStartAddress) {
-      drive->fPacket.fLba = dataForkLba;
-      drive->fPacket.fPacketSize = sizeof(NewFork);
-      drive->fPacket.fPacketContent = sectorBuf;
+    drive->fPacket.fLba = dataForkLba;
+    drive->fPacket.fPacketSize = sizeof(NewFork);
+    drive->fPacket.fPacketContent = sectorBuf;
 
-      drive->fInput(&drive->fPacket);
+    drive->fInput(&drive->fPacket);
 
-      forkData = (NewFork*)sectorBuf;
+    forkData = (NewFork*)sectorBuf;
 
-      kcout << "Fork-Name: " << forkData->Name << endl;
+    kcout << "Fork-Name: " << forkData->Name << endl;
 
-      if (forkData->DataOffset <= kNewFSCatalogStartAddress) {
-        delete[] sectorBuf;
+    if (forkData->DataOffset <= kNewFSCatalogStartAddress) {
+      delete[] sectorBuf;
 
-        kcout << "Fail-Data-Offset: " << hex_number(forkData->DataOffset) << endl;
+      kcout << "Fail-Data-Offset: " << hex_number(forkData->DataOffset) << endl;
 
-        return nullptr;
-      }
+      return nullptr;
+    }
 
-      if (StringBuilder::Equals(forkName, forkData->Name))
-        break;
+    if (StringBuilder::Equals(forkName, forkData->Name)) break;
 
-      dataForkLba = forkData->NextSibling;
+    dataForkLba = forkData->NextSibling;
   }
 
   if (dataForkLba <= kNewFSCatalogStartAddress) {
-      delete[] sectorBuf;
-      return nullptr;
+    delete[] sectorBuf;
+    return nullptr;
   }
 
   Char* forkBuf = new Char[dataSz];