reactos/boot/freeldr/freeldr/windows/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
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <freeldr.h>
  23
  24 #include <ndk/ldrtypes.h>
  25 #include <debug.h>
  26
  27 //FIXME: Do a better way to retrieve Arc disk information
  28 extern ULONG reactos_disk_count;
  29 extern ARC_DISK_SIGNATURE reactos_arc_disk_info[];
  30 extern char reactos_arc_strings[32][256];
  31
  32 extern BOOLEAN UseRealHeap;
  33 extern ULONG LoaderPagesSpanned;
  34
  35 BOOLEAN
  36 WinLdrCheckForLoadedDll(IN OUT PLOADER_PARAMETER_BLOCK WinLdrBlock,
  37                         IN PCH DllName,
  38                         OUT PLDR_DATA_TABLE_ENTRY *LoadedEntry);
  39
  40 // debug stuff
  41 VOID DumpMemoryAllocMap(VOID);
  42 VOID WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock);
  43 VOID WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock);
  44 VOID WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock);
  45
  46
  47 // Init "phase 0"
  48 VOID
  49 AllocateAndInitLPB(PLOADER_PARAMETER_BLOCK *OutLoaderBlock)
  50 {
  51         PLOADER_PARAMETER_BLOCK LoaderBlock;
  52
  53         /* Allocate and zero-init the LPB */
  54         LoaderBlock = MmHeapAlloc(sizeof(LOADER_PARAMETER_BLOCK));
  55         RtlZeroMemory(LoaderBlock, sizeof(LOADER_PARAMETER_BLOCK));
  56
  57         /* Init three critical lists, used right away */
  58         InitializeListHead(&LoaderBlock->LoadOrderListHead);
  59         InitializeListHead(&LoaderBlock->MemoryDescriptorListHead);
  60         InitializeListHead(&LoaderBlock->BootDriverListHead);
  61
  62         /* Alloc space for NLS (it will be converted to VA in WinLdrLoadNLS) */
  63         LoaderBlock->NlsData = MmHeapAlloc(sizeof(NLS_DATA_BLOCK));
  64         if (LoaderBlock->NlsData == NULL)
  65         {
  66                 UiMessageBox("Failed to allocate memory for NLS table data!");
  67                 return;
  68         }
  69         RtlZeroMemory(LoaderBlock->NlsData, sizeof(NLS_DATA_BLOCK));
  70
  71         *OutLoaderBlock = LoaderBlock;
  72 }
  73
  74 // Init "phase 1"
  75 VOID
  76 WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock,
  77                        PCHAR Options,
  78                        PCHAR SystemPath,
  79                        WORD VersionToBoot)
  80 {
  81         /* Examples of correct options and paths */
  82         //CHAR  Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
  83         //CHAR  Options[] = "/NODEBUG";
  84         //CHAR  SystemRoot[] = "\\WINNT\\";
  85         //CHAR  ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
  86
  87         CHAR    HalPath[] = "\\";
  88         CHAR    SystemRoot[256];
  89         CHAR    ArcBoot[256];
  90         ULONG i, PathSeparator;
  91         PLOADER_PARAMETER_EXTENSION Extension;
  92
  93         LoaderBlock->u.I386.CommonDataArea = NULL; // Force No ABIOS support
  94
  95         /* Construct SystemRoot and ArcBoot from SystemPath */
  96         PathSeparator = strstr(SystemPath, "\\") - SystemPath;
  97         strncpy(ArcBoot, SystemPath, PathSeparator);
  98         ArcBoot[PathSeparator] = 0;
  99         strcpy(SystemRoot, &SystemPath[PathSeparator]);
 100         strcat(SystemRoot, "\\");
 101
 102         DbgPrint((DPRINT_WINDOWS, "ArcBoot: %s\n", ArcBoot));
 103         DbgPrint((DPRINT_WINDOWS, "SystemRoot: %s\n", SystemRoot));
 104         DbgPrint((DPRINT_WINDOWS, "Options: %s\n", Options));
 105
 106         /* Fill Arc BootDevice */
 107         LoaderBlock->ArcBootDeviceName = MmHeapAlloc(strlen(ArcBoot)+1);
 108         strcpy(LoaderBlock->ArcBootDeviceName, ArcBoot);
 109         LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
 110
 111         /* Fill Arc HalDevice, it matches ArcBoot path */
 112         LoaderBlock->ArcHalDeviceName = MmHeapAlloc(strlen(ArcBoot)+1);
 113         strcpy(LoaderBlock->ArcHalDeviceName, ArcBoot);
 114         LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
 115
 116         /* Fill SystemRoot */
 117         LoaderBlock->NtBootPathName = MmHeapAlloc(strlen(SystemRoot)+1);
 118         strcpy(LoaderBlock->NtBootPathName, SystemRoot);
 119         LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
 120
 121         /* Fill NtHalPathName */
 122         LoaderBlock->NtHalPathName = MmHeapAlloc(strlen(HalPath)+1);
 123         strcpy(LoaderBlock->NtHalPathName, HalPath);
 124         LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
 125
 126         /* Fill load options */
 127         LoaderBlock->LoadOptions = MmHeapAlloc(strlen(Options)+1);
 128         strcpy(LoaderBlock->LoadOptions, Options);
 129         LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
 130
 131         /* Arc devices */
 132         LoaderBlock->ArcDiskInformation = (PARC_DISK_INFORMATION)MmHeapAlloc(sizeof(ARC_DISK_INFORMATION));
 133         InitializeListHead(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
 134
 135         /* Convert ARC disk information from freeldr to a correct format */
 136         for (i = 0; i < reactos_disk_count; i++)
 137         {
 138                 PARC_DISK_SIGNATURE ArcDiskInfo;
 139
 140                 /* Get the ARC structure */
 141                 ArcDiskInfo = (PARC_DISK_SIGNATURE)MmHeapAlloc(sizeof(ARC_DISK_SIGNATURE));
 142                 RtlZeroMemory(ArcDiskInfo, sizeof(ARC_DISK_SIGNATURE));
 143
 144                 /* Copy the data over */
 145                 ArcDiskInfo->Signature = reactos_arc_disk_info[i].Signature;
 146                 ArcDiskInfo->CheckSum = reactos_arc_disk_info[i].CheckSum;
 147
 148                 /* Copy the ARC Name */
 149                 ArcDiskInfo->ArcName = (PCHAR)MmHeapAlloc(sizeof(CHAR)*256);
 150                 strcpy(ArcDiskInfo->ArcName, reactos_arc_disk_info[i].ArcName);
 151                 ArcDiskInfo->ArcName = (PCHAR)PaToVa(ArcDiskInfo->ArcName);
 152
 153                 /* Mark partition table as valid */
 154                 ArcDiskInfo->ValidPartitionTable = TRUE;
 155
 156                 /* Insert into the list */
 157                 InsertTailList(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead,
 158                         &ArcDiskInfo->ListEntry);
 159         }
 160
 161         /* Convert all list's to Virtual address */
 162
 163         /* Convert the ArcDisks list to virtual address */
 164         List_PaToVa(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
 165         LoaderBlock->ArcDiskInformation = PaToVa(LoaderBlock->ArcDiskInformation);
 166
 167         /* Convert configuration entries to VA */
 168         ConvertConfigToVA(LoaderBlock->ConfigurationRoot);
 169         LoaderBlock->ConfigurationRoot = PaToVa(LoaderBlock->ConfigurationRoot);
 170
 171         /* Convert all DTE into virtual addresses */
 172         List_PaToVa(&LoaderBlock->LoadOrderListHead);
 173
 174         /* this one will be converted right before switching to
 175            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 = MmHeapAlloc(sizeof(LOADER_PARAMETER_EXTENSION));
 183         if (Extension == NULL)
 184         {
 185                 UiMessageBox("Failed to allocate LPB Extension!");
 186                 return;
 187         }
 188         RtlZeroMemory(Extension, sizeof(LOADER_PARAMETER_EXTENSION));
 189
 190         /* Fill LPB extension */
 191         Extension->Size = sizeof(LOADER_PARAMETER_EXTENSION);
 192         Extension->MajorVersion = (VersionToBoot & 0xFF00) >> 8;
 193         Extension->MinorVersion = VersionToBoot & 0xFF;
 194         Extension->Profile.Status = 2;
 195
 196         LoaderBlock->Extension = PaToVa(Extension);
 197 }
 198
 199 // Last step before going virtual
 200 void WinLdrSetupForNt(PLOADER_PARAMETER_BLOCK LoaderBlock,
 201                       PVOID *GdtIdt,
 202                       ULONG *PcrBasePage,
 203                       ULONG *TssBasePage)
 204 {
 205         ULONG TssSize;
 206         ULONG TssPages;
 207         ULONG_PTR Pcr = 0;
 208         ULONG_PTR Tss = 0;
 209         ULONG BlockSize, NumPages;
 210
 211         LoaderBlock->u.I386.CommonDataArea = NULL; //CommonDataArea;
 212         LoaderBlock->u.I386.MachineType = 0; // ntldr sets this to 0
 213
 214         /* Allocate 2 pages for PCR */
 215         Pcr = (ULONG_PTR)MmAllocateMemoryWithType(2 * MM_PAGE_SIZE, LoaderStartupPcrPage);
 216         *PcrBasePage = Pcr >> MM_PAGE_SHIFT;
 217
 218         if (Pcr == 0)
 219         {
 220                 UiMessageBox("Can't allocate PCR\n");
 221                 return;
 222         }
 223
 224         /* Allocate TSS */
 225         TssSize = (sizeof(KTSS) + MM_PAGE_SIZE) & ~(MM_PAGE_SIZE - 1);
 226         TssPages = TssSize / MM_PAGE_SIZE;
 227
 228         Tss = (ULONG_PTR)MmAllocateMemoryWithType(TssSize, LoaderMemoryData);
 229
 230         *TssBasePage = Tss >> MM_PAGE_SHIFT;
 231
 232         /* Allocate space for new GDT + IDT */
 233         BlockSize = NUM_GDT*sizeof(KGDTENTRY) + NUM_IDT*sizeof(KIDTENTRY);//FIXME: Use GDT/IDT limits here?
 234         NumPages = (BlockSize + MM_PAGE_SIZE - 1) >> MM_PAGE_SHIFT;
 235         *GdtIdt = (PKGDTENTRY)MmAllocateMemoryWithType(NumPages * MM_PAGE_SIZE, LoaderMemoryData);
 236
 237         if (*GdtIdt == NULL)
 238         {
 239                 UiMessageBox("Can't allocate pages for GDT+IDT!\n");
 240                 return;
 241         }
 242
 243         /* Zero newly prepared GDT+IDT */
 244         RtlZeroMemory(*GdtIdt, NumPages << MM_PAGE_SHIFT);
 245 }
 246
 247 BOOLEAN
 248 WinLdrLoadDeviceDriver(PLOADER_PARAMETER_BLOCK LoaderBlock,
 249                        LPSTR BootPath,
 250                        PUNICODE_STRING FilePath,
 251                        ULONG Flags,
 252                        PLDR_DATA_TABLE_ENTRY *DriverDTE)
 253 {
 254         CHAR FullPath[1024];
 255         CHAR DriverPath[1024];
 256         CHAR DllName[1024];
 257         PCHAR DriverNamePos;
 258         BOOLEAN Status;
 259         PVOID DriverBase;
 260
 261         // Separate the path to file name and directory path
 262         sprintf(DriverPath, "%S", FilePath->Buffer);
 263         DriverNamePos = strrchr(DriverPath, '\\');
 264         if (DriverNamePos != NULL)
 265         {
 266                 // Copy the name
 267                 strcpy(DllName, DriverNamePos+1);
 268
 269                 // Cut out the name from the path
 270                 *(DriverNamePos+1) = 0;
 271         }
 272
 273         DbgPrint((DPRINT_WINDOWS, "DriverPath: %s, DllName: %s, LPB %p\n", DriverPath, DllName, LoaderBlock));
 274
 275
 276         // Check if driver is already loaded
 277         Status = WinLdrCheckForLoadedDll(LoaderBlock, DllName, DriverDTE);
 278         if (Status)
 279         {
 280                 // We've got the pointer to its DTE, just return success
 281                 return TRUE;
 282         }
 283
 284         // It's not loaded, we have to load it
 285         sprintf(FullPath,"%s%S", BootPath, FilePath->Buffer);
 286         Status = WinLdrLoadImage(FullPath, LoaderBootDriver, &DriverBase);
 287         if (!Status)
 288                 return FALSE;
 289
 290         // Allocate a DTE for it
 291         Status = WinLdrAllocateDataTableEntry(LoaderBlock, DllName, DllName, DriverBase, DriverDTE);
 292         if (!Status)
 293         {
 294                 DbgPrint((DPRINT_WINDOWS, "WinLdrAllocateDataTableEntry() failed\n"));
 295                 return FALSE;
 296         }
 297
 298         // Modify any flags, if needed
 299         (*DriverDTE)->Flags |= Flags;
 300
 301         // Look for any dependencies it may have, and load them too
 302         sprintf(FullPath,"%s%s", BootPath, DriverPath);
 303         Status = WinLdrScanImportDescriptorTable(LoaderBlock, FullPath, *DriverDTE);
 304         if (!Status)
 305         {
 306                 DbgPrint((DPRINT_WINDOWS, "WinLdrScanImportDescriptorTable() failed for %s\n",
 307                         FullPath));
 308                 return FALSE;
 309         }
 310
 311         return TRUE;
 312 }
 313
 314 BOOLEAN
 315 WinLdrLoadBootDrivers(PLOADER_PARAMETER_BLOCK LoaderBlock,
 316                       LPSTR BootPath)
 317 {
 318         PLIST_ENTRY NextBd;
 319         PBOOT_DRIVER_LIST_ENTRY BootDriver;
 320         BOOLEAN Status;
 321
 322         // Walk through the boot drivers list
 323         NextBd = LoaderBlock->BootDriverListHead.Flink;
 324
 325         while (NextBd != &LoaderBlock->BootDriverListHead)
 326         {
 327                 BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, ListEntry);
 328
 329                 DbgPrint((DPRINT_WINDOWS, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
 330                         BootDriver->DataTableEntry, &BootDriver->RegistryPath));
 331
 332                 // Paths are relative (FIXME: Are they always relative?)
 333
 334                 // Load it
 335                 Status = WinLdrLoadDeviceDriver(LoaderBlock, BootPath, &BootDriver->FilePath,
 336                         0, &BootDriver->DataTableEntry);
 337
 338                 // If loading failed - cry loudly
 339                 //FIXME: Maybe remove it from the list and try to continue?
 340                 if (!Status)
 341                 {
 342                         UiMessageBox("Can't load boot driver!");
 343                         return FALSE;
 344                 }
 345
 346                 // Convert the RegistryPath and DTE addresses to VA since we are not going to use it anymore
 347                 BootDriver->RegistryPath.Buffer = PaToVa(BootDriver->RegistryPath.Buffer);
 348                 BootDriver->DataTableEntry = PaToVa(BootDriver->DataTableEntry);
 349
 350                 NextBd = BootDriver->ListEntry.Flink;
 351         }
 352
 353         return TRUE;
 354 }
 355
 356 VOID
 357 LoadAndBootWindows(PCSTR OperatingSystemName, WORD OperatingSystemVersion)
 358 {
 359         CHAR  MsgBuffer[256];
 360         CHAR  SystemPath[512], SearchPath[512];
 361         CHAR  FileName[512];
 362         CHAR  BootPath[512];
 363         CHAR  BootOptions[256];
 364         PVOID NtosBase = NULL, HalBase = NULL, KdComBase = NULL;
 365         BOOLEAN Status;
 366         ULONG SectionId;
 367         ULONG BootDevice;
 368         PLOADER_PARAMETER_BLOCK LoaderBlock, LoaderBlockVA;
 369         KERNEL_ENTRY_POINT KiSystemStartup;
 370         PLDR_DATA_TABLE_ENTRY KernelDTE, HalDTE, KdComDTE = NULL;
 371         // Mm-related things
 372         PVOID GdtIdt;
 373         ULONG PcrBasePage=0;
 374         ULONG TssBasePage=0;
 375
 376         //sprintf(MsgBuffer,"Booting Microsoft(R) Windows(R) OS version '%04x' is not implemented yet", OperatingSystemVersion);
 377         //UiMessageBox(MsgBuffer);
 378
 379         // Open the operating system section
 380         // specified in the .ini file
 381         if (!IniOpenSection(OperatingSystemName, &SectionId))
 382         {
 383                 sprintf(MsgBuffer,"Operating System section '%s' not found in freeldr.ini", OperatingSystemName);
 384                 UiMessageBox(MsgBuffer);
 385                 return;
 386         }
 387
 388         UiDrawBackdrop();
 389         UiDrawStatusText("Detecting Hardware...");
 390         UiDrawProgressBarCenter(1, 100, "Loading Windows...");
 391
 392         /* Make sure the system path is set in the .ini file */
 393         if (!IniReadSettingByName(SectionId, "SystemPath", SystemPath, sizeof(SystemPath)))
 394         {
 395                 UiMessageBox("System path not specified for selected operating system.");
 396                 return;
 397         }
 398
 399         /* Read booting options */
 400         if (!IniReadSettingByName(SectionId, "Options", BootOptions, sizeof(BootOptions)))
 401         {
 402                 /* Nothing read, make the string empty */
 403                 strcpy(BootOptions, "");
 404         }
 405
 406         /* Normalize system path */
 407         if (!MachDiskNormalizeSystemPath(SystemPath, sizeof(SystemPath)))
 408         {
 409                 UiMessageBox("Invalid system path");
 410                 return;
 411         }
 412
 413         /* Let user know we started loading */
 414         UiDrawStatusText("Loading...");
 415
 416         /* Try to open system drive */
 417         BootDevice = 0xffffffff;
 418         if (!FsOpenSystemVolume(SystemPath, BootPath, &BootDevice))
 419         {
 420                 UiMessageBox("Failed to open boot drive.");
 421                 return;
 422         }
 423
 424         /* append a backslash */
 425         if ((strlen(BootPath)==0) ||
 426             BootPath[strlen(BootPath)] != '\\')
 427                 strcat(BootPath, "\\");
 428
 429         DbgPrint((DPRINT_WINDOWS,"SystemRoot: '%s'\n", BootPath));
 430
 431         /* Allocate and minimalistic-initialize LPB */
 432         AllocateAndInitLPB(&LoaderBlock);
 433
 434         /* Detect hardware */
 435         UseRealHeap = TRUE;
 436         LoaderBlock->ConfigurationRoot = MachHwDetect();
 437
 438         /* Load kernel */
 439         strcpy(FileName, BootPath);
 440         strcat(FileName, "SYSTEM32\\NTOSKRNL.EXE");
 441         Status = WinLdrLoadImage(FileName, LoaderSystemCode, &NtosBase);
 442         DbgPrint((DPRINT_WINDOWS, "Ntos loaded with status %d at %p\n", Status, NtosBase));
 443
 444         /* Load HAL */
 445         strcpy(FileName, BootPath);
 446         strcat(FileName, "SYSTEM32\\HAL.DLL");
 447         Status = WinLdrLoadImage(FileName, LoaderHalCode, &HalBase);
 448         DbgPrint((DPRINT_WINDOWS, "HAL loaded with status %d at %p\n", Status, HalBase));
 449
 450         /* Load kernel-debugger support dll */
 451         if (OperatingSystemVersion > _WIN32_WINNT_WIN2K)
 452         {
 453                 strcpy(FileName, BootPath);
 454                 strcat(FileName, "SYSTEM32\\KDCOM.DLL");
 455                 Status = WinLdrLoadImage(FileName, LoaderBootDriver, &KdComBase);
 456                 DbgPrint((DPRINT_WINDOWS, "KdCom loaded with status %d at %p\n", Status, KdComBase));
 457         }
 458
 459         /* Allocate data table entries for above-loaded modules */
 460         WinLdrAllocateDataTableEntry(LoaderBlock, "ntoskrnl.exe",
 461                 "WINDOWS\\SYSTEM32\\NTOSKRNL.EXE", NtosBase, &KernelDTE);
 462         WinLdrAllocateDataTableEntry(LoaderBlock, "hal.dll",
 463                 "WINDOWS\\SYSTEM32\\HAL.DLL", HalBase, &HalDTE);
 464         if (OperatingSystemVersion > _WIN32_WINNT_WIN2K)
 465         {
 466                 WinLdrAllocateDataTableEntry(LoaderBlock, "kdcom.dll",
 467                         "WINDOWS\\SYSTEM32\\KDCOM.DLL", KdComBase, &KdComDTE);
 468         }
 469
 470         /* Load all referenced DLLs for kernel, HAL and kdcom.dll */
 471         strcpy(SearchPath, BootPath);
 472         strcat(SearchPath, "SYSTEM32\\");
 473         WinLdrScanImportDescriptorTable(LoaderBlock, SearchPath, KernelDTE);
 474         WinLdrScanImportDescriptorTable(LoaderBlock, SearchPath, HalDTE);
 475         if (KdComDTE)
 476                 WinLdrScanImportDescriptorTable(LoaderBlock, SearchPath, KdComDTE);
 477
 478         /* Load Hive, and then NLS data, OEM font, and prepare boot drivers list */
 479         Status = WinLdrLoadAndScanSystemHive(LoaderBlock, BootPath);
 480         DbgPrint((DPRINT_WINDOWS, "SYSTEM hive loaded and scanned with status %d\n", Status));
 481
 482         /* Load boot drivers */
 483         Status = WinLdrLoadBootDrivers(LoaderBlock, BootPath);
 484         DbgPrint((DPRINT_WINDOWS, "Boot drivers loaded with status %d\n", Status));
 485
 486         /* Alloc PCR, TSS, do magic things with the GDT/IDT */
 487         WinLdrSetupForNt(LoaderBlock, &GdtIdt, &PcrBasePage, &TssBasePage);
 488
 489         /* Initialize Phase 1 - no drivers loading anymore */
 490         WinLdrInitializePhase1(LoaderBlock, BootOptions, SystemPath, OperatingSystemVersion);
 491
 492         /* Save entry-point pointer and Loader block VAs */
 493         KiSystemStartup = (KERNEL_ENTRY_POINT)KernelDTE->EntryPoint;
 494         LoaderBlockVA = PaToVa(LoaderBlock);
 495
 496         /* "Stop all motors", change videomode */
 497         DiskStopFloppyMotor();
 498         if (OperatingSystemVersion < _WIN32_WINNT_WIN2K)
 499                 MachVideoPrepareForReactOS(TRUE);
 500         else
 501                 MachVideoPrepareForReactOS(FALSE);
 502
 503         /* Debugging... */
 504         //DumpMemoryAllocMap();
 505
 506         /* Turn on paging mode of CPU*/
 507         WinLdrTurnOnPaging(LoaderBlock, PcrBasePage, TssBasePage, GdtIdt);
 508
 509         /* Save final value of LoaderPagesSpanned */
 510         LoaderBlock->Extension->LoaderPagesSpanned = LoaderPagesSpanned;
 511
 512         DbgPrint((DPRINT_WINDOWS, "Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
 513                 KiSystemStartup, LoaderBlockVA));
 514
 515         WinLdrpDumpMemoryDescriptors(LoaderBlockVA);
 516         WinLdrpDumpBootDriver(LoaderBlockVA);
 517         WinLdrpDumpArcDisks(LoaderBlockVA);
 518
 519         //FIXME: If I substitute this debugging checkpoint, GCC will "optimize away" the code below
 520         //while (1) {};
 521         /*asm(".intel_syntax noprefix\n");
 522                 asm("test1:\n");
 523                 asm("jmp test1\n");
 524         asm(".att_syntax\n");*/
 525
 526         /* Pass control */
 527         (*KiSystemStartup)(LoaderBlockVA);
 528
 529         return;
 530 }
 531
 532 VOID
 533 WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock)
 534 {
 535         PLIST_ENTRY NextMd;
 536         PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
 537
 538         NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
 539
 540         while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
 541         {
 542                 MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry);
 543
 544                 DbgPrint((DPRINT_WINDOWS, "BP %08X PC %04X MT %d\n", MemoryDescriptor->BasePage,
 545                         MemoryDescriptor->PageCount, MemoryDescriptor->MemoryType));
 546
 547                 NextMd = MemoryDescriptor->ListEntry.Flink;
 548         }
 549 }
 550
 551 VOID
 552 WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock)
 553 {
 554         PLIST_ENTRY NextBd;
 555         PBOOT_DRIVER_LIST_ENTRY BootDriver;
 556
 557         NextBd = LoaderBlock->BootDriverListHead.Flink;
 558
 559         while (NextBd != &LoaderBlock->BootDriverListHead)
 560         {
 561                 BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, ListEntry);
 562
 563                 DbgPrint((DPRINT_WINDOWS, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
 564                         BootDriver->DataTableEntry, &BootDriver->RegistryPath));
 565
 566                 NextBd = BootDriver->ListEntry.Flink;
 567         }
 568 }
 569
 570 VOID
 571 WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock)
 572 {
 573         PLIST_ENTRY NextBd;
 574         PARC_DISK_SIGNATURE ArcDisk;
 575
 576         NextBd = LoaderBlock->ArcDiskInformation->DiskSignatureListHead.Flink;
 577
 578         while (NextBd != &LoaderBlock->ArcDiskInformation->DiskSignatureListHead)
 579         {
 580                 ArcDisk = CONTAINING_RECORD(NextBd, ARC_DISK_SIGNATURE, ListEntry);
 581
 582                 DbgPrint((DPRINT_WINDOWS, "ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
 583                         ArcDisk->ArcName, ArcDisk->CheckSum, ArcDisk->Signature));
 584
 585                 NextBd = ArcDisk->ListEntry.Flink;
 586         }
 587 }
 588
 589