- Merge from trunk up to r45543
[reactos.git] / 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 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
24 #include <ndk/ldrtypes.h>
25 #include <debug.h>
26
27 // TODO: Move to .h
28 void WinLdrSetupForNt(PLOADER_PARAMETER_BLOCK LoaderBlock,
29 PVOID *GdtIdt,
30 ULONG *PcrBasePage,
31 ULONG *TssBasePage);
32
33 //FIXME: Do a better way to retrieve Arc disk information
34 extern ULONG reactos_disk_count;
35 extern ARC_DISK_SIGNATURE reactos_arc_disk_info[];
36 extern char reactos_arc_strings[32][256];
37
38 extern BOOLEAN UseRealHeap;
39 extern ULONG LoaderPagesSpanned;
40
41 BOOLEAN
42 WinLdrCheckForLoadedDll(IN OUT PLOADER_PARAMETER_BLOCK WinLdrBlock,
43 IN PCH DllName,
44 OUT PLDR_DATA_TABLE_ENTRY *LoadedEntry);
45
46 // debug stuff
47 VOID DumpMemoryAllocMap(VOID);
48 VOID WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock);
49 VOID WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock);
50 VOID WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock);
51
52
53 // Init "phase 0"
54 VOID
55 AllocateAndInitLPB(PLOADER_PARAMETER_BLOCK *OutLoaderBlock)
56 {
57 PLOADER_PARAMETER_BLOCK LoaderBlock;
58
59 /* Allocate and zero-init the LPB */
60 LoaderBlock = MmHeapAlloc(sizeof(LOADER_PARAMETER_BLOCK));
61 RtlZeroMemory(LoaderBlock, sizeof(LOADER_PARAMETER_BLOCK));
62
63 /* Init three critical lists, used right away */
64 InitializeListHead(&LoaderBlock->LoadOrderListHead);
65 InitializeListHead(&LoaderBlock->MemoryDescriptorListHead);
66 InitializeListHead(&LoaderBlock->BootDriverListHead);
67
68 /* Alloc space for NLS (it will be converted to VA in WinLdrLoadNLS) */
69 LoaderBlock->NlsData = MmHeapAlloc(sizeof(NLS_DATA_BLOCK));
70 if (LoaderBlock->NlsData == NULL)
71 {
72 UiMessageBox("Failed to allocate memory for NLS table data!");
73 return;
74 }
75 RtlZeroMemory(LoaderBlock->NlsData, sizeof(NLS_DATA_BLOCK));
76
77 *OutLoaderBlock = LoaderBlock;
78 }
79
80 // Init "phase 1"
81 VOID
82 WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock,
83 PCHAR Options,
84 PCHAR SystemRoot,
85 PCHAR BootPath,
86 USHORT VersionToBoot)
87 {
88 /* Examples of correct options and paths */
89 //CHAR Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
90 //CHAR Options[] = "/NODEBUG";
91 //CHAR SystemRoot[] = "\\WINNT\\";
92 //CHAR ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
93
94 CHAR HalPath[] = "\\";
95 CHAR ArcBoot[256];
96 CHAR MiscFiles[256];
97 ULONG i, PathSeparator;
98 PLOADER_PARAMETER_EXTENSION Extension;
99
100 /* Construct SystemRoot and ArcBoot from SystemPath */
101 PathSeparator = strstr(BootPath, "\\") - BootPath;
102 strncpy(ArcBoot, BootPath, PathSeparator);
103 ArcBoot[PathSeparator] = 0;
104
105 DPRINTM(DPRINT_WINDOWS, "ArcBoot: %s\n", ArcBoot);
106 DPRINTM(DPRINT_WINDOWS, "SystemRoot: %s\n", SystemRoot);
107 DPRINTM(DPRINT_WINDOWS, "Options: %s\n", Options);
108
109 /* Fill Arc BootDevice */
110 LoaderBlock->ArcBootDeviceName = MmHeapAlloc(strlen(ArcBoot)+1);
111 strcpy(LoaderBlock->ArcBootDeviceName, ArcBoot);
112 LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
113
114 /* Fill Arc HalDevice, it matches ArcBoot path */
115 LoaderBlock->ArcHalDeviceName = MmHeapAlloc(strlen(ArcBoot)+1);
116 strcpy(LoaderBlock->ArcHalDeviceName, ArcBoot);
117 LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
118
119 /* Fill SystemRoot */
120 LoaderBlock->NtBootPathName = MmHeapAlloc(strlen(SystemRoot)+1);
121 strcpy(LoaderBlock->NtBootPathName, SystemRoot);
122 LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
123
124 /* Fill NtHalPathName */
125 LoaderBlock->NtHalPathName = MmHeapAlloc(strlen(HalPath)+1);
126 strcpy(LoaderBlock->NtHalPathName, HalPath);
127 LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
128
129 /* Fill load options */
130 LoaderBlock->LoadOptions = MmHeapAlloc(strlen(Options)+1);
131 strcpy(LoaderBlock->LoadOptions, Options);
132 LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
133
134 /* Arc devices */
135 LoaderBlock->ArcDiskInformation = (PARC_DISK_INFORMATION)MmHeapAlloc(sizeof(ARC_DISK_INFORMATION));
136 InitializeListHead(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
137
138 /* Convert ARC disk information from freeldr to a correct format */
139 for (i = 0; i < reactos_disk_count; i++)
140 {
141 PARC_DISK_SIGNATURE ArcDiskInfo;
142
143 /* Get the ARC structure */
144 ArcDiskInfo = (PARC_DISK_SIGNATURE)MmHeapAlloc(sizeof(ARC_DISK_SIGNATURE));
145 RtlZeroMemory(ArcDiskInfo, sizeof(ARC_DISK_SIGNATURE));
146
147 /* Copy the data over */
148 ArcDiskInfo->Signature = reactos_arc_disk_info[i].Signature;
149 ArcDiskInfo->CheckSum = reactos_arc_disk_info[i].CheckSum;
150
151 /* Copy the ARC Name */
152 ArcDiskInfo->ArcName = (PCHAR)MmHeapAlloc(sizeof(CHAR)*256);
153 strcpy(ArcDiskInfo->ArcName, reactos_arc_disk_info[i].ArcName);
154 ArcDiskInfo->ArcName = (PCHAR)PaToVa(ArcDiskInfo->ArcName);
155
156 /* Mark partition table as valid */
157 ArcDiskInfo->ValidPartitionTable = TRUE;
158
159 /* Insert into the list */
160 InsertTailList(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead,
161 &ArcDiskInfo->ListEntry);
162 }
163
164 /* Convert all list's to Virtual address */
165
166 /* Convert the ArcDisks list to virtual address */
167 List_PaToVa(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
168 LoaderBlock->ArcDiskInformation = PaToVa(LoaderBlock->ArcDiskInformation);
169
170 /* Convert configuration entries to VA */
171 ConvertConfigToVA(LoaderBlock->ConfigurationRoot);
172 LoaderBlock->ConfigurationRoot = PaToVa(LoaderBlock->ConfigurationRoot);
173
174 /* Convert all DTE into virtual addresses */
175 List_PaToVa(&LoaderBlock->LoadOrderListHead);
176
177 /* this one will be converted right before switching to
178 virtual paging mode */
179 //List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
180
181 /* Convert list of boot drivers */
182 List_PaToVa(&LoaderBlock->BootDriverListHead);
183
184 /* Initialize Extension now */
185 Extension = MmHeapAlloc(sizeof(LOADER_PARAMETER_EXTENSION));
186 if (Extension == NULL)
187 {
188 UiMessageBox("Failed to allocate LPB Extension!");
189 return;
190 }
191 RtlZeroMemory(Extension, sizeof(LOADER_PARAMETER_EXTENSION));
192
193 /* Fill LPB extension */
194 Extension->Size = sizeof(LOADER_PARAMETER_EXTENSION);
195 Extension->MajorVersion = (VersionToBoot & 0xFF00) >> 8;
196 Extension->MinorVersion = VersionToBoot & 0xFF;
197 Extension->Profile.Status = 2;
198
199 /* Load drivers database */
200 strcpy(MiscFiles, BootPath);
201 strcat(MiscFiles, "AppPatch\\drvmain.sdb");
202 Extension->DrvDBImage = PaToVa(WinLdrLoadModule(MiscFiles,
203 &Extension->DrvDBSize, LoaderRegistryData));
204
205 /* Convert extension and setup block pointers */
206 LoaderBlock->Extension = PaToVa(Extension);
207
208 if (LoaderBlock->SetupLdrBlock)
209 LoaderBlock->SetupLdrBlock = PaToVa(LoaderBlock->SetupLdrBlock);
210 }
211
212 BOOLEAN
213 WinLdrLoadDeviceDriver(PLOADER_PARAMETER_BLOCK LoaderBlock,
214 LPSTR BootPath,
215 PUNICODE_STRING FilePath,
216 ULONG Flags,
217 PLDR_DATA_TABLE_ENTRY *DriverDTE)
218 {
219 CHAR FullPath[1024];
220 CHAR DriverPath[1024];
221 CHAR DllName[1024];
222 PCHAR DriverNamePos;
223 BOOLEAN Status;
224 PVOID DriverBase;
225
226 // Separate the path to file name and directory path
227 sprintf(DriverPath, "%S", FilePath->Buffer);
228 DriverNamePos = strrchr(DriverPath, '\\');
229 if (DriverNamePos != NULL)
230 {
231 // Copy the name
232 strcpy(DllName, DriverNamePos+1);
233
234 // Cut out the name from the path
235 *(DriverNamePos+1) = 0;
236 }
237 else
238 {
239 // There is no directory in the path
240 strcpy(DllName, DriverPath);
241 DriverPath[0] = 0;
242 }
243
244 DPRINTM(DPRINT_WINDOWS, "DriverPath: %s, DllName: %s, LPB %p\n", DriverPath, DllName, LoaderBlock);
245
246
247 // Check if driver is already loaded
248 Status = WinLdrCheckForLoadedDll(LoaderBlock, DllName, DriverDTE);
249 if (Status)
250 {
251 // We've got the pointer to its DTE, just return success
252 return TRUE;
253 }
254
255 // It's not loaded, we have to load it
256 sprintf(FullPath,"%s%S", BootPath, FilePath->Buffer);
257 Status = WinLdrLoadImage(FullPath, LoaderBootDriver, &DriverBase);
258 if (!Status)
259 return FALSE;
260
261 // Allocate a DTE for it
262 Status = WinLdrAllocateDataTableEntry(LoaderBlock, DllName, DllName, DriverBase, DriverDTE);
263 if (!Status)
264 {
265 DPRINTM(DPRINT_WINDOWS, "WinLdrAllocateDataTableEntry() failed\n");
266 return FALSE;
267 }
268
269 // Modify any flags, if needed
270 (*DriverDTE)->Flags |= Flags;
271
272 // Look for any dependencies it may have, and load them too
273 sprintf(FullPath,"%s%s", BootPath, DriverPath);
274 Status = WinLdrScanImportDescriptorTable(LoaderBlock, FullPath, *DriverDTE);
275 if (!Status)
276 {
277 DPRINTM(DPRINT_WINDOWS, "WinLdrScanImportDescriptorTable() failed for %s\n",
278 FullPath);
279 return FALSE;
280 }
281
282 return TRUE;
283 }
284
285 BOOLEAN
286 WinLdrLoadBootDrivers(PLOADER_PARAMETER_BLOCK LoaderBlock,
287 LPSTR BootPath)
288 {
289 PLIST_ENTRY NextBd;
290 PBOOT_DRIVER_LIST_ENTRY BootDriver;
291 BOOLEAN Status;
292
293 // Walk through the boot drivers list
294 NextBd = LoaderBlock->BootDriverListHead.Flink;
295
296 while (NextBd != &LoaderBlock->BootDriverListHead)
297 {
298 BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
299
300 DPRINTM(DPRINT_WINDOWS, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
301 BootDriver->LdrEntry, &BootDriver->RegistryPath);
302
303 // Paths are relative (FIXME: Are they always relative?)
304
305 // Load it
306 Status = WinLdrLoadDeviceDriver(LoaderBlock, BootPath, &BootDriver->FilePath,
307 0, &BootDriver->LdrEntry);
308
309 // If loading failed - cry loudly
310 //FIXME: Maybe remove it from the list and try to continue?
311 if (!Status)
312 {
313 UiMessageBox("Can't load boot driver!");
314 return FALSE;
315 }
316
317 // Convert the RegistryPath and DTE addresses to VA since we are not going to use it anymore
318 BootDriver->RegistryPath.Buffer = PaToVa(BootDriver->RegistryPath.Buffer);
319 BootDriver->FilePath.Buffer = PaToVa(BootDriver->FilePath.Buffer);
320 BootDriver->LdrEntry = PaToVa(BootDriver->LdrEntry);
321
322 NextBd = BootDriver->Link.Flink;
323 }
324
325 return TRUE;
326 }
327
328 PVOID WinLdrLoadModule(PCSTR ModuleName, ULONG *Size,
329 TYPE_OF_MEMORY MemoryType)
330 {
331 ULONG FileId;
332 PVOID PhysicalBase;
333 FILEINFORMATION FileInfo;
334 ULONG FileSize;
335 ULONG Status;
336 ULONG BytesRead;
337
338 //CHAR ProgressString[256];
339
340 /* Inform user we are loading files */
341 //sprintf(ProgressString, "Loading %s...", FileName);
342 //UiDrawProgressBarCenter(1, 100, ProgressString);
343
344 DPRINTM(DPRINT_WINDOWS, "Loading module %s\n", ModuleName);
345 *Size = 0;
346
347 /* Open the image file */
348 Status = ArcOpen((PCHAR)ModuleName, OpenReadOnly, &FileId);
349 if (Status != ESUCCESS)
350 {
351 /* In case of errors, we just return, without complaining to the user */
352 return NULL;
353 }
354
355 /* Get this file's size */
356 Status = ArcGetFileInformation(FileId, &FileInfo);
357 if (Status != ESUCCESS)
358 {
359 ArcClose(FileId);
360 return NULL;
361 }
362 FileSize = FileInfo.EndingAddress.LowPart;
363 *Size = FileSize;
364
365 /* Allocate memory */
366 PhysicalBase = MmAllocateMemoryWithType(FileSize, MemoryType);
367 if (PhysicalBase == NULL)
368 {
369 ArcClose(FileId);
370 return NULL;
371 }
372
373 /* Load whole file */
374 Status = ArcRead(FileId, PhysicalBase, FileSize, &BytesRead);
375 ArcClose(FileId);
376 if (Status != ESUCCESS)
377 {
378 return NULL;
379 }
380
381 DPRINTM(DPRINT_WINDOWS, "Loaded %s at 0x%x with size 0x%x\n", ModuleName, PhysicalBase, FileSize);
382
383 return PhysicalBase;
384 }
385
386
387 USHORT
388 WinLdrDetectVersion()
389 {
390 LONG rc;
391 FRLDRHKEY hKey;
392
393 rc = RegOpenKey(
394 NULL,
395 L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server",
396 &hKey);
397 if (rc != ERROR_SUCCESS)
398 {
399 // Key doesn't exist; assume NT 4.0
400 return _WIN32_WINNT_NT4;
401 }
402
403 // We may here want to read the value of ProductVersion
404 return _WIN32_WINNT_WS03;
405 }
406
407
408 VOID
409 LoadAndBootWindows(PCSTR OperatingSystemName,
410 PSTR SettingsValue,
411 USHORT OperatingSystemVersion)
412 {
413 BOOLEAN HasSection;
414 char FullPath[MAX_PATH], SystemRoot[MAX_PATH], BootPath[MAX_PATH];
415 CHAR FileName[MAX_PATH];
416 CHAR BootOptions[256];
417 PCHAR File;
418 PCHAR PathSeparator;
419 PVOID NtosBase = NULL, HalBase = NULL, KdComBase = NULL;
420 BOOLEAN Status;
421 ULONG_PTR SectionId;
422 PLOADER_PARAMETER_BLOCK LoaderBlock, LoaderBlockVA;
423 KERNEL_ENTRY_POINT KiSystemStartup;
424 PLDR_DATA_TABLE_ENTRY KernelDTE, HalDTE, KdComDTE = NULL;
425 // Mm-related things
426 PVOID GdtIdt;
427 ULONG PcrBasePage=0;
428 ULONG TssBasePage=0;
429
430 // Open the operating system section
431 // specified in the .ini file
432 HasSection = IniOpenSection(OperatingSystemName, &SectionId);
433
434 UiDrawBackdrop();
435 UiDrawStatusText("Detecting Hardware...");
436 UiDrawProgressBarCenter(1, 100, "Loading NT...");
437
438 /* Read the system path is set in the .ini file */
439 if (!HasSection || !IniReadSettingByName(SectionId, "SystemPath", FullPath, sizeof(FullPath)))
440 {
441 strcpy(FullPath, OperatingSystemName);
442 }
443
444 /* Special case for LiveCD */
445 if (!_strnicmp(FullPath, "LiveCD", strlen("LiveCD")))
446 {
447 strcpy(BootPath, FullPath + strlen("LiveCD"));
448 MachDiskGetBootPath(FullPath, sizeof(FullPath));
449 strcat(FullPath, BootPath);
450 }
451
452 /* Convert FullPath to SystemRoot */
453 PathSeparator = strstr(FullPath, "\\");
454 strcpy(SystemRoot, PathSeparator);
455 strcat(SystemRoot, "\\");
456
457 /* Read booting options */
458 if (!HasSection || !IniReadSettingByName(SectionId, "Options", BootOptions, sizeof(BootOptions)))
459 {
460 /* Get options after the title */
461 const CHAR*p = SettingsValue;
462 while (*p == ' ' || *p == '"')
463 p++;
464 while (*p != '\0' && *p != '"')
465 p++;
466 strcpy(BootOptions, p);
467 DPRINTM(DPRINT_WINDOWS,"BootOptions: '%s'\n", BootOptions);
468 }
469
470 //
471 // Check if a ramdisk file was given
472 //
473 File = strstr(BootOptions, "/RDPATH=");
474 if (File)
475 {
476 //
477 // Copy the file name and everything else after it
478 //
479 strcpy(FileName, File + 8);
480
481 //
482 // Null-terminate
483 //
484 *strstr(FileName, " ") = ANSI_NULL;
485
486 //
487 // Load the ramdisk
488 //
489 RamDiskLoadVirtualFile(FileName);
490 }
491
492 /* Let user know we started loading */
493 UiDrawStatusText("Loading...");
494
495 /* append a backslash */
496 strcpy(BootPath, FullPath);
497 if ((strlen(BootPath)==0) ||
498 BootPath[strlen(BootPath)] != '\\')
499 strcat(BootPath, "\\");
500
501 DPRINTM(DPRINT_WINDOWS,"BootPath: '%s'\n", BootPath);
502
503 /* Allocate and minimalistic-initialize LPB */
504 AllocateAndInitLPB(&LoaderBlock);
505
506 /* Detect hardware */
507 UseRealHeap = TRUE;
508 LoaderBlock->ConfigurationRoot = MachHwDetect();
509
510 /* Load Hive */
511 Status = WinLdrInitSystemHive(LoaderBlock, BootPath);
512 DPRINTM(DPRINT_WINDOWS, "SYSTEM hive loaded with status %d\n", Status);
513
514 if (OperatingSystemVersion == 0)
515 OperatingSystemVersion = WinLdrDetectVersion();
516
517 /* Load kernel */
518 strcpy(FileName, BootPath);
519 strcat(FileName, "SYSTEM32\\NTOSKRNL.EXE");
520 Status = WinLdrLoadImage(FileName, LoaderSystemCode, &NtosBase);
521 DPRINTM(DPRINT_WINDOWS, "Ntos loaded with status %d at %p\n", Status, NtosBase);
522
523 /* Load HAL */
524 strcpy(FileName, BootPath);
525 strcat(FileName, "SYSTEM32\\HAL.DLL");
526 Status = WinLdrLoadImage(FileName, LoaderHalCode, &HalBase);
527 DPRINTM(DPRINT_WINDOWS, "HAL loaded with status %d at %p\n", Status, HalBase);
528
529 /* Load kernel-debugger support dll */
530 if (OperatingSystemVersion > _WIN32_WINNT_WIN2K)
531 {
532 strcpy(FileName, BootPath);
533 strcat(FileName, "SYSTEM32\\KDCOM.DLL");
534 Status = WinLdrLoadImage(FileName, LoaderBootDriver, &KdComBase);
535 DPRINTM(DPRINT_WINDOWS, "KdCom loaded with status %d at %p\n", Status, KdComBase);
536 }
537
538 /* Allocate data table entries for above-loaded modules */
539 WinLdrAllocateDataTableEntry(LoaderBlock, "ntoskrnl.exe",
540 "WINDOWS\\SYSTEM32\\NTOSKRNL.EXE", NtosBase, &KernelDTE);
541 WinLdrAllocateDataTableEntry(LoaderBlock, "hal.dll",
542 "WINDOWS\\SYSTEM32\\HAL.DLL", HalBase, &HalDTE);
543 if (OperatingSystemVersion > _WIN32_WINNT_WIN2K)
544 {
545 WinLdrAllocateDataTableEntry(LoaderBlock, "kdcom.dll",
546 "WINDOWS\\SYSTEM32\\KDCOM.DLL", KdComBase, &KdComDTE);
547 }
548
549 /* Load all referenced DLLs for kernel, HAL and kdcom.dll */
550 strcpy(FileName, BootPath);
551 strcat(FileName, "SYSTEM32\\");
552 WinLdrScanImportDescriptorTable(LoaderBlock, FileName, KernelDTE);
553 WinLdrScanImportDescriptorTable(LoaderBlock, FileName, HalDTE);
554 if (KdComDTE)
555 WinLdrScanImportDescriptorTable(LoaderBlock, FileName, KdComDTE);
556
557 /* Load NLS data, OEM font, and prepare boot drivers list */
558 Status = WinLdrScanSystemHive(LoaderBlock, BootPath);
559 DPRINTM(DPRINT_WINDOWS, "SYSTEM hive scanned with status %d\n", Status);
560
561 /* Load boot drivers */
562 Status = WinLdrLoadBootDrivers(LoaderBlock, BootPath);
563 DPRINTM(DPRINT_WINDOWS, "Boot drivers loaded with status %d\n", Status);
564
565 /* Alloc PCR, TSS, do magic things with the GDT/IDT */
566 WinLdrSetupForNt(LoaderBlock, &GdtIdt, &PcrBasePage, &TssBasePage);
567
568 /* Initialize Phase 1 - no drivers loading anymore */
569 WinLdrInitializePhase1(LoaderBlock, BootOptions, SystemRoot, BootPath, OperatingSystemVersion);
570
571 /* Save entry-point pointer and Loader block VAs */
572 KiSystemStartup = (KERNEL_ENTRY_POINT)KernelDTE->EntryPoint;
573 LoaderBlockVA = PaToVa(LoaderBlock);
574
575 /* "Stop all motors", change videomode */
576 if (OperatingSystemVersion < _WIN32_WINNT_WIN2K)
577 MachPrepareForReactOS(TRUE);
578 else
579 MachPrepareForReactOS(FALSE);
580
581 /* Debugging... */
582 //DumpMemoryAllocMap();
583
584 /* Turn on paging mode of CPU*/
585 WinLdrTurnOnPaging(LoaderBlock, PcrBasePage, TssBasePage, GdtIdt);
586
587 /* Save final value of LoaderPagesSpanned */
588 LoaderBlockVA->Extension->LoaderPagesSpanned = LoaderPagesSpanned;
589
590 DPRINTM(DPRINT_WINDOWS, "Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
591 KiSystemStartup, LoaderBlockVA);
592
593 WinLdrpDumpMemoryDescriptors(LoaderBlockVA);
594 WinLdrpDumpBootDriver(LoaderBlockVA);
595 WinLdrpDumpArcDisks(LoaderBlockVA);
596
597 //FIXME: If I substitute this debugging checkpoint, GCC will "optimize away" the code below
598 //while (1) {};
599 /*asm(".intel_syntax noprefix\n");
600 asm("test1:\n");
601 asm("jmp test1\n");
602 asm(".att_syntax\n");*/
603
604 /* Pass control */
605 (*KiSystemStartup)(LoaderBlockVA);
606
607 return;
608 }
609
610 VOID
611 WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock)
612 {
613 PLIST_ENTRY NextMd;
614 PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
615
616 NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
617
618 while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
619 {
620 MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry);
621
622 DPRINTM(DPRINT_WINDOWS, "BP %08X PC %04X MT %d\n", MemoryDescriptor->BasePage,
623 MemoryDescriptor->PageCount, MemoryDescriptor->MemoryType);
624
625 NextMd = MemoryDescriptor->ListEntry.Flink;
626 }
627 }
628
629 VOID
630 WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock)
631 {
632 PLIST_ENTRY NextBd;
633 PBOOT_DRIVER_LIST_ENTRY BootDriver;
634
635 NextBd = LoaderBlock->BootDriverListHead.Flink;
636
637 while (NextBd != &LoaderBlock->BootDriverListHead)
638 {
639 BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
640
641 DPRINTM(DPRINT_WINDOWS, "BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
642 BootDriver->LdrEntry, &BootDriver->RegistryPath);
643
644 NextBd = BootDriver->Link.Flink;
645 }
646 }
647
648 VOID
649 WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock)
650 {
651 PLIST_ENTRY NextBd;
652 PARC_DISK_SIGNATURE ArcDisk;
653
654 NextBd = LoaderBlock->ArcDiskInformation->DiskSignatureListHead.Flink;
655
656 while (NextBd != &LoaderBlock->ArcDiskInformation->DiskSignatureListHead)
657 {
658 ArcDisk = CONTAINING_RECORD(NextBd, ARC_DISK_SIGNATURE, ListEntry);
659
660 DPRINTM(DPRINT_WINDOWS, "ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
661 ArcDisk->ArcName, ArcDisk->CheckSum, ArcDisk->Signature);
662
663 NextBd = ArcDisk->ListEntry.Flink;
664 }
665 }
666
667