reactos/boot/freeldr/freeldr/reactos/reactos.c

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