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