Merged in MHR-18 (pull request #9)

MHR-18

4 files changed, 79 insertions, 131 deletions

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