ReactOS  0.4.13-dev-99-g7e18b6d
winldr.c
Go to the documentation of this file.
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 "winldr.h"
24 #include "registry.h"
25 
26 #include <ndk/ldrtypes.h>
27 
28 #include <debug.h>
29 DBG_DEFAULT_CHANNEL(WINDOWS);
30 
31 // FIXME: Find a better way to retrieve ARC disk information
34 
36 extern BOOLEAN AcpiPresent;
37 
40 extern void WinLdrSetupEms(IN PCHAR BootOptions);
41 
43 
44 // debug stuff
46 
47 // Init "phase 0"
48 VOID
50 {
51  PLOADER_PARAMETER_BLOCK LoaderBlock;
52 
53  /* Allocate and zero-init the LPB */
56  if (WinLdrSystemBlock == NULL)
57  {
58  UiMessageBox("Failed to allocate memory for system block!");
59  return;
60  }
61 
63 
64  LoaderBlock = &WinLdrSystemBlock->LoaderBlock;
65  LoaderBlock->NlsData = &WinLdrSystemBlock->NlsDataBlock;
66 
67  /* Init three critical lists, used right away */
71 
72  *OutLoaderBlock = LoaderBlock;
73 }
74 
75 // Init "phase 1"
76 VOID
81  USHORT VersionToBoot)
82 {
83  /* Examples of correct options and paths */
84  //CHAR Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
85  //CHAR Options[] = "/NODEBUG";
86  //CHAR SystemRoot[] = "\\WINNT\\";
87  //CHAR ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
88 
89  LPSTR LoadOptions, NewLoadOptions;
90  CHAR HalPath[] = "\\";
91  CHAR ArcBoot[256];
92  CHAR MiscFiles[256];
93  ULONG i;
94  ULONG_PTR PathSeparator;
96 
97  /* Construct SystemRoot and ArcBoot from SystemPath */
98  PathSeparator = strstr(BootPath, "\\") - BootPath;
99  strncpy(ArcBoot, BootPath, PathSeparator);
100  ArcBoot[PathSeparator] = ANSI_NULL;
101 
102  TRACE("ArcBoot: %s\n", ArcBoot);
103  TRACE("SystemRoot: %s\n", SystemRoot);
104  TRACE("Options: %s\n", Options);
105 
106  /* Fill Arc BootDevice */
108  strncpy(LoaderBlock->ArcBootDeviceName, ArcBoot, MAX_PATH);
109  LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
110 
111  /* Fill Arc HalDevice, it matches ArcBoot path */
113  LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
114 
115  /* Fill SystemRoot */
117  strncpy(LoaderBlock->NtBootPathName, SystemRoot, MAX_PATH);
118  LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
119 
120  /* Fill NtHalPathName */
122  strncpy(LoaderBlock->NtHalPathName, HalPath, MAX_PATH);
123  LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
124 
125  /* Fill LoadOptions and strip the '/' commutator symbol in front of each option */
126  NewLoadOptions = LoadOptions = LoaderBlock->LoadOptions = WinLdrSystemBlock->LoadOptions;
128 
129  do
130  {
131  while (*LoadOptions == '/')
132  ++LoadOptions;
133 
134  *NewLoadOptions++ = *LoadOptions;
135  } while (*LoadOptions++);
136 
137  LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
138 
139  /* Arc devices */
142 
143  /* Convert ARC disk information from freeldr to a correct format */
144  for (i = 0; i < reactos_disk_count; i++)
145  {
146  PARC_DISK_SIGNATURE_EX ArcDiskSig;
147 
148  /* Allocate the ARC structure */
149  ArcDiskSig = FrLdrHeapAlloc(sizeof(ARC_DISK_SIGNATURE_EX), 'giSD');
150 
151  /* Copy the data over */
153 
154  /* Set the ARC Name pointer */
155  ArcDiskSig->DiskSignature.ArcName = PaToVa(ArcDiskSig->ArcName);
156 
157  /* Insert into the list */
159  &ArcDiskSig->DiskSignature.ListEntry);
160  }
161 
162  /* Convert all list's to Virtual address */
163 
164  /* Convert the ArcDisks list to virtual address */
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 */
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 */
199  {
200  Extension->HeadlessLoaderBlock = &WinLdrSystemBlock->HeadlessLoaderBlock;
201  RtlCopyMemory(Extension->HeadlessLoaderBlock,
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,
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
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;
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
297 {
298  PLIST_ENTRY NextBd;
299  PBOOT_DRIVER_LIST_ENTRY BootDriver;
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
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
348  ULONG *Size,
349  TYPE_OF_MEMORY MemoryType)
350 {
351  ULONG FileId;
352  PVOID PhysicalBase;
354  ULONG FileSize;
357 
358  //CHAR ProgressString[256];
359 
360  /* Inform user we are loading files */
361  //UiDrawBackdrop();
362  //sprintf(ProgressString, "Loading %s...", FileName);
363  //UiDrawProgressBarCenter(1, 100, ProgressString);
364 
365  TRACE("Loading module %s\n", ModuleName);
366  *Size = 0;
367 
368  /* Open the image file */
370  if (Status != ESUCCESS)
371  {
372  /* In case of errors, we just return, without complaining to the user */
373  return NULL;
374  }
375 
376  /* Get this file's size */
378  if (Status != ESUCCESS)
379  {
380  ArcClose(FileId);
381  return NULL;
382  }
383  FileSize = FileInfo.EndingAddress.LowPart;
384  *Size = FileSize;
385 
386  /* Allocate memory */
387  PhysicalBase = MmAllocateMemoryWithType(FileSize, MemoryType);
388  if (PhysicalBase == NULL)
389  {
390  ArcClose(FileId);
391  return NULL;
392  }
393 
394  /* Load whole file */
395  Status = ArcRead(FileId, PhysicalBase, FileSize, &BytesRead);
396  ArcClose(FileId);
397  if (Status != ESUCCESS)
398  {
399  return NULL;
400  }
401 
402  TRACE("Loaded %s at 0x%x with size 0x%x\n", ModuleName, PhysicalBase, FileSize);
403 
404  return PhysicalBase;
405 }
406 
407 USHORT
409 {
410  LONG rc;
411  HKEY hKey;
412 
413  rc = RegOpenKey(
414  NULL,
415  L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server",
416  &hKey);
417  if (rc != ERROR_SUCCESS)
418  {
419  // Key doesn't exist; assume NT 4.0
420  return _WIN32_WINNT_NT4;
421  }
422 
423  // We may here want to read the value of ProductVersion
424  return _WIN32_WINNT_WS03;
425 }
426 
427 static
428 BOOLEAN
430  IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
431  IN PCCH Path,
432  IN PCCH File,
433  IN PCCH ImportName, // BaseDllName
434  IN TYPE_OF_MEMORY MemoryType,
436  IN ULONG Percentage)
437 {
439  CHAR FullFileName[MAX_PATH];
440  CHAR ProgressString[256];
442 
443  UiDrawBackdrop();
444  sprintf(ProgressString, "Loading %s...", File);
445  UiDrawProgressBarCenter(Percentage, 100, ProgressString);
446 
447  strcpy(FullFileName, Path);
448  strcat(FullFileName, File);
449 
450  Success = WinLdrLoadImage(FullFileName, MemoryType, &BaseAddress);
451  if (!Success)
452  {
453  TRACE("Loading %s failed\n", File);
454  return FALSE;
455  }
456  TRACE("%s loaded successfully at %p\n", File, BaseAddress);
457 
458  /*
459  * Cheat about the base DLL name if we are loading
460  * the Kernel Debugger Transport DLL, to make the
461  * PE loader happy.
462  */
463  Success = WinLdrAllocateDataTableEntry(&LoaderBlock->LoadOrderListHead,
464  ImportName,
465  FullFileName,
466  BaseAddress,
467  Dte);
468 
469  return Success;
470 }
471 
472 static
473 BOOLEAN
475  IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
477  IN PCSTR BootPath,
478  IN OUT PLDR_DATA_TABLE_ENTRY* KernelDTE)
479 {
481  PCSTR Options;
482  CHAR DirPath[MAX_PATH];
483  CHAR KernelFileName[MAX_PATH];
484  CHAR HalFileName[MAX_PATH];
485  CHAR KdTransportDllName[MAX_PATH];
486  PLDR_DATA_TABLE_ENTRY HalDTE, KdComDTE = NULL;
487 
488  if (!KernelDTE) return FALSE;
489 
490  /* Initialize SystemRoot\System32 path */
491  strcpy(DirPath, BootPath);
492  strcat(DirPath, "system32\\");
493 
494  //
495  // TODO: Parse also the separate INI values "Kernel=" and "Hal="
496  //
497 
498  /* Default KERNEL and HAL file names */
499  strcpy(KernelFileName, "ntoskrnl.exe");
500  strcpy(HalFileName , "hal.dll");
501 
502  /* Find any /KERNEL= or /HAL= switch in the boot options */
504  while (Options)
505  {
506  /* Skip possible initial whitespace */
507  Options += strspn(Options, " \t");
508 
509  /* Check whether a new commutator starts and it is either KERNEL or HAL */
510  if (*Options != '/' || (++Options,
511  !(_strnicmp(Options, "KERNEL=", 7) == 0 ||
512  _strnicmp(Options, "HAL=", 4) == 0)) )
513  {
514  /* Search for another whitespace */
515  Options = strpbrk(Options, " \t");
516  continue;
517  }
518  else
519  {
520  size_t i = strcspn(Options, " \t"); /* Skip whitespace */
521  if (i == 0)
522  {
523  /* Use the default values */
524  break;
525  }
526 
527  /* We have found either KERNEL or HAL commutator */
528  if (_strnicmp(Options, "KERNEL=", 7) == 0)
529  {
530  Options += 7; i -= 7;
531  strncpy(KernelFileName, Options, i);
532  KernelFileName[i] = ANSI_NULL;
533  _strupr(KernelFileName);
534  }
535  else if (_strnicmp(Options, "HAL=", 4) == 0)
536  {
537  Options += 4; i -= 4;
538  strncpy(HalFileName, Options, i);
539  HalFileName[i] = ANSI_NULL;
540  _strupr(HalFileName);
541  }
542  }
543  }
544 
545  TRACE("Kernel file = '%s' ; HAL file = '%s'\n", KernelFileName, HalFileName);
546 
547  /* Load the Kernel */
548  LoadModule(LoaderBlock, DirPath, KernelFileName, "ntoskrnl.exe", LoaderSystemCode, KernelDTE, 30);
549 
550  /* Load the HAL */
551  LoadModule(LoaderBlock, DirPath, HalFileName, "hal.dll", LoaderHalCode, &HalDTE, 45);
552 
553  /* Load the Kernel Debugger Transport DLL */
555  {
556  /*
557  * According to http://www.nynaeve.net/?p=173 :
558  * "[...] Another enhancement that could be done Microsoft-side would be
559  * a better interface for replacing KD transport modules. Right now, due
560  * to the fact that ntoskrnl is static linked to KDCOM.DLL, the OS loader
561  * has a hardcoded hack that interprets the KD type in the OS loader options,
562  * loads one of the (hardcoded filenames) "kdcom.dll", "kd1394.dll", or
563  * "kdusb2.dll" modules, and inserts them into the loaded module list under
564  * the name "kdcom.dll". [...]"
565  */
566 
567  /*
568  * This loop replaces a dumb call to strstr(..., "DEBUGPORT=").
569  * Indeed I want it to be case-insensitive to allow "debugport="
570  * or "DeBuGpOrT=" or... , and I don't want it to match malformed
571  * command-line options, such as:
572  *
573  * "...foo DEBUGPORT=xxx bar..."
574  * "...foo/DEBUGPORT=xxx bar..."
575  * "...foo/DEBUGPORT=bar..."
576  *
577  * i.e. the "DEBUGPORT=" switch must start with a slash and be separated
578  * from the rest by whitespace, unless it begins the command-line, e.g.:
579  *
580  * "/DEBUGPORT=COM1 foo...bar..."
581  * "...foo /DEBUGPORT=USB bar..."
582  * or:
583  * "...foo /DEBUGPORT= bar..."
584  * (in that case, we default the port to COM).
585  */
587  while (Options)
588  {
589  /* Skip possible initial whitespace */
590  Options += strspn(Options, " \t");
591 
592  /* Check whether a new commutator starts and it is the DEBUGPORT one */
593  if (*Options != '/' || _strnicmp(++Options, "DEBUGPORT=", 10) != 0)
594  {
595  /* Search for another whitespace */
596  Options = strpbrk(Options, " \t");
597  continue;
598  }
599  else
600  {
601  /* We found the DEBUGPORT commutator. Move to the port name. */
602  Options += 10;
603  break;
604  }
605  }
606 
607  if (Options)
608  {
609  /*
610  * We have found the DEBUGPORT commutator. Parse the port name.
611  * Format: /DEBUGPORT=COM1 or /DEBUGPORT=FILE:\Device\HarddiskX\PartitionY\debug.log or /DEBUGPORT=FOO
612  * If we only have /DEBUGPORT= (i.e. without any port name), defaults it to "COM".
613  */
614  strcpy(KdTransportDllName, "KD");
615  if (_strnicmp(Options, "COM", 3) == 0 && '0' <= Options[3] && Options[3] <= '9')
616  {
617  strncat(KdTransportDllName, Options, 3);
618  }
619  else
620  {
621  size_t i = strcspn(Options, " \t:"); /* Skip valid separators: whitespace or colon */
622  if (i == 0)
623  strcat(KdTransportDllName, "COM");
624  else
625  strncat(KdTransportDllName, Options, i);
626  }
627  strcat(KdTransportDllName, ".DLL");
628  _strupr(KdTransportDllName);
629 
630  /*
631  * Load the transport DLL. Override the base DLL name of the
632  * loaded transport DLL to the default "KDCOM.DLL" name.
633  */
634  LoadModule(LoaderBlock, DirPath, KdTransportDllName, "kdcom.dll", LoaderSystemCode, &KdComDTE, 60);
635  }
636  }
637 
638  /* Load all referenced DLLs for Kernel, HAL and Kernel Debugger Transport DLL */
639  Success = WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, *KernelDTE);
640  Success &= WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, HalDTE);
641  if (KdComDTE)
642  {
643  Success &= WinLdrScanImportDescriptorTable(&LoaderBlock->LoadOrderListHead, DirPath, KdComDTE);
644  }
645 
646  return Success;
647 }
648 
649 VOID
652 {
653  ULONG_PTR SectionId;
654  PCSTR SectionName = OperatingSystem->SystemPartition;
655  CHAR SettingsValue[80];
656  BOOLEAN HasSection;
659  CHAR BootOptions[256];
660  PCHAR File;
662  PLOADER_PARAMETER_BLOCK LoaderBlock;
663 
664  /* Get OS setting value */
665  SettingsValue[0] = ANSI_NULL;
666  IniOpenSection("Operating Systems", &SectionId);
667  IniReadSettingByName(SectionId, SectionName, SettingsValue, sizeof(SettingsValue));
668 
669  /* Open the operating system section specified in the .ini file */
670  HasSection = IniOpenSection(SectionName, &SectionId);
671 
672  UiDrawBackdrop();
673  UiDrawProgressBarCenter(1, 100, "Loading NT...");
674 
675  /* Read the system path is set in the .ini file */
676  if (!HasSection ||
677  !IniReadSettingByName(SectionId, "SystemPath", BootPath, sizeof(BootPath)))
678  {
679  strcpy(BootPath, SectionName);
680  }
681 
682  /*
683  * Check whether BootPath is a full path
684  * and if not, create a full boot path.
685  *
686  * See FsOpenFile for the technique used.
687  */
688  if (strrchr(BootPath, ')') == NULL)
689  {
690  /* Temporarily save the boot path */
692 
693  /* This is not a full path. Use the current (i.e. boot) device. */
695 
696  /* Append a path separator if needed */
697  if (FileName[0] != '\\' && FileName[0] != '/')
698  strcat(BootPath, "\\");
699 
700  /* Append the remaining path */
702  }
703 
704  /* Append a backslash if needed */
705  if ((BootPath[0] == 0) || BootPath[strlen(BootPath) - 1] != '\\')
706  strcat(BootPath, "\\");
707 
708  /* Read booting options */
709  if (!HasSection || !IniReadSettingByName(SectionId, "Options", BootOptions, sizeof(BootOptions)))
710  {
711  /* Get options after the title */
712  PCSTR p = SettingsValue;
713  while (*p == ' ' || *p == '"')
714  p++;
715  while (*p != '\0' && *p != '"')
716  p++;
717  strcpy(BootOptions, p);
718  TRACE("BootOptions: '%s'\n", BootOptions);
719  }
720 
721  /* Append boot-time options */
723 
724  /* Check if a ramdisk file was given */
725  File = strstr(BootOptions, "/RDPATH=");
726  if (File)
727  {
728  /* Copy the file name and everything else after it */
729  strcpy(FileName, File + 8);
730 
731  /* Null-terminate */
732  *strstr(FileName, " ") = ANSI_NULL;
733 
734  /* Load the ramdisk */
736  {
737  UiMessageBox("Failed to load RAM disk file %s", FileName);
738  return;
739  }
740  }
741 
742  /* Let user know we started loading */
743  //UiDrawStatusText("Loading...");
744 
745  TRACE("BootPath: '%s'\n", BootPath);
746 
747  /* Allocate and minimalist-initialize LPB */
748  AllocateAndInitLPB(&LoaderBlock);
749 
750  /* Load the system hive */
751  UiDrawBackdrop();
752  UiDrawProgressBarCenter(15, 100, "Loading system hive...");
753  Success = WinLdrInitSystemHive(LoaderBlock, BootPath, FALSE);
754  TRACE("SYSTEM hive %s\n", (Success ? "loaded" : "not loaded"));
755  /* Bail out if failure */
756  if (!Success)
757  return;
758 
759  /* Load NLS data, OEM font, and prepare boot drivers list */
760  Success = WinLdrScanSystemHive(LoaderBlock, BootPath);
761  TRACE("SYSTEM hive %s\n", (Success ? "scanned" : "not scanned"));
762  /* Bail out if failure */
763  if (!Success)
764  return;
765 
766  /* Finish loading */
768  LoaderBlock,
769  BootOptions,
770  BootPath,
771  FALSE);
772 }
773 
774 VOID
777  PLOADER_PARAMETER_BLOCK LoaderBlock,
780  BOOLEAN Setup)
781 {
782  PLOADER_PARAMETER_BLOCK LoaderBlockVA;
784  PLDR_DATA_TABLE_ENTRY KernelDTE;
787  TRACE("LoadAndBootWindowsCommon()\n");
788 
789 #ifdef _M_IX86
790  /* Setup redirection support */
792 #endif
793 
794  /* Convert BootPath to SystemRoot */
795  SystemRoot = strstr(BootPath, "\\");
796 
797  /* Detect hardware */
798  UiDrawBackdrop();
799  UiDrawProgressBarCenter(20, 100, "Detecting hardware...");
800  LoaderBlock->ConfigurationRoot = MachHwDetect();
801 
802  if (OperatingSystemVersion == 0)
804 
805  /* Load the operating system core: the Kernel, the HAL and the Kernel Debugger Transport DLL */
807  LoaderBlock,
808  BootOptions,
809  BootPath,
810  &KernelDTE);
811  if (!Success)
812  {
813  UiMessageBox("Error loading NTOS core.");
814  return;
815  }
816 
817  /* Load boot drivers */
818  UiDrawBackdrop();
819  UiDrawProgressBarCenter(100, 100, "Loading boot drivers...");
820  Success = WinLdrLoadBootDrivers(LoaderBlock, BootPath);
821  TRACE("Boot drivers loading %s\n", Success ? "successful" : "failed");
822 
823  /* Initialize Phase 1 - no drivers loading anymore */
824  WinLdrInitializePhase1(LoaderBlock,
825  BootOptions,
826  SystemRoot,
827  BootPath,
829 
830  /* Save entry-point pointer and Loader block VAs */
832  LoaderBlockVA = PaToVa(LoaderBlock);
833 
834  /* "Stop all motors", change videomode */
836 
837  /* Cleanup ini file */
838  IniCleanup();
839 
840  /* Debugging... */
841  //DumpMemoryAllocMap();
842 
843  /* Do the machine specific initialization */
844  WinLdrSetupMachineDependent(LoaderBlock);
845 
846  /* Map pages and create memory descriptors */
847  WinLdrSetupMemoryLayout(LoaderBlock);
848 
849  /* Set processor context */
851 
852  /* Save final value of LoaderPagesSpanned */
854 
855  TRACE("Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
856  KiSystemStartup, LoaderBlockVA);
857 
858  // Zero KI_USER_SHARED_DATA page
859  memset((PVOID)KI_USER_SHARED_DATA, 0, MM_PAGE_SIZE);
860 
861  WinLdrpDumpMemoryDescriptors(LoaderBlockVA);
862  WinLdrpDumpBootDriver(LoaderBlockVA);
863 #ifndef _M_AMD64
864  WinLdrpDumpArcDisks(LoaderBlockVA);
865 #endif
866 
867  /* Pass control */
868  (*KiSystemStartup)(LoaderBlockVA);
869 }
870 
871 VOID
873 {
874  PLIST_ENTRY NextMd;
876 
877  NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
878 
879  while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
880  {
882 
883  TRACE("BP %08X PC %04X MT %d\n", MemoryDescriptor->BasePage,
884  MemoryDescriptor->PageCount, MemoryDescriptor->MemoryType);
885 
886  NextMd = MemoryDescriptor->ListEntry.Flink;
887  }
888 }
889 
890 VOID
892 {
893  PLIST_ENTRY NextBd;
894  PBOOT_DRIVER_LIST_ENTRY BootDriver;
895 
896  NextBd = LoaderBlock->BootDriverListHead.Flink;
897 
898  while (NextBd != &LoaderBlock->BootDriverListHead)
899  {
900  BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
901 
902  TRACE("BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
903  BootDriver->LdrEntry, &BootDriver->RegistryPath);
904 
905  NextBd = BootDriver->Link.Flink;
906  }
907 }
908 
909 VOID
911 {
912  PLIST_ENTRY NextBd;
913  PARC_DISK_SIGNATURE ArcDisk;
914 
915  NextBd = LoaderBlock->ArcDiskInformation->DiskSignatureListHead.Flink;
916 
917  while (NextBd != &LoaderBlock->ArcDiskInformation->DiskSignatureListHead)
918  {
919  ArcDisk = CONTAINING_RECORD(NextBd, ARC_DISK_SIGNATURE, ListEntry);
920 
921  TRACE("ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
922  ArcDisk->ArcName, ArcDisk->CheckSum, ArcDisk->Signature);
923 
924  NextBd = ArcDisk->ListEntry.Flink;
925  }
926 }
VOID AllocateAndInitLPB(PLOADER_PARAMETER_BLOCK *OutLoaderBlock)
Definition: winldr.c:49
VOID AppendBootTimeOptions(PCHAR BootOptions)
Definition: options.c:244
signed char * PCHAR
Definition: retypes.h:7
#define MachHwDetect()
Definition: machine.h:130
#define IN
Definition: typedefs.h:38
VOID LoadAndBootWindows(IN OperatingSystemItem *OperatingSystem, IN USHORT OperatingSystemVersion)
Definition: winldr.c:650
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
VOID(NTAPI * KERNEL_ENTRY_POINT)(PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: winldr.h:34
PSTR ArcBootDeviceName
Definition: arc.h:503
_Out_ PNDIS_BUFFER _In_ NDIS_HANDLE _In_ PVOID MemoryDescriptor
Definition: ndis.h:3252
BOOLEAN WinLdrAllocateDataTableEntry(IN OUT PLIST_ENTRY ModuleListHead, IN PCCH BaseDllName, IN PCCH FullDllName, IN PVOID BasePA, OUT PLDR_DATA_TABLE_ENTRY *NewEntry)
Definition: peloader.c:172
ARC_DISK_INFORMATION ArcDiskInformation
Definition: winldr.h:84
ARC_DISK_SIGNATURE_EX reactos_arc_disk_info[]
Definition: archwsup.c:21
#define ERROR_SUCCESS
Definition: deptool.c:10
VOID WinLdrpDumpArcDisks(PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: winldr.c:910
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE ACPI_HANDLE *OutHandle ACPI_HANDLE *OutHandle void *Context void *Context ACPI_EVENT_HANDLER Handler UINT32 UINT32 ACPI_GPE_HANDLER void *Context UINT32 ACPI_NOTIFY_HANDLER void *Context ACPI_ADR_SPACE_TYPE ACPI_ADR_SPACE_HANDLER ACPI_ADR_SPACE_SETUP Setup
Definition: acpixf.h:816
char * strncat(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:605
#define _WIN32_WINNT_WS03
Definition: sdkddkver.h:23
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
BOOLEAN NTAPI RamDiskLoadVirtualFile(IN PCHAR FileName)
Definition: ramdisk.c:121
Definition: arc.h:32
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strpbrk(const char *String, const char *Delimiters)
Definition: utclib.c:302
VOID WinLdrSetProcessorContext(void)
Definition: winldr.c:348
PCHAR ArcName
Definition: arc.h:210
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
_Check_return_ _CRTIMP size_t __cdecl strcspn(_In_z_ const char *_Str, _In_z_ const char *_Control)
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
PLOADER_PARAMETER_EXTENSION Extension
Definition: arc.h:512
PCONFIGURATION_COMPONENT_DATA ConfigurationRoot
Definition: arc.h:502
char CHAR
Definition: xmlstorage.h:175
static BOOLEAN LoadWindowsCore(IN USHORT OperatingSystemVersion, IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCSTR BootOptions, IN PCSTR BootPath, IN OUT PLDR_DATA_TABLE_ENTRY *KernelDTE)
Definition: winldr.c:474
BOOLEAN WinLdrTerminalConnected
Definition: headless.c:30
ULONG Signature
Definition: arc.h:209
_Check_return_ _CRTIMP size_t __cdecl strspn(_In_z_ const char *_Str, _In_z_ const char *_Control)
HEADLESS_LOADER_BLOCK LoaderRedirectionInformation
Definition: headless.c:29
ULONG ARC_STATUS
Definition: arc.h:4
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char * ModuleName
Definition: acpixf.h:1252
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define InsertTailList(ListHead, Entry)
char * LPSTR
Definition: xmlstorage.h:182
enum OPTION_FLAGS Options
Definition: stats.c:44
UNICODE_STRING FilePath
Definition: arc.h:201
static int Link(const char **args)
Definition: vfdcmd.c:2414
void WinLdrSetupEms(IN PCHAR BootOptions)
Definition: headless.c:243
BOOLEAN WinLdrSetupMemoryLayout(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: wlmemory.c:182
CHAR ArcBootDeviceName[MAX_PATH+1]
Definition: winldr.h:80
PCWSTR FilePath
BOOLEAN WinLdrLoadBootDrivers(PLOADER_PARAMETER_BLOCK LoaderBlock, LPCSTR BootPath)
Definition: winldr.c:295
enum _TYPE_OF_MEMORY TYPE_OF_MEMORY
uint32_t ULONG_PTR
Definition: typedefs.h:63
Definition: arc.h:198
#define MAX_OPTIONS_LENGTH
Definition: winldr.h:68
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define sprintf(buf, format,...)
Definition: sprintf.c:55
BOOLEAN WinLdrCheckForLoadedDll(IN OUT PLIST_ENTRY ModuleListHead, IN PCH DllName, OUT PLDR_DATA_TABLE_ENTRY *LoadedEntry)
Definition: peloader.c:58
#define _snprintf
Definition: xmlstorage.h:200
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define _WIN32_WINNT_WIN2K
Definition: sdkddkver.h:21
VOID DumpMemoryAllocMap(VOID)
struct _SETUP_LOADER_BLOCK * SetupLdrBlock
Definition: arc.h:511
#define ANSI_NULL
long LONG
Definition: pedump.c:60
VOID List_PaToVa(_In_ LIST_ENTRY *ListEntry)
DBG_DEFAULT_CHANNEL(WINDOWS)
PVOID EntryPoint
Definition: ntddk_ex.h:203
INIT_FUNCTION VOID NTAPI KiSystemStartup(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:371
_Check_return_ _CRTIMP int __cdecl _strnicmp(_In_reads_or_z_(_MaxCount) const char *_Str1, _In_reads_or_z_(_MaxCount) const char *_Str2, _In_ size_t _MaxCount)
_In_opt_ PVOID _In_ PCSTR File
Definition: iofuncs.h:615
VOID UiMessageBox(PCSTR Format,...)
Definition: ui.c:347
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
void WinLdrSetupMachineDependent(PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: winldr.c:379
#define _WIN32_WINNT_NT4
Definition: sdkddkver.h:20
USHORT WinLdrDetectVersion(VOID)
Definition: winldr.c:408
VOID WinLdrpDumpBootDriver(PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: winldr.c:891
const char * LPCSTR
Definition: xmlstorage.h:183
void * PVOID
Definition: retypes.h:9
LOADER_PARAMETER_BLOCK LoaderBlock
Definition: winldr.h:72
USHORT OperatingSystemVersion
Definition: bootmgr.c:35
ULONG_PTR LoaderPagesSpanned
Definition: arc.h:356
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
BOOLEAN IniReadSettingByName(ULONG_PTR SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize)
Definition: inifile.c:147
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
CONST CHAR * PCCH
Definition: ntbasedef.h:399
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
FORCEINLINE PVOID FrLdrHeapAlloc(SIZE_T MemorySize, ULONG Tag)
Definition: mm.h:163
#define TRACE(s)
Definition: solgame.cpp:4
LIST_ENTRY ListEntry
Definition: arc.h:208
BOOLEAN IniOpenSection(PCSTR SectionName, ULONG_PTR *SectionId)
Definition: inifile.c:25
PVOID WinLdrLoadModule(PCSTR ModuleName, ULONG *Size, TYPE_OF_MEMORY MemoryType)
Definition: winldr.c:347
static const WCHAR SystemRoot[]
Definition: reg.c:38
CHAR ArcName[MAX_PATH]
Definition: winldr.h:58
NLS_DATA_BLOCK NlsDataBlock
Definition: winldr.h:78
#define MAX_PATH
Definition: compat.h:26
PARC_DISK_INFORMATION ArcDiskInformation
Definition: arc.h:509
static BOOLEAN WinLdrLoadDeviceDriver(PLIST_ENTRY LoadOrderListHead, LPCSTR BootPath, PUNICODE_STRING FilePath, ULONG Flags, PLDR_DATA_TABLE_ENTRY *DriverDTE)
Definition: winldr.c:224
LIST_ENTRY BootDriverListHead
Definition: arc.h:495
ULONG reactos_disk_count
Definition: archwsup.c:20
ULONG LoaderPagesSpanned
Definition: mm.c:29
ARC_DISK_SIGNATURE DiskSignature
Definition: winldr.h:57
BOOLEAN AcpiPresent
Definition: macharm.c:21
VOID WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock, LPCSTR Options, LPCSTR SystemRoot, LPCSTR BootPath, USHORT VersionToBoot)
Definition: winldr.c:77
BOOLEAN WinLdrScanImportDescriptorTable(IN OUT PLIST_ENTRY ModuleListHead, IN PCCH DirectoryPath, IN PLDR_DATA_TABLE_ENTRY ScanDTE)
Definition: peloader.c:101
ARC_STATUS ArcRead(ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
Definition: fs.c:237
CHAR LoadOptions[MAX_OPTIONS_LENGTH+1]
Definition: winldr.h:79
VOID IniCleanup(VOID)
Definition: inifile.c:235
int ret
static const WCHAR L[]
Definition: oid.c:1250
PVOID MmAllocateMemoryWithType(SIZE_T MemorySize, TYPE_OF_MEMORY MemoryType)
Definition: mm.c:31
#define KI_USER_SHARED_DATA
Definition: btrfs_drv.h:1801
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
Definition: fsrtlfuncs.h:108
#define MachPrepareForReactOS(Setup)
Definition: machine.h:116
CHAR NtHalPathName[MAX_PATH+1]
Definition: winldr.h:83
Definition: typedefs.h:117
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
VOID UiDrawBackdrop(VOID)
Definition: ui.c:241
VOID WinLdrpDumpMemoryDescriptors(PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: winldr.c:872
LIST_ENTRY LoadOrderListHead
Definition: arc.h:493
LOADER_PARAMETER_EXTENSION Extension
Definition: winldr.h:73
Status
Definition: gdiplustypes.h:24
static BOOLEAN LoadModule(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCCH Path, IN PCCH File, IN PCCH ImportName, IN TYPE_OF_MEMORY MemoryType, OUT PLDR_DATA_TABLE_ENTRY *Dte, IN ULONG Percentage)
Definition: winldr.c:429
#define ERR(fmt,...)
Definition: debug.h:109
UNICODE_STRING RegistryPath
Definition: arc.h:202
PRTL_UNICODE_STRING_BUFFER Path
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
unsigned short USHORT
Definition: pedump.c:61
struct _LDR_DATA_TABLE_ENTRY * LdrEntry
Definition: arc.h:203
LIST_ENTRY MemoryDescriptorListHead
Definition: arc.h:494
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define MachDiskGetBootPath(Path, Size)
Definition: machine.h:118
BOOLEAN WinLdrLoadImage(IN PCHAR FileName, TYPE_OF_MEMORY MemoryType, OUT PVOID *ImageBasePA)
Definition: peloader.c:268
VOID ConvertConfigToVA(PCONFIGURATION_COMPONENT_DATA Start)
Definition: conversion.c:51
ARC_STATUS ArcClose(ULONG FileId)
Definition: fs.c:219
LIST_ENTRY Link
Definition: arc.h:200
ARC_STATUS ArcGetFileInformation(ULONG FileId, FILEINFORMATION *Information)
Definition: fs.c:251
#define OUT
Definition: typedefs.h:39
struct FileInfo FileInfo
FORCEINLINE PVOID PaToVa(PVOID Pa)
Definition: conversion.h:22
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
ARC_STATUS ArcOpen(CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
Definition: fs.c:57
LIST_ENTRY DiskSignatureListHead
Definition: arc.h:221
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
VOID LoadAndBootWindowsCommon(USHORT OperatingSystemVersion, PLOADER_PARAMETER_BLOCK LoaderBlock, LPCSTR BootOptions, LPCSTR BootPath, BOOLEAN Setup)
Definition: winldr.c:775
PNLS_DATA_BLOCK NlsData
Definition: arc.h:508
const char * PCSTR
Definition: typedefs.h:51
Definition: File.h:15
ULONG CheckSum
Definition: arc.h:211
CHAR NtBootPathName[MAX_PATH+1]
Definition: winldr.h:82
GLfloat GLfloat p
Definition: glext.h:8902
#define RegOpenKey
Definition: winreg.h:519
BOOLEAN WinLdrInitSystemHive(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCSTR SystemRoot, IN BOOLEAN Setup)
Definition: wlregistry.c:121
#define memset(x, y, z)
Definition: compat.h:39
BOOLEAN WinLdrScanSystemHive(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN LPCSTR DirectoryPath)
Definition: wlregistry.c:171
_Inout_opt_ PUNICODE_STRING Extension
Definition: fltkernel.h:1092
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesRead
Definition: fltkernel.h:1255
struct _LOADER_PARAMETER_EXTENSION LOADER_PARAMETER_EXTENSION
char BootPath[0x100]
Definition: mach.c:35
VOID UiDrawProgressBarCenter(ULONG Position, ULONG Range, PCHAR ProgressText)
Definition: ui.c:373
PLOADER_SYSTEM_BLOCK WinLdrSystemBlock
Definition: winldr.c:42