boot/freeldr/freeldr/ntldr/winldr.c

   1 /*
   2  *  FreeLoader
   3  *
   4  *  Copyright (C) 1998-2003  Brian Palmer    <brianp@sginet.com>
   5  *  Copyright (C) 2006       Aleksey Bragin  <aleksey@reactos.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <freeldr.h>
  23 #include "registry.h"
  24
  25 #include <ndk/ldrtypes.h>
  26
  27 #include <debug.h>
  28 DBG_DEFAULT_CHANNEL(WINDOWS);
  29
  30 // FIXME: Find a better way to retrieve ARC disk information
  31 extern ULONG reactos_disk_count;
  32 extern ARC_DISK_SIGNATURE_EX reactos_arc_disk_info[];
  33
  34 extern ULONG LoaderPagesSpanned;
  35 extern BOOLEAN AcpiPresent;
  36
  37 extern HEADLESS_LOADER_BLOCK LoaderRedirectionInformation;
  38 extern BOOLEAN WinLdrTerminalConnected;
  39 extern void WinLdrSetupEms(IN PCHAR BootOptions);
  40
  41 PLOADER_SYSTEM_BLOCK WinLdrSystemBlock;
  42
  43 // debug stuff
  44 VOID DumpMemoryAllocMap(VOID);
  45
  46 // Init "phase 0"
  47 VOID
  48 AllocateAndInitLPB(PLOADER_PARAMETER_BLOCK *OutLoaderBlock)
  49 {
  50     PLOADER_PARAMETER_BLOCK LoaderBlock;
  51
  52     /* Allocate and zero-init the LPB */
  53     WinLdrSystemBlock = MmAllocateMemoryWithType(sizeof(LOADER_SYSTEM_BLOCK),
  54                                                  LoaderSystemBlock);
  55     if (WinLdrSystemBlock == NULL)
  56     {
  57         UiMessageBox("Failed to allocate memory for system block!");
  58         return;
  59     }
  60
  61     RtlZeroMemory(WinLdrSystemBlock, sizeof(LOADER_SYSTEM_BLOCK));
  62
  63     LoaderBlock = &WinLdrSystemBlock->LoaderBlock;
  64     LoaderBlock->NlsData = &WinLdrSystemBlock->NlsDataBlock;
  65
  66     /* Init three critical lists, used right away */
  67     InitializeListHead(&LoaderBlock->LoadOrderListHead);
  68     InitializeListHead(&LoaderBlock->MemoryDescriptorListHead);
  69     InitializeListHead(&LoaderBlock->BootDriverListHead);
  70
  71     *OutLoaderBlock = LoaderBlock;
  72 }
  73
  74 // Init "phase 1"
  75 VOID
  76 WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock,
  77                        LPCSTR Options,
  78                        LPCSTR SystemRoot,
  79                        LPCSTR BootPath,
  80                        USHORT VersionToBoot)
  81 {
  82     /* Examples of correct options and paths */
  83     //CHAR    Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
  84     //CHAR    Options[] = "/NODEBUG";
  85     //CHAR    SystemRoot[] = "\\WINNT\\";
  86     //CHAR    ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
  87
  88     LPSTR LoadOptions, NewLoadOptions;
  89     CHAR  HalPath[] = "\\";
  90     CHAR  ArcBoot[256];
  91     CHAR  MiscFiles[256];
  92     ULONG i;
  93     ULONG_PTR PathSeparator;
  94     PLOADER_PARAMETER_EXTENSION Extension;
  95
  96     /* Construct SystemRoot and ArcBoot from SystemPath */
  97     PathSeparator = strstr(BootPath, "\\") - BootPath;
  98     strncpy(ArcBoot, BootPath, PathSeparator);
  99     ArcBoot[PathSeparator] = ANSI_NULL;
 100
 101     TRACE("ArcBoot: %s\n", ArcBoot);
 102     TRACE("SystemRoot: %s\n", SystemRoot);
 103     TRACE("Options: %s\n", Options);
 104
 105     /* Fill Arc BootDevice */
 106     LoaderBlock->ArcBootDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
 107     strncpy(LoaderBlock->ArcBootDeviceName, ArcBoot, MAX_PATH);
 108     LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
 109
 110     /* Fill Arc HalDevice, it matches ArcBoot path */
 111     LoaderBlock->ArcHalDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
 112     LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
 113
 114     /* Fill SystemRoot */
 115     LoaderBlock->NtBootPathName = WinLdrSystemBlock->NtBootPathName;
 116     strncpy(LoaderBlock->NtBootPathName, SystemRoot, MAX_PATH);
 117     LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
 118
 119     /* Fill NtHalPathName */
 120     LoaderBlock->NtHalPathName = WinLdrSystemBlock->NtHalPathName;
 121     strncpy(LoaderBlock->NtHalPathName, HalPath, MAX_PATH);
 122     LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
 123
 124     /* Fill LoadOptions and strip the '/' commutator symbol in front of each option */
 125     NewLoadOptions = LoadOptions = LoaderBlock->LoadOptions = WinLdrSystemBlock->LoadOptions;
 126     strncpy(LoaderBlock->LoadOptions, Options, MAX_OPTIONS_LENGTH);
 127
 128     do
 129     {
 130         while (*LoadOptions == '/')
 131             ++LoadOptions;
 132
 133         *NewLoadOptions++ = *LoadOptions;
 134     } while (*LoadOptions++);
 135
 136     LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
 137
 138     /* Arc devices */
 139     LoaderBlock->ArcDiskInformation = &WinLdrSystemBlock->ArcDiskInformation;
 140     InitializeListHead(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
 141
 142     /* Convert ARC disk information from freeldr to a correct format */
 143     for (i = 0; i < reactos_disk_count; i++)
 144     {
 145         PARC_DISK_SIGNATURE_EX ArcDiskSig;
 146
 147         /* Allocate the ARC structure */
 148         ArcDiskSig = FrLdrHeapAlloc(sizeof(ARC_DISK_SIGNATURE_EX), 'giSD');
 149
 150         /* Copy the data over */
 151         RtlCopyMemory(ArcDiskSig, &reactos_arc_disk_info[i], sizeof(ARC_DISK_SIGNATURE_EX));
 152
 153         /* Set the ARC Name pointer and mark the partition table as valid */
 154         ArcDiskSig->DiskSignature.ArcName = PaToVa(ArcDiskSig->ArcName);
 155         ArcDiskSig->DiskSignature.ValidPartitionTable = TRUE;
 156
 157         /* Insert into the list */
 158         InsertTailList(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead,
 159                        &ArcDiskSig->DiskSignature.ListEntry);
 160     }
 161
 162     /* Convert all list's to Virtual address */
 163
 164     /* Convert the ArcDisks list to virtual address */
 165     List_PaToVa(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
 166     LoaderBlock->ArcDiskInformation = PaToVa(LoaderBlock->ArcDiskInformation);
 167
 168     /* Convert configuration entries to VA */
 169     ConvertConfigToVA(LoaderBlock->ConfigurationRoot);
 170     LoaderBlock->ConfigurationRoot = PaToVa(LoaderBlock->ConfigurationRoot);
 171
 172     /* Convert all DTE into virtual addresses */
 173     List_PaToVa(&LoaderBlock->LoadOrderListHead);
 174
 175     /* This one will be converted right before switching to virtual paging mode */
 176     //List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
 177
 178     /* Convert list of boot drivers */
 179     List_PaToVa(&LoaderBlock->BootDriverListHead);
 180
 181     /* Initialize Extension now */
 182     Extension = &WinLdrSystemBlock->Extension;
 183     Extension->Size = sizeof(LOADER_PARAMETER_EXTENSION);
 184     Extension->MajorVersion = (VersionToBoot & 0xFF00) >> 8;
 185     Extension->MinorVersion = VersionToBoot & 0xFF;
 186     Extension->Profile.Status = 2;
 187
 188     /* Check if FreeLdr detected a ACPI table */
 189     if (AcpiPresent)
 190     {
 191         /* Set the pointer to something for compatibility */
 192         Extension->AcpiTable = (PVOID)1;
 193         // FIXME: Extension->AcpiTableSize;
 194     }
 195
 196 #ifdef _M_IX86
 197     /* Set headless block pointer */
 198     if (WinLdrTerminalConnected)
 199     {
 200         Extension->HeadlessLoaderBlock = &WinLdrSystemBlock->HeadlessLoaderBlock;
 201         RtlCopyMemory(Extension->HeadlessLoaderBlock,
 202                       &LoaderRedirectionInformation,
 203                       sizeof(HEADLESS_LOADER_BLOCK));
 204         Extension->HeadlessLoaderBlock = PaToVa(Extension->HeadlessLoaderBlock);
 205     }
 206 #endif
 207     /* Load drivers database */
 208     strcpy(MiscFiles, BootPath);
 209     strcat(MiscFiles, "AppPatch\\drvmain.sdb");
 210     Extension->DrvDBImage = PaToVa(WinLdrLoadModule(MiscFiles,
 211                                                     &Extension->DrvDBSize,
 212                                                     LoaderRegistryData));
 213
 214     /* Convert extension and setup block pointers */
 215     LoaderBlock->Extension = PaToVa(Extension);
 216
 217     if (LoaderBlock->SetupLdrBlock)
 218         LoaderBlock->SetupLdrBlock = PaToVa(LoaderBlock->SetupLdrBlock);
 219
 220     TRACE("WinLdrInitializePhase1() completed\n");
 221 }
 222
 223 static BOOLEAN
 224 WinLdrLoadDeviceDriver(PLIST_ENTRY LoadOrderListHead,
 225                        LPCSTR BootPath,
 226                        PUNICODE_STRING FilePath,
 227                        ULONG Flags,
 228                        PLDR_DATA_TABLE_ENTRY *DriverDTE)
 229 {
 230     CHAR FullPath[1024];
 231     CHAR DriverPath[1024];
 232     CHAR DllName[1024];
 233     PCHAR DriverNamePos;
 234     BOOLEAN Success;
 235     PVOID DriverBase = NULL;
 236
 237     // Separate the path to file name and directory path
 238     _snprintf(DriverPath, sizeof(DriverPath), "%wZ", FilePath);
 239     DriverNamePos = strrchr(DriverPath, '\\');
 240     if (DriverNamePos != NULL)
 241     {
 242         // Copy the name
 243         strcpy(DllName, DriverNamePos+1);
 244
 245         // Cut out the name from the path
 246         *(DriverNamePos+1) = 0;
 247     }
 248     else
 249     {
 250         // There is no directory in the path
 251         strcpy(DllName, DriverPath);
 252         DriverPath[0] = ANSI_NULL;
 253     }
 254
 255     TRACE("DriverPath: %s, DllName: %s, LPB\n", DriverPath, DllName);
 256
 257     // Check if driver is already loaded
 258     Success = WinLdrCheckForLoadedDll(LoadOrderListHead, DllName, DriverDTE);
 259     if (Success)
 260     {
 261         // We've got the pointer to its DTE, just return success
 262         return TRUE;
 263     }
 264
 265     // It's not loaded, we have to load it
 266     _snprintf(FullPath, sizeof(FullPath), "%s%wZ", BootPath, FilePath);
 267     Success = WinLdrLoadImage(FullPath, LoaderBootDriver, &DriverBase);
 268     if (!Success)
 269         return FALSE;
 270
 271     // Allocate a DTE for it
 272     Success = WinLdrAllocateDataTableEntry(LoadOrderListHead, DllName, DllName, DriverBase, DriverDTE);
 273     if (!Success)
 274     {
 275         ERR("WinLdrAllocateDataTableEntry() failed\n");
 276         return FALSE;
 277     }
 278
 279     // Modify any flags, if needed
 280     (*DriverDTE)->Flags |= Flags;
 281
 282     // Look for any dependencies it may have, and load them too
 283     sprintf(FullPath,"%s%s", BootPath, DriverPath);
 284     Success = WinLdrScanImportDescriptorTable(LoadOrderListHead, FullPath, *DriverDTE);
 285     if (!Success)
 286     {
 287         ERR("WinLdrScanImportDescriptorTable() failed for %s\n", FullPath);
 288         return FALSE;
 289     }
 290
 291     return TRUE;
 292 }
 293
 294 BOOLEAN
 295 WinLdrLoadBootDrivers(PLOADER_PARAMETER_BLOCK LoaderBlock,
 296                       LPCSTR BootPath)
 297 {
 298     PLIST_ENTRY NextBd;
 299     PBOOT_DRIVER_LIST_ENTRY BootDriver;
 300     BOOLEAN Success;
 301     BOOLEAN ret = TRUE;
 302
 303     // Walk through the boot drivers list
 304     NextBd = LoaderBlock->BootDriverListHead.Flink;
 305
 306     while (NextBd != &LoaderBlock->BootDriverListHead)
 307     {
 308         BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
 309
 310         TRACE("BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
 311             BootDriver->LdrEntry, &BootDriver->RegistryPath);
 312
 313         // Paths are relative (FIXME: Are they always relative?)
 314
 315         // Load it
 316         Success = WinLdrLoadDeviceDriver(&LoaderBlock->LoadOrderListHead,
 317                                          BootPath,
 318                                          &BootDriver->FilePath,
 319                                          0,
 320                                          &BootDriver->LdrEntry);
 321
 322         if (Success)
 323         {
 324             // Convert the RegistryPath and DTE addresses to VA since we are not going to use it anymore
 325             BootDriver->RegistryPath.Buffer = PaToVa(BootDriver->RegistryPath.Buffer);
 326             BootDriver->FilePath.Buffer = PaToVa(BootDriver->FilePath.Buffer);
 327             BootDriver->LdrEntry = PaToVa(BootDriver->LdrEntry);
 328         }
 329         else
 330         {
 331             // Loading failed - cry loudly
 332             ERR("Can't load boot driver '%wZ'!\n", &BootDriver->FilePath);
 333             UiMessageBox("Can't load boot driver '%wZ'!", &BootDriver->FilePath);
 334             ret = FALSE;
 335
 336             // Remove it from the list and try to continue
 337             RemoveEntryList(NextBd);
 338         }
 339
 340         NextBd = BootDriver->Link.Flink;
 341     }
 342
 343     return ret;
 344 }
 345
 346 PVOID
 347 WinLdrLoadModule(PCSTR ModuleName,
 348                  ULONG *Size,
 349                  TYPE_OF_MEMORY MemoryType)
 350 {
 351     ULONG FileId;
 352     PVOID PhysicalBase;
 353     FILEINFORMATION FileInfo;
 354     ULONG FileSize;
 355     ARC_STATUS Status;
 356     ULONG BytesRead;
 357
 358     //CHAR ProgressString[256];
 359
 360     /* Inform user we are loading files */
 361     //sprintf(ProgressString, "Loading %s...", FileName);
 362     //UiDrawProgressBarCenter(1, 100, ProgressString);
 363
 364     TRACE("Loading module %s\n", ModuleName);
 365     *Size = 0;
 366
 367     /* Open the image file */
 368     Status = ArcOpen((PCHAR)ModuleName, OpenReadOnly, &FileId);
 369     if (Status != ESUCCESS)
 370     {
 371         /* In case of errors, we just return, without complaining to the user */
 372         return NULL;
 373     }
 374
 375     /* Get this file's size */
 376     Status = ArcGetFileInformation(FileId, &FileInfo);
 377     if (Status != ESUCCESS)
 378     {
 379         ArcClose(FileId);
 380         return NULL;
 381     }
 382     FileSize = FileInfo.EndingAddress.LowPart;
 383     *Size = FileSize;
 384
 385     /* Allocate memory */
 386     PhysicalBase = MmAllocateMemoryWithType(FileSize, MemoryType);
 387     if (PhysicalBase == NULL)
 388     {
 389         ArcClose(FileId);
 390         return NULL;
 391     }
 392
 393     /* Load whole file */
 394     Status = ArcRead(FileId, PhysicalBase, FileSize, &BytesRead);
 395     ArcClose(FileId);
 396     if (Status != ESUCCESS)
 397     {
 398         return NULL;
 399     }
 400
 401     TRACE("Loaded %s at 0x%x with size 0x%x\n", ModuleName, PhysicalBase, FileSize);
 402
 403     return PhysicalBase;
 404 }
 405
 406 USHORT
 407 WinLdrDetectVersion(VOID)
 408 {
 409     LONG rc;
 410     HKEY hKey;
 411
 412     rc = RegOpenKey(
 413         NULL,
 414         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server",
 415         &hKey);
 416     if (rc != ERROR_SUCCESS)
 417     {
 418         // Key doesn't exist; assume NT 4.0
 419         return _WIN32_WINNT_NT4;
 420     }
 421
 422     // We may here want to read the value of ProductVersion
 423     return _WIN32_WINNT_WS03;
 424 }
 425
 426 static
 427 BOOLEAN
 428 LoadModule(
 429     IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
 430     IN PCCH Path,
 431     IN PCCH File,
 432     IN PCCH ImportName, // BaseDllName
 433     IN TYPE_OF_MEMORY MemoryType,
 434     OUT PLDR_DATA_TABLE_ENTRY *Dte,
 435     IN ULONG Percentage)
 436 {
 437     BOOLEAN Success;
 438     CHAR FullFileName[MAX_PATH];
 439     CHAR ProgressString[256];
 440     PVOID BaseAddress = NULL;
 441
 442     UiDrawBackdrop();
 443     sprintf(ProgressString, "Loading %s...", File);
 444     UiDrawProgressBarCenter(Percentage, 100, ProgressString);
 445
 446     strcpy(FullFileName, Path);
 447     strcat(FullFileName, File);
 448
 449     Success = WinLdrLoadImage(FullFileName, MemoryType, &BaseAddress);
 450     if (!Success)
 451     {
 452         TRACE("Loading %s failed\n", File);
 453         return FALSE;
 454     }
 455     TRACE("%s loaded successfully at %p\n", File, BaseAddress);
 456
 457     /*
 458      * Cheat about the base DLL name if we are loading
 459      * the Kernel Debugger Transport DLL, to make the
 460      * PE loader happy.
 461      */
 462     Success = WinLdrAllocateDataTableEntry(&LoaderBlock->LoadOrderListHead,
 463                                            ImportName,
 464                                            FullFileName,
 465                                            BaseAddress,
 466                                            Dte);
 467
 468     return Success;
 469 }
 470
 471 static
 472 BOOLEAN
 473 LoadWindowsCore(IN USHORT OperatingSystemVersion,
 474                 IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
 475                 IN PCSTR BootOptions,
 476                 IN PCSTR BootPath,
 477                 IN OUT PLDR_DATA_TABLE_ENTRY* KernelDTE)
 478 {
 479     BOOLEAN Success;
 480     PCSTR Options;
 481     CHAR DirPath[MAX_PATH];
 482     CHAR KernelFileName[MAX_PATH];
 483     CHAR HalFileName[MAX_PATH];
 484     CHAR KdTransportDllName[MAX_PATH];
 485     PLDR_DATA_TABLE_ENTRY HalDTE, KdComDTE = NULL;
 486
 487     if (!KernelDTE) return FALSE;
 488
 489     /* Initialize SystemRoot\System32 path */
 490     strcpy(DirPath, BootPath);
 491     strcat(DirPath, "SYSTEM32\\");
 492
 493     //
 494     // TODO: Parse also the separate INI values "Kernel=" and "Hal="
 495     //
 496
 497     /* Default KERNEL and HAL file names */
 498     strcpy(KernelFileName, "NTOSKRNL.EXE");
 499     strcpy(HalFileName   , "HAL.DLL");
 500
 501     /* Find any /KERNEL= or /HAL= switch in the boot options */
 502     Options = BootOptions;
 503     while (Options)
 504     {
 505         /* Skip possible initial whitespace */
 506         Options += strspn(Options, " \t");
 507
 508         /* Check whether a new commutator starts and it is either KERNEL or HAL */
 509         if (*Options != '/' || (++Options,
 510             !(_strnicmp(Options, "KERNEL=", 7) == 0 ||
 511               _strnicmp(Options, "HAL=",    4) == 0)) )
 512         {
 513             /* Search for another whitespace */
 514             Options = strpbrk(Options, " \t");
 515             continue;
 516         }
 517         else
 518         {
 519             size_t i = strcspn(Options, " \t"); /* Skip whitespace */
 520             if (i == 0)
 521             {
 522                 /* Use the default values */
 523                 break;
 524             }
 525
 526             /* We have found either KERNEL or HAL commutator */
 527             if (_strnicmp(Options, "KERNEL=", 7) == 0)
 528             {
 529                 Options += 7; i -= 7;
 530                 strncpy(KernelFileName, Options, i);
 531                 KernelFileName[i] = ANSI_NULL;
 532                 _strupr(KernelFileName);
 533             }
 534             else if (_strnicmp(Options, "HAL=", 4) == 0)
 535             {
 536                 Options += 4; i -= 4;
 537                 strncpy(HalFileName, Options, i);
 538                 HalFileName[i] = ANSI_NULL;
 539                 _strupr(HalFileName);
 540             }
 541         }
 542     }
 543
 544     TRACE("Kernel file = '%s' ; HAL file = '%s'\n", KernelFileName, HalFileName);
 545
 546     /* Load the Kernel */
 547     LoadModule(LoaderBlock, DirPath, KernelFileName, "NTOSKRNL.EXE", LoaderSystemCode, KernelDTE, 30);
 548
 549     /* Load the HAL */
 550     LoadModule(LoaderBlock, DirPath, HalFileName, "HAL.DLL", LoaderHalCode, &HalDTE, 45);
 551
 552     /* Load the Kernel Debugger Transport DLL */
 553     if (OperatingSystemVersion > _WIN32_WINNT_WIN2K)
 554     {
 555         /*
 556          * According to http://www.nynaeve.net/?p=173 :
 557          * "[...] Another enhancement that could be done Microsoft-side would be
 558          * a better interface for replacing KD transport modules. Right now, due
 559          * to the fact that ntoskrnl is static linked to KDCOM.DLL, the OS loader
 560          * has a hardcoded hack that interprets the KD type in the OS loader options,
 561          * loads one of the (hardcoded filenames) "kdcom.dll", "kd1394.dll", or
 562          * "kdusb2.dll" modules, and inserts them into the loaded module list under
 563          * the name "kdcom.dll". [...]"
 564          */
 565
 566         /*
 567          * This loop replaces a dumb call to strstr(..., "DEBUGPORT=").
 568          * Indeed I want it to be case-insensitive to allow "debugport="
 569          * or "DeBuGpOrT=" or... , and I don't want it to match malformed
 570          * command-line options, such as:
 571          *
 572          * "...foo DEBUGPORT=xxx bar..."
 573          * "...foo/DEBUGPORT=xxx bar..."
 574          * "...foo/DEBUGPORT=bar..."
 575          *
 576          * i.e. the "DEBUGPORT=" switch must start with a slash and be separated
 577          * from the rest by whitespace, unless it begins the command-line, e.g.:
 578          *
 579          * "/DEBUGPORT=COM1 foo...bar..."
 580          * "...foo /DEBUGPORT=USB bar..."
 581          * or:
 582          * "...foo /DEBUGPORT= bar..."
 583          * (in that case, we default the port to COM).
 584          */
 585         Options = BootOptions;
 586         while (Options)
 587         {
 588             /* Skip possible initial whitespace */
 589             Options += strspn(Options, " \t");
 590
 591             /* Check whether a new commutator starts and it is the DEBUGPORT one */
 592             if (*Options != '/' || _strnicmp(++Options, "DEBUGPORT=", 10) != 0)
 593             {
 594                 /* Search for another whitespace */
 595                 Options = strpbrk(Options, " \t");
 596                 continue;
 597             }
 598             else
 599             {
 600                 /* We found the DEBUGPORT commutator. Move to the port name. */
 601                 Options += 10;
 602                 break;
 603             }
 604         }
 605
 606         if (Options)
 607         {
 608             /*
 609              * We have found the DEBUGPORT commutator. Parse the port name.
 610              * Format: /DEBUGPORT=COM1 or /DEBUGPORT=FILE:\Device\HarddiskX\PartitionY\debug.log or /DEBUGPORT=FOO
 611              * If we only have /DEBUGPORT= (i.e. without any port name), defaults it to "COM".
 612              */
 613             strcpy(KdTransportDllName, "KD");
 614             if (_strnicmp(Options, "COM", 3) == 0 && '0' <= Options[3] && Options[3] <= '9')
 615             {
 616                 strncat(KdTransportDllName, Options, 3);
 617             }
 618             else
 619             {
 620                 size_t i = strcspn(Options, " \t:"); /* Skip valid separators: whitespace or colon */
 621                 if (i == 0)
 622                     strcat(KdTransportDllName, "COM");
 623                 else
 624                     strncat(KdTransportDllName, Options, i);
 625             }
 626             strcat(KdTransportDllName, ".DLL");
 627             _strupr(KdTransportDllName);
 628
 629             /*
 630              * Load the transport DLL. Override the base DLL name of the
 631              * loaded transport DLL to the default "KDCOM.DLL" name.
 632              */
 633             LoadModule(LoaderBlock, DirPath, KdTransportDllName, "KDCOM.DLL", LoaderSystemCode, &KdComDTE, 60);
 634         }
 635     }
 636
 637     /* Load all referenced DLLs for Kernel, HAL and Kernel Debugger Transport DLL */
 638     Success  = WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, *KernelDTE);
 639     Success &= WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, HalDTE);
 640     if (KdComDTE)
 641     {
 642         Success &= WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, KdComDTE);
 643     }
 644
 645     return Success;
 646 }
 647
 648 VOID
 649 LoadAndBootWindows(IN OperatingSystemItem* OperatingSystem,
 650                    IN USHORT OperatingSystemVersion)
 651 {
 652     ULONG_PTR SectionId;
 653     PCSTR SectionName = OperatingSystem->SystemPartition;
 654     CHAR  SettingsValue[80];
 655     BOOLEAN HasSection;
 656     CHAR  BootPath[MAX_PATH];
 657     CHAR  FileName[MAX_PATH];
 658     CHAR  BootOptions[256];
 659     PCHAR File;
 660     BOOLEAN Success;
 661     PLOADER_PARAMETER_BLOCK LoaderBlock;
 662
 663     /* Get OS setting value */
 664     SettingsValue[0] = ANSI_NULL;
 665     IniOpenSection("Operating Systems", &SectionId);
 666     IniReadSettingByName(SectionId, SectionName, SettingsValue, sizeof(SettingsValue));
 667
 668     /* Open the operating system section specified in the .ini file */
 669     HasSection = IniOpenSection(SectionName, &SectionId);
 670
 671     UiDrawBackdrop();
 672     UiDrawProgressBarCenter(1, 100, "Loading NT...");
 673
 674     /* Read the system path is set in the .ini file */
 675     if (!HasSection ||
 676         !IniReadSettingByName(SectionId, "SystemPath", BootPath, sizeof(BootPath)))
 677     {
 678         strcpy(BootPath, SectionName);
 679     }
 680
 681     /*
 682      * Check whether BootPath is a full path
 683      * and if not, create a full boot path.
 684      *
 685      * See FsOpenFile for the technique used.
 686      */
 687     if (strrchr(BootPath, ')') == NULL)
 688     {
 689         /* Temporarily save the boot path */
 690         strcpy(FileName, BootPath);
 691
 692         /* This is not a full path. Use the current (i.e. boot) device. */
 693         MachDiskGetBootPath(BootPath, sizeof(BootPath));
 694
 695         /* Append a path separator if needed */
 696         if (FileName[0] != '\\' && FileName[0] != '/')
 697             strcat(BootPath, "\\");
 698
 699         /* Append the remaining path */
 700         strcat(BootPath, FileName);
 701     }
 702
 703     /* Append a backslash if needed */
 704     if ((BootPath[0] == 0) || BootPath[strlen(BootPath) - 1] != '\\')
 705         strcat(BootPath, "\\");
 706
 707     /* Read booting options */
 708     if (!HasSection || !IniReadSettingByName(SectionId, "Options", BootOptions, sizeof(BootOptions)))
 709     {
 710         /* Get options after the title */
 711         PCSTR p = SettingsValue;
 712         while (*p == ' ' || *p == '"')
 713             p++;
 714         while (*p != '\0' && *p != '"')
 715             p++;
 716         strcpy(BootOptions, p);
 717         TRACE("BootOptions: '%s'\n", BootOptions);
 718     }
 719
 720     /* Append boot-time options */
 721     AppendBootTimeOptions(BootOptions);
 722
 723     /* Check if a ramdisk file was given */
 724     File = strstr(BootOptions, "/RDPATH=");
 725     if (File)
 726     {
 727         /* Copy the file name and everything else after it */
 728         strcpy(FileName, File + 8);
 729
 730         /* Null-terminate */
 731         *strstr(FileName, " ") = ANSI_NULL;
 732
 733         /* Load the ramdisk */
 734         if (!RamDiskLoadVirtualFile(FileName))
 735         {
 736             UiMessageBox("Failed to load RAM disk file %s", FileName);
 737             return;
 738         }
 739     }
 740
 741     /* Let user know we started loading */
 742     //UiDrawStatusText("Loading...");
 743
 744     TRACE("BootPath: '%s'\n", BootPath);
 745
 746     /* Allocate and minimalist-initialize LPB */
 747     AllocateAndInitLPB(&LoaderBlock);
 748
 749     /* Load the system hive */
 750     UiDrawBackdrop();
 751     UiDrawProgressBarCenter(15, 100, "Loading system hive...");
 752     Success = WinLdrInitSystemHive(LoaderBlock, BootPath);
 753     TRACE("SYSTEM hive %s\n", (Success ? "loaded" : "not loaded"));
 754     /* Bail out if failure */
 755     if (!Success)
 756         return;
 757
 758     /* Load NLS data, OEM font, and prepare boot drivers list */
 759     Success = WinLdrScanSystemHive(LoaderBlock, BootPath);
 760     TRACE("SYSTEM hive %s\n", (Success ? "scanned" : "not scanned"));
 761     /* Bail out if failure */
 762     if (!Success)
 763         return;
 764
 765     /* Finish loading */
 766     LoadAndBootWindowsCommon(OperatingSystemVersion,
 767                              LoaderBlock,
 768                              BootOptions,
 769                              BootPath,
 770                              FALSE);
 771 }
 772
 773 VOID
 774 LoadAndBootWindowsCommon(
 775     USHORT OperatingSystemVersion,
 776     PLOADER_PARAMETER_BLOCK LoaderBlock,
 777     LPCSTR BootOptions,
 778     LPCSTR BootPath,
 779     BOOLEAN Setup)
 780 {
 781     PLOADER_PARAMETER_BLOCK LoaderBlockVA;
 782     BOOLEAN Success;
 783     PLDR_DATA_TABLE_ENTRY KernelDTE;
 784     KERNEL_ENTRY_POINT KiSystemStartup;
 785     LPCSTR SystemRoot;
 786     TRACE("LoadAndBootWindowsCommon()\n");
 787
 788 #ifdef _M_IX86
 789     /* Setup redirection support */
 790     WinLdrSetupEms((PCHAR)BootOptions);
 791 #endif
 792
 793     /* Convert BootPath to SystemRoot */
 794     SystemRoot = strstr(BootPath, "\\");
 795
 796     /* Detect hardware */
 797     UiDrawBackdrop();
 798     UiDrawProgressBarCenter(20, 100, "Detecting hardware...");
 799     LoaderBlock->ConfigurationRoot = MachHwDetect();
 800
 801     if (OperatingSystemVersion == 0)
 802         OperatingSystemVersion = WinLdrDetectVersion();
 803
 804     /* Load the operating system core: the Kernel, the HAL and the Kernel Debugger Transport DLL */
 805     Success = LoadWindowsCore(OperatingSystemVersion,
 806                               LoaderBlock,
 807                               BootOptions,
 808                               BootPath,
 809                               &KernelDTE);
 810     if (!Success)
 811     {
 812         UiMessageBox("Error loading NTOS core.");
 813         return;
 814     }
 815
 816     /* Load boot drivers */
 817     UiDrawBackdrop();
 818     UiDrawProgressBarCenter(100, 100, "Loading boot drivers...");
 819     Success = WinLdrLoadBootDrivers(LoaderBlock, BootPath);
 820     TRACE("Boot drivers loading %s\n", Success ? "successful" : "failed");
 821
 822     /* Initialize Phase 1 - no drivers loading anymore */
 823     WinLdrInitializePhase1(LoaderBlock,
 824                            BootOptions,
 825                            SystemRoot,
 826                            BootPath,
 827                            OperatingSystemVersion);
 828
 829     /* Save entry-point pointer and Loader block VAs */
 830     KiSystemStartup = (KERNEL_ENTRY_POINT)KernelDTE->EntryPoint;
 831     LoaderBlockVA = PaToVa(LoaderBlock);
 832
 833     /* "Stop all motors", change videomode */
 834     MachPrepareForReactOS(Setup);
 835
 836     /* Cleanup ini file */
 837     IniCleanup();
 838
 839     /* Debugging... */
 840     //DumpMemoryAllocMap();
 841
 842     /* Do the machine specific initialization */
 843     WinLdrSetupMachineDependent(LoaderBlock);
 844
 845     /* Map pages and create memory descriptors */
 846     WinLdrSetupMemoryLayout(LoaderBlock);
 847
 848     /* Set processor context */
 849     WinLdrSetProcessorContext();
 850
 851     /* Save final value of LoaderPagesSpanned */
 852     LoaderBlock->Extension->LoaderPagesSpanned = LoaderPagesSpanned;
 853
 854     TRACE("Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
 855           KiSystemStartup, LoaderBlockVA);
 856
 857     // Zero KI_USER_SHARED_DATA page
 858     memset((PVOID)KI_USER_SHARED_DATA, 0, MM_PAGE_SIZE);
 859
 860     WinLdrpDumpMemoryDescriptors(LoaderBlockVA);
 861     WinLdrpDumpBootDriver(LoaderBlockVA);
 862 #ifndef _M_AMD64
 863     WinLdrpDumpArcDisks(LoaderBlockVA);
 864 #endif
 865
 866     /* Pass control */
 867     (*KiSystemStartup)(LoaderBlockVA);
 868 }
 869
 870 VOID
 871 WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock)
 872 {
 873     PLIST_ENTRY NextMd;
 874     PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
 875
 876     NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
 877
 878     while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
 879     {
 880         MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry);
 881
 882         TRACE("BP %08X PC %04X MT %d\n", MemoryDescriptor->BasePage,
 883             MemoryDescriptor->PageCount, MemoryDescriptor->MemoryType);
 884
 885         NextMd = MemoryDescriptor->ListEntry.Flink;
 886     }
 887 }
 888
 889 VOID
 890 WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock)
 891 {
 892     PLIST_ENTRY NextBd;
 893     PBOOT_DRIVER_LIST_ENTRY BootDriver;
 894
 895     NextBd = LoaderBlock->BootDriverListHead.Flink;
 896
 897     while (NextBd != &LoaderBlock->BootDriverListHead)
 898     {
 899         BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
 900
 901         TRACE("BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
 902             BootDriver->LdrEntry, &BootDriver->RegistryPath);
 903
 904         NextBd = BootDriver->Link.Flink;
 905     }
 906 }
 907
 908 VOID
 909 WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock)
 910 {
 911     PLIST_ENTRY NextBd;
 912     PARC_DISK_SIGNATURE ArcDisk;
 913
 914     NextBd = LoaderBlock->ArcDiskInformation->DiskSignatureListHead.Flink;
 915
 916     while (NextBd != &LoaderBlock->ArcDiskInformation->DiskSignatureListHead)
 917     {
 918         ArcDisk = CONTAINING_RECORD(NextBd, ARC_DISK_SIGNATURE, ListEntry);
 919
 920         TRACE("ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
 921             ArcDisk->ArcName, ArcDisk->CheckSum, ArcDisk->Signature);
 922
 923         NextBd = ArcDisk->ListEntry.Flink;
 924     }
 925 }