813eea9346510ea514d66801382a5b4cbd2d3d3d
[reactos.git] / reactos / boot / freeldr / freeldr / reactos / reactos.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: Freeloader
4 * FILE: boot/freeldr/freeldr/reactos/rosboot.c
5 * PURPOSE: ReactOS Loader
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 */
8
9 #include <freeldr.h>
10 #include <internal/i386/ke.h>
11 #include <reactos/rossym.h>
12
13 #include "registry.h"
14
15 #define NDEBUG
16 #include <debug.h>
17
18 BOOL
19 STDCALL
20 FrLdrLoadKernel(PCHAR szFileName,
21 INT nPos)
22 {
23 PFILE FilePointer;
24 PCHAR szShortName;
25 CHAR szBuffer[256];
26
27 /* Extract Kernel filename without path */
28 szShortName = strrchr(szFileName, '\\');
29 if (szShortName == NULL) {
30
31 /* No path, leave it alone */
32 szShortName = szFileName;
33
34 } else {
35
36 /* Skip the path */
37 szShortName = szShortName + 1;
38 }
39
40 /* Open the Kernel */
41 FilePointer = FsOpenFile(szFileName);
42
43 /* Make sure it worked */
44 if (FilePointer == NULL) {
45
46 /* Return failure on the short name */
47 strcpy(szBuffer, szShortName);
48 strcat(szBuffer, " not found.");
49 UiMessageBox(szBuffer);
50 return(FALSE);
51 }
52
53 /* Update the status bar with the current file */
54 strcpy(szBuffer, "Reading ");
55 strcat(szBuffer, szShortName);
56 UiDrawStatusText(szBuffer);
57
58 /* Do the actual loading */
59 FrLdrMapKernel(FilePointer);
60
61 /* Update Processbar and return success */
62 UiDrawProgressBarCenter(nPos, 100, "Loading ReactOS...");
63 return(TRUE);
64 }
65
66 static VOID
67 FreeldrFreeMem(PVOID Area)
68 {
69 MmFreeMemory(Area);
70 }
71
72 static PVOID
73 FreeldrAllocMem(ULONG_PTR Size)
74 {
75 return MmAllocateMemory((ULONG) Size);
76 }
77
78 static BOOLEAN
79 FreeldrReadFile(PVOID FileContext, PVOID Buffer, ULONG Size)
80 {
81 ULONG BytesRead;
82
83 return FsReadFile((PFILE) FileContext, (ULONG) Size, &BytesRead, Buffer)
84 && Size == BytesRead;
85 }
86
87 static BOOLEAN
88 FreeldrSeekFile(PVOID FileContext, ULONG_PTR Position)
89 {
90 FsSetFilePointer((PFILE) FileContext, (ULONG) Position);
91 return TRUE;
92 }
93
94 static BOOL
95 LoadKernelSymbols(PCHAR szKernelName, int nPos)
96 {
97 static ROSSYM_CALLBACKS FreeldrCallbacks =
98 {
99 FreeldrAllocMem,
100 FreeldrFreeMem,
101 FreeldrReadFile,
102 FreeldrSeekFile
103 };
104 PFILE FilePointer;
105 PROSSYM_INFO RosSymInfo;
106 ULONG Size;
107 ULONG_PTR Base;
108
109 RosSymInit(&FreeldrCallbacks);
110
111 FilePointer = FsOpenFile(szKernelName);
112 if (FilePointer == NULL)
113 {
114 return FALSE;
115 }
116 if (! RosSymCreateFromFile(FilePointer, &RosSymInfo))
117 {
118 return FALSE;
119 }
120 Base = FrLdrCreateModule("NTOSKRNL.SYM");
121 Size = RosSymGetRawDataLength(RosSymInfo);
122 RosSymGetRawData(RosSymInfo, (PVOID)Base);
123 FrLdrCloseModule(Base, Size);
124 RosSymDelete(RosSymInfo);
125 return TRUE;
126 }
127
128 BOOL
129 FrLdrLoadNlsFile(PCHAR szFileName,
130 PCHAR szModuleName)
131 {
132 PFILE FilePointer;
133 CHAR value[256];
134 LPSTR p;
135
136 /* Open the Driver */
137 FilePointer = FsOpenFile(szFileName);
138
139 /* Make sure we did */
140 if (FilePointer == NULL) {
141
142 /* Fail if file wasn't opened */
143 strcpy(value, szFileName);
144 strcat(value, " not found.");
145 UiMessageBox(value);
146 return(FALSE);
147 }
148
149 /* Update the status bar with the current file */
150 strcpy(value, "Reading ");
151 p = strrchr(szFileName, '\\');
152 if (p == NULL) {
153
154 strcat(value, szFileName);
155
156 } else {
157
158 strcat(value, p + 1);
159 }
160 UiDrawStatusText(value);
161
162 /* Load the driver */
163 FrLdrLoadModule(FilePointer, szModuleName, NULL);
164 return(TRUE);
165 }
166
167 BOOL
168 FrLdrLoadNlsFiles(PCHAR szSystemRoot,
169 PCHAR szErrorOut)
170 {
171 LONG rc = ERROR_SUCCESS;
172 FRLDRHKEY hKey;
173 CHAR szIdBuffer[80];
174 CHAR szNameBuffer[80];
175 CHAR szFileName[256];
176 ULONG BufferSize;
177
178 /* open the codepage key */
179 rc = RegOpenKey(NULL,
180 "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\CodePage",
181 &hKey);
182 if (rc != ERROR_SUCCESS) {
183
184 strcpy(szErrorOut, "Couldn't open CodePage registry key");
185 return(FALSE);
186 }
187
188 /* get ANSI codepage */
189 BufferSize = 80;
190 rc = RegQueryValue(hKey, "ACP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
191 if (rc != ERROR_SUCCESS) {
192
193 strcpy(szErrorOut, "Couldn't get ACP NLS setting");
194 return(FALSE);
195 }
196
197 BufferSize = 80;
198 rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
199 if (rc != ERROR_SUCCESS) {
200
201 strcpy(szErrorOut, "ACP NLS Setting exists, but isn't readable");
202 return(FALSE);
203 }
204
205 /* load ANSI codepage table */
206 strcpy(szFileName, szSystemRoot);
207 strcat(szFileName, "system32\\");
208 strcat(szFileName, szNameBuffer);
209 DbgPrint((DPRINT_REACTOS, "ANSI file: %s\n", szFileName));
210 if (!FrLdrLoadNlsFile(szFileName, "ansi.nls")) {
211
212 strcpy(szErrorOut, "Couldn't load ansi.nls");
213 return(FALSE);
214 }
215
216 /* get OEM codepage */
217 BufferSize = 80;
218 rc = RegQueryValue(hKey, "OEMCP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
219 if (rc != ERROR_SUCCESS) {
220
221 strcpy(szErrorOut, "Couldn't get OEMCP NLS setting");
222 return(FALSE);
223 }
224
225 BufferSize = 80;
226 rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
227 if (rc != ERROR_SUCCESS) {
228
229 strcpy(szErrorOut, "OEMCP NLS setting exists, but isn't readable");
230 return(FALSE);
231 }
232
233 /* load OEM codepage table */
234 strcpy(szFileName, szSystemRoot);
235 strcat(szFileName, "system32\\");
236 strcat(szFileName, szNameBuffer);
237 DbgPrint((DPRINT_REACTOS, "Oem file: %s\n", szFileName));
238 if (!FrLdrLoadNlsFile(szFileName, "oem.nls")) {
239
240 strcpy(szErrorOut, "Couldn't load oem.nls");
241 return(FALSE);
242 }
243
244 /* open the language key */
245 rc = RegOpenKey(NULL,
246 "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\Language",
247 &hKey);
248 if (rc != ERROR_SUCCESS) {
249
250 strcpy(szErrorOut, "Couldn't open Language registry key");
251 return(FALSE);
252 }
253
254 /* get the Unicode case table */
255 BufferSize = 80;
256 rc = RegQueryValue(hKey, "Default", NULL, (PUCHAR)szIdBuffer, &BufferSize);
257 if (rc != ERROR_SUCCESS) {
258
259 strcpy(szErrorOut, "Couldn't get Language Default setting");
260 return(FALSE);
261 }
262
263 BufferSize = 80;
264 rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
265 if (rc != ERROR_SUCCESS) {
266
267 strcpy(szErrorOut, "Language Default setting exists, but isn't readable");
268 return(FALSE);
269 }
270
271 /* load Unicode case table */
272 strcpy(szFileName, szSystemRoot);
273 strcat(szFileName, "system32\\");
274 strcat(szFileName, szNameBuffer);
275 DbgPrint((DPRINT_REACTOS, "Casemap file: %s\n", szFileName));
276 if (!FrLdrLoadNlsFile(szFileName, "casemap.nls")) {
277
278 strcpy(szErrorOut, "casemap.nls");
279 return(FALSE);
280 }
281
282 return(TRUE);
283 }
284
285 BOOL
286 FrLdrLoadDriver(PCHAR szFileName,
287 INT nPos)
288 {
289 PFILE FilePointer;
290 CHAR value[256];
291 LPSTR p;
292
293 /* Open the Driver */
294 FilePointer = FsOpenFile(szFileName);
295
296 /* Make sure we did */
297 if (FilePointer == NULL) {
298
299 /* Fail if file wasn't opened */
300 strcpy(value, szFileName);
301 strcat(value, " not found.");
302 UiMessageBox(value);
303 return(FALSE);
304 }
305
306 /* Update the status bar with the current file */
307 strcpy(value, "Reading ");
308 p = strrchr(szFileName, '\\');
309 if (p == NULL) {
310
311 strcat(value, szFileName);
312
313 } else {
314
315 strcat(value, p + 1);
316
317 }
318 UiDrawStatusText(value);
319
320 /* Load the driver */
321 FrLdrLoadModule(FilePointer, szFileName, NULL);
322
323 /* Update status and return */
324 UiDrawProgressBarCenter(nPos, 100, "Loading ReactOS...");
325 return(TRUE);
326 }
327
328 VOID
329 FrLdrLoadBootDrivers(PCHAR szSystemRoot,
330 INT nPos)
331 {
332 LONG rc = 0;
333 FRLDRHKEY hGroupKey, hOrderKey, hServiceKey, hDriverKey;
334 CHAR GroupNameBuffer[512];
335 CHAR ServiceName[256];
336 ULONG OrderList[128];
337 ULONG BufferSize;
338 ULONG Index;
339 ULONG TagIndex;
340 LPSTR GroupName;
341
342 ULONG ValueSize;
343 ULONG ValueType;
344 ULONG StartValue;
345 ULONG TagValue;
346 CHAR DriverGroup[256];
347 ULONG DriverGroupSize;
348
349 CHAR ImagePath[256];
350 CHAR TempImagePath[256];
351
352 /* get 'service group order' key */
353 rc = RegOpenKey(NULL,
354 "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\ServiceGroupOrder",
355 &hGroupKey);
356 if (rc != ERROR_SUCCESS) {
357
358 DbgPrint((DPRINT_REACTOS, "Failed to open the 'ServiceGroupOrder' key (rc %d)\n", (int)rc));
359 return;
360 }
361
362 /* get 'group order list' key */
363 rc = RegOpenKey(NULL,
364 "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\GroupOrderList",
365 &hOrderKey);
366 if (rc != ERROR_SUCCESS) {
367
368 DbgPrint((DPRINT_REACTOS, "Failed to open the 'GroupOrderList' key (rc %d)\n", (int)rc));
369 return;
370 }
371
372 /* enumerate drivers */
373 rc = RegOpenKey(NULL,
374 "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services",
375 &hServiceKey);
376 if (rc != ERROR_SUCCESS) {
377
378 DbgPrint((DPRINT_REACTOS, "Failed to open the 'Services' key (rc %d)\n", (int)rc));
379 return;
380 }
381
382 /* Get the Name Group */
383 BufferSize = sizeof(GroupNameBuffer);
384 rc = RegQueryValue(hGroupKey, "List", NULL, (PUCHAR)GroupNameBuffer, &BufferSize);
385 DbgPrint((DPRINT_REACTOS, "RegQueryValue(): rc %d\n", (int)rc));
386 if (rc != ERROR_SUCCESS) return;
387 DbgPrint((DPRINT_REACTOS, "BufferSize: %d \n", (int)BufferSize));
388 DbgPrint((DPRINT_REACTOS, "GroupNameBuffer: '%s' \n", GroupNameBuffer));
389
390 /* Loop through each group */
391 GroupName = GroupNameBuffer;
392 while (*GroupName) {
393 DbgPrint((DPRINT_REACTOS, "Driver group: '%s'\n", GroupName));
394
395 /* Query the Order */
396 BufferSize = sizeof(OrderList);
397 rc = RegQueryValue(hOrderKey, GroupName, NULL, (PUCHAR)OrderList, &BufferSize);
398 if (rc != ERROR_SUCCESS) OrderList[0] = 0;
399
400 /* enumerate all drivers */
401 for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++) {
402
403 Index = 0;
404
405 while (TRUE) {
406
407 /* Get the Driver's Name */
408 ValueSize = sizeof(ServiceName);
409 rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize);
410 DbgPrint((DPRINT_REACTOS, "RegEnumKey(): rc %d\n", (int)rc));
411
412 /* Makre sure it's valid, and check if we're done */
413 if (rc == ERROR_NO_MORE_ITEMS) break;
414 if (rc != ERROR_SUCCESS) return;
415 DbgPrint((DPRINT_REACTOS, "Service %d: '%s'\n", (int)Index, ServiceName));
416
417 /* open driver Key */
418 rc = RegOpenKey(hServiceKey, ServiceName, &hDriverKey);
419
420 /* Read the Start Value */
421 ValueSize = sizeof(ULONG);
422 rc = RegQueryValue(hDriverKey, "Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
423 DbgPrint((DPRINT_REACTOS, " Start: %x \n", (int)StartValue));
424
425 /* Read the Tag */
426 ValueSize = sizeof(ULONG);
427 rc = RegQueryValue(hDriverKey, "Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
428 if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
429 DbgPrint((DPRINT_REACTOS, " Tag: %x \n", (int)TagValue));
430
431 /* Read the driver's group */
432 DriverGroupSize = 256;
433 rc = RegQueryValue(hDriverKey, "Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
434 DbgPrint((DPRINT_REACTOS, " Group: '%s' \n", DriverGroup));
435
436 /* Make sure it should be started */
437 if ((StartValue == 0) &&
438 (TagValue == OrderList[TagIndex]) &&
439 (stricmp(DriverGroup, GroupName) == 0)) {
440
441 /* Get the Driver's Location */
442 ValueSize = 256;
443 rc = RegQueryValue(hDriverKey, "ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
444
445 /* Write the whole path if it suceeded, else prepare to fail */
446 if (rc != ERROR_SUCCESS) {
447 DbgPrint((DPRINT_REACTOS, " ImagePath: not found\n"));
448 strcpy(ImagePath, szSystemRoot);
449 strcat(ImagePath, "system32\\drivers\\");
450 strcat(ImagePath, ServiceName);
451 strcat(ImagePath, ".sys");
452 } else if (TempImagePath[0] != '\\') {
453 strcpy(ImagePath, szSystemRoot);
454 strcat(ImagePath, TempImagePath);
455 } else {
456 strcpy(ImagePath, TempImagePath);
457 DbgPrint((DPRINT_REACTOS, " ImagePath: '%s'\n", ImagePath));
458 }
459
460 DbgPrint((DPRINT_REACTOS, " Loading driver: '%s'\n", ImagePath));
461
462 /* Update the position if needed */
463 if (nPos < 100) nPos += 5;
464
465 FrLdrLoadDriver(ImagePath, nPos);
466
467 } else {
468
469 DbgPrint((DPRINT_REACTOS, " Skipping driver '%s' with Start %d, Tag %d and Group '%s' (Current Tag %d, current group '%s')\n",
470 ServiceName, StartValue, TagValue, DriverGroup, OrderList[TagIndex], GroupName));
471 }
472
473 Index++;
474 }
475 }
476
477 Index = 0;
478 while (TRUE) {
479
480 /* Get the Driver's Name */
481 ValueSize = sizeof(ServiceName);
482 rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize);
483
484 DbgPrint((DPRINT_REACTOS, "RegEnumKey(): rc %d\n", (int)rc));
485 if (rc == ERROR_NO_MORE_ITEMS) break;
486 if (rc != ERROR_SUCCESS) return;
487 DbgPrint((DPRINT_REACTOS, "Service %d: '%s'\n", (int)Index, ServiceName));
488
489 /* open driver Key */
490 rc = RegOpenKey(hServiceKey, ServiceName, &hDriverKey);
491
492 /* Read the Start Value */
493 ValueSize = sizeof(ULONG);
494 rc = RegQueryValue(hDriverKey, "Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
495 DbgPrint((DPRINT_REACTOS, " Start: %x \n", (int)StartValue));
496
497 /* Read the Tag */
498 ValueSize = sizeof(ULONG);
499 rc = RegQueryValue(hDriverKey, "Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
500 if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
501 DbgPrint((DPRINT_REACTOS, " Tag: %x \n", (int)TagValue));
502
503 /* Read the driver's group */
504 DriverGroupSize = 256;
505 rc = RegQueryValue(hDriverKey, "Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
506 DbgPrint((DPRINT_REACTOS, " Group: '%s' \n", DriverGroup));
507
508 for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++) {
509 if (TagValue == OrderList[TagIndex]) break;
510 }
511
512 if ((StartValue == 0) &&
513 (TagIndex > OrderList[0]) &&
514 (stricmp(DriverGroup, GroupName) == 0)) {
515
516 ValueSize = 256;
517 rc = RegQueryValue(hDriverKey, "ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
518 if (rc != ERROR_SUCCESS) {
519 DbgPrint((DPRINT_REACTOS, " ImagePath: not found\n"));
520 strcpy(ImagePath, szSystemRoot);
521 strcat(ImagePath, "system32\\drivers\\");
522 strcat(ImagePath, ServiceName);
523 strcat(ImagePath, ".sys");
524 } else if (TempImagePath[0] != '\\') {
525 strcpy(ImagePath, szSystemRoot);
526 strcat(ImagePath, TempImagePath);
527 } else {
528 strcpy(ImagePath, TempImagePath);
529 DbgPrint((DPRINT_REACTOS, " ImagePath: '%s'\n", ImagePath));
530 }
531 DbgPrint((DPRINT_REACTOS, " Loading driver: '%s'\n", ImagePath));
532
533 if (nPos < 100) nPos += 5;
534
535 FrLdrLoadDriver(ImagePath, nPos);
536
537 } else {
538
539 DbgPrint((DPRINT_REACTOS, " Skipping driver '%s' with Start %d, Tag %d and Group '%s' (Current group '%s')\n",
540 ServiceName, StartValue, TagValue, DriverGroup, GroupName));
541 }
542
543 Index++;
544 }
545
546 /* Move to the next group name */
547 GroupName = GroupName + strlen(GroupName) + 1;
548 }
549 }
550
551 VOID
552 LoadAndBootReactOS(PCHAR OperatingSystemName)
553 {
554 PFILE FilePointer;
555 CHAR name[1024];
556 CHAR value[1024];
557 CHAR SystemPath[1024];
558 CHAR szKernelName[1024];
559 CHAR szHalName[1024];
560 CHAR szFileName[1024];
561 CHAR szBootPath[256];
562 INT i;
563 CHAR MsgBuffer[256];
564 ULONG SectionId;
565
566 ULONG_PTR Base;
567 ULONG Size;
568
569 extern ULONG PageDirectoryStart;
570 extern ULONG PageDirectoryEnd;
571 extern BOOLEAN AcpiPresent;
572
573 //
574 // Open the operating system section
575 // specified in the .ini file
576 //
577 if (!IniOpenSection(OperatingSystemName, &SectionId))
578 {
579 sprintf(MsgBuffer,"Operating System section '%s' not found in freeldr.ini", OperatingSystemName);
580 UiMessageBox(MsgBuffer);
581 return;
582 }
583
584 /*
585 * Setup multiboot information structure
586 */
587 LoaderBlock.Flags = MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_BOOT_DEVICE | MB_INFO_FLAG_COMMAND_LINE | MB_INFO_FLAG_MODULES;
588 LoaderBlock.PageDirectoryStart = (ULONG)&PageDirectoryStart;
589 LoaderBlock.PageDirectoryEnd = (ULONG)&PageDirectoryEnd;
590 LoaderBlock.BootDevice = 0xffffffff;
591 LoaderBlock.CommandLine = (unsigned long)multiboot_kernel_cmdline;
592 LoaderBlock.ModsCount = 0;
593 LoaderBlock.ModsAddr = (unsigned long)multiboot_modules;
594 LoaderBlock.MmapLength = (unsigned long)MachGetMemoryMap((PBIOS_MEMORY_MAP)(PVOID)&multiboot_memory_map, 32) * sizeof(memory_map_t);
595 if (LoaderBlock.MmapLength)
596 {
597 LoaderBlock.MmapAddr = (unsigned long)&multiboot_memory_map;
598 LoaderBlock.Flags |= MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_MEMORY_MAP;
599 multiboot_memory_map_descriptor_size = sizeof(memory_map_t); // GetBiosMemoryMap uses a fixed value of 24
600 DbgPrint((DPRINT_REACTOS, "memory map length: %d\n", LoaderBlock.MmapLength));
601 DbgPrint((DPRINT_REACTOS, "dumping memory map:\n"));
602 for (i=0; i<(LoaderBlock.MmapLength/sizeof(memory_map_t)); i++)
603 {
604 if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
605 0 == multiboot_memory_map[i].base_addr_low)
606 {
607 LoaderBlock.MemLower = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024;
608 if (640 < LoaderBlock.MemLower)
609 {
610 LoaderBlock.MemLower = 640;
611 }
612 }
613 if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
614 multiboot_memory_map[i].base_addr_low <= 1024 * 1024 &&
615 1024 * 1024 <= multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low)
616 {
617 LoaderBlock.MemHigher = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024 - 1024;
618 }
619 DbgPrint((DPRINT_REACTOS, "start: %x\t size: %x\t type %d\n",
620 multiboot_memory_map[i].base_addr_low,
621 multiboot_memory_map[i].length_low,
622 multiboot_memory_map[i].type));
623 }
624 }
625 DbgPrint((DPRINT_REACTOS, "low_mem = %d\n", LoaderBlock.MemLower));
626 DbgPrint((DPRINT_REACTOS, "high_mem = %d\n", LoaderBlock.MemHigher));
627
628 /*
629 * Initialize the registry
630 */
631 RegInitializeRegistry();
632
633 /*
634 * Make sure the system path is set in the .ini file
635 */
636 if (!IniReadSettingByName(SectionId, "SystemPath", SystemPath, sizeof(SystemPath)))
637 {
638 UiMessageBox("System path not specified for selected operating system.");
639 return;
640 }
641
642 /*
643 * Special case for Live CD.
644 */
645 if (!stricmp(SystemPath, "LiveCD"))
646 {
647 /* Normalize */
648 MachDiskGetBootPath(SystemPath, sizeof(SystemPath));
649 strcat(SystemPath, "\\reactos");
650 strcat(strcpy(multiboot_kernel_cmdline, SystemPath),
651 " /MININT");
652 }
653 else
654 {
655 /* copy system path into kernel command line */
656 strcpy(multiboot_kernel_cmdline, SystemPath);
657 }
658
659 /*
660 * Read the optional kernel parameters (if any)
661 */
662 if (IniReadSettingByName(SectionId, "Options", value, 1024))
663 {
664 strcat(multiboot_kernel_cmdline, " ");
665 strcat(multiboot_kernel_cmdline, value);
666 }
667
668
669 UiDrawBackdrop();
670 UiDrawStatusText("Detecting Hardware...");
671
672 /*
673 * Detect hardware
674 */
675 MachHwDetect();
676
677 if (AcpiPresent) LoaderBlock.Flags |= MB_INFO_FLAG_ACPI_TABLE;
678
679 UiDrawStatusText("Loading...");
680 UiDrawProgressBarCenter(0, 100, "Loading ReactOS...");
681
682 /*
683 * Try to open system drive
684 */
685 if (!FsOpenSystemVolume(SystemPath, szBootPath, &LoaderBlock.BootDevice))
686 {
687 UiMessageBox("Failed to open boot drive.");
688 return;
689 }
690
691 /* append a backslash */
692 if ((strlen(szBootPath)==0) ||
693 szBootPath[strlen(szBootPath)] != '\\')
694 strcat(szBootPath, "\\");
695
696 DbgPrint((DPRINT_REACTOS,"SystemRoot: '%s'\n", szBootPath));
697
698 /*
699 * Find the kernel image name
700 * and try to load the kernel off the disk
701 */
702 if(IniReadSettingByName(SectionId, "Kernel", value, 1024))
703 {
704 /*
705 * Set the name and
706 */
707 if (value[0] == '\\')
708 {
709 strcpy(szKernelName, value);
710 }
711 else
712 {
713 strcpy(szKernelName, szBootPath);
714 strcat(szKernelName, "SYSTEM32\\");
715 strcat(szKernelName, value);
716 }
717 }
718 else
719 {
720 strcpy(value, "NTOSKRNL.EXE");
721 strcpy(szKernelName, szBootPath);
722 strcat(szKernelName, "SYSTEM32\\");
723 strcat(szKernelName, value);
724 }
725
726 if (!FrLdrLoadKernel(szKernelName, 5)) return;
727
728 /*
729 * Find the HAL image name
730 * and try to load the kernel off the disk
731 */
732 if(IniReadSettingByName(SectionId, "Hal", value, 1024))
733 {
734 /*
735 * Set the name and
736 */
737 if (value[0] == '\\')
738 {
739 strcpy(szHalName, value);
740 }
741 else
742 {
743 strcpy(szHalName, szBootPath);
744 strcat(szHalName, "SYSTEM32\\");
745 strcat(szHalName, value);
746 }
747 }
748 else
749 {
750 strcpy(value, "HAL.DLL");
751 strcpy(szHalName, szBootPath);
752 strcat(szHalName, "SYSTEM32\\");
753 strcat(szHalName, value);
754 }
755
756 if (!FrLdrLoadDriver(szHalName, 10))
757 return;
758
759 /*
760 * Load the System hive from disk
761 */
762 strcpy(szFileName, szBootPath);
763 strcat(szFileName, "SYSTEM32\\CONFIG\\SYSTEM");
764
765 DbgPrint((DPRINT_REACTOS, "SystemHive: '%s'", szFileName));
766
767 FilePointer = FsOpenFile(szFileName);
768 if (FilePointer == NULL)
769 {
770 UiMessageBox("Could not find the System hive!");
771 return;
772 }
773
774 /*
775 * Update the status bar with the current file
776 */
777 strcpy(name, "Reading ");
778 strcat(name, value);
779 while (strlen(name) < 80)
780 strcat(name, " ");
781 UiDrawStatusText(name);
782
783 /*
784 * Load the System hive
785 */
786 Base = FrLdrLoadModule(FilePointer, szFileName, &Size);
787 if (Base == 0 || Size == 0)
788 {
789 UiMessageBox("Could not load the System hive!\n");
790 return;
791 }
792 DbgPrint((DPRINT_REACTOS, "SystemHive loaded at 0x%x size %u", (unsigned)Base, (unsigned)Size));
793
794 /*
795 * Import the loaded system hive
796 */
797 RegImportBinaryHive((PCHAR)Base, Size);
798
799 /*
800 * Initialize the 'CurrentControlSet' link
801 */
802 RegInitCurrentControlSet(FALSE);
803
804 UiDrawProgressBarCenter(15, 100, "Loading ReactOS...");
805
806 /*
807 * Export the hardware hive
808 */
809 Base = FrLdrCreateModule ("HARDWARE");
810 RegExportBinaryHive ("\\Registry\\Machine\\HARDWARE", (PCHAR)Base, &Size);
811 FrLdrCloseModule (Base, Size);
812
813 UiDrawProgressBarCenter(20, 100, "Loading ReactOS...");
814
815 /*
816 * Load NLS files
817 */
818 if (!FrLdrLoadNlsFiles(szBootPath, MsgBuffer))
819 {
820 UiMessageBox(MsgBuffer);
821 return;
822 }
823 UiDrawProgressBarCenter(30, 100, "Loading ReactOS...");
824
825 /*
826 * Load kernel symbols
827 */
828 LoadKernelSymbols(szKernelName, 30);
829 UiDrawProgressBarCenter(40, 100, "Loading ReactOS...");
830
831 /*
832 * Load boot drivers
833 */
834 FrLdrLoadBootDrivers(szBootPath, 40);
835 UiUnInitialize("Booting ReactOS...");
836
837 /*
838 * Now boot the kernel
839 */
840 DiskStopFloppyMotor();
841 MachVideoPrepareForReactOS();
842 FrLdrStartup(0x2badb002);
843 }
844
845 #undef DbgPrint
846 ULONG
847 DbgPrint(char *Fmt, ...)
848 {
849 UiMessageBox(Fmt);
850 return 0;
851 }
852
853 /* EOF */