IntelFrameworkModulePkg/Universal/BdsDxe/BdsEntry.c

   1 /** @file
   2   This module produce main entry for BDS phase - BdsEntry.
   3   When this module was dispatched by DxeCore, gEfiBdsArchProtocolGuid will be installed
   4   which contains interface of BdsEntry.
   5   After DxeCore finish DXE phase, gEfiBdsArchProtocolGuid->BdsEntry will be invoked
   6   to enter BDS phase.
   7
   8 Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
   9 This program and the accompanying materials
  10 are licensed and made available under the terms and conditions of the BSD License
  11 which accompanies this distribution.  The full text of the license may be found at
  12 http://opensource.org/licenses/bsd-license.php
  13
  14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17 **/
  18
  19 #include "Bds.h"
  20 #include "Language.h"
  21 #include "FrontPage.h"
  22 #include "Hotkey.h"
  23 #include "HwErrRecSupport.h"
  24
  25 ///
  26 /// BDS arch protocol instance initial value.
  27 ///
  28 /// Note: Current BDS not directly get the BootMode, DefaultBoot,
  29 /// TimeoutDefault, MemoryTestLevel value from the BDS arch protocol.
  30 /// Please refer to the library useage of BdsLibGetBootMode, BdsLibGetTimeout
  31 /// and PlatformBdsDiagnostics in BdsPlatform.c
  32 ///
  33 EFI_HANDLE  gBdsHandle = NULL;
  34
  35 EFI_BDS_ARCH_PROTOCOL  gBds = {
  36   BdsEntry
  37 };
  38
  39 UINT16                          *mBootNext = NULL;
  40
  41 /**
  42
  43   Install Boot Device Selection Protocol
  44
  45   @param ImageHandle     The image handle.
  46   @param SystemTable     The system table.
  47
  48   @retval  EFI_SUCEESS  BDS has finished initializing.
  49                         Return the dispatcher and recall BDS.Entry
  50   @retval  Other        Return status from AllocatePool() or gBS->InstallProtocolInterface
  51
  52 **/
  53 EFI_STATUS
  54 EFIAPI
  55 BdsInitialize (
  56   IN EFI_HANDLE                            ImageHandle,
  57   IN EFI_SYSTEM_TABLE                      *SystemTable
  58   )
  59 {
  60   EFI_STATUS  Status;
  61
  62   //
  63   // Install protocol interface
  64   //
  65   Status = gBS->InstallMultipleProtocolInterfaces (
  66                   &gBdsHandle,
  67                   &gEfiBdsArchProtocolGuid, &gBds,
  68                   NULL
  69                   );
  70   ASSERT_EFI_ERROR (Status);
  71
  72   return Status;
  73 }
  74
  75 /**
  76
  77   This function attempts to boot for the boot order specified
  78   by platform policy.
  79
  80 **/
  81 VOID
  82 BdsBootDeviceSelect (
  83   VOID
  84   )
  85 {
  86   EFI_STATUS        Status;
  87   LIST_ENTRY        *Link;
  88   BDS_COMMON_OPTION *BootOption;
  89   UINTN             ExitDataSize;
  90   CHAR16            *ExitData;
  91   UINT16            Timeout;
  92   LIST_ENTRY        BootLists;
  93   CHAR16            Buffer[20];
  94   BOOLEAN           BootNextExist;
  95   LIST_ENTRY        *LinkBootNext;
  96
  97   //
  98   // Got the latest boot option
  99   //
 100   BootNextExist = FALSE;
 101   LinkBootNext  = NULL;
 102   InitializeListHead (&BootLists);
 103
 104   //
 105   // First check the boot next option
 106   //
 107   ZeroMem (Buffer, sizeof (Buffer));
 108
 109   if (mBootNext != NULL) {
 110     //
 111     // Indicate we have the boot next variable, so this time
 112     // boot will always have this boot option
 113     //
 114     BootNextExist = TRUE;
 115
 116     //
 117     // Clear the this variable so it's only exist in this time boot
 118     //
 119     gRT->SetVariable (
 120           L"BootNext",
 121           &gEfiGlobalVariableGuid,
 122           EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 123           0,
 124           mBootNext
 125           );
 126
 127     //
 128     // Add the boot next boot option
 129     //
 130     UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", *mBootNext);
 131     BootOption = BdsLibVariableToOption (&BootLists, Buffer);
 132
 133     //
 134     // If fail to get boot option from variable, just return and do nothing.
 135     //
 136     if (BootOption == NULL) {
 137       return;
 138     }
 139
 140     BootOption->BootCurrent = *mBootNext;
 141   }
 142   //
 143   // Parse the boot order to get boot option
 144   //
 145   BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
 146
 147   //
 148   // When we didn't have chance to build boot option variables in the first
 149   // full configuration boot (e.g.: Reset in the first page or in Device Manager),
 150   // we have no boot options in the following mini configuration boot.
 151   // Give the last chance to enumerate the boot options.
 152   //
 153   if (IsListEmpty (&BootLists)) {
 154     BdsLibEnumerateAllBootOption (&BootLists);
 155   }
 156
 157   Link = BootLists.ForwardLink;
 158
 159   //
 160   // Parameter check, make sure the loop will be valid
 161   //
 162   if (Link == NULL) {
 163     return ;
 164   }
 165   //
 166   // Here we make the boot in a loop, every boot success will
 167   // return to the front page
 168   //
 169   for (;;) {
 170     //
 171     // Check the boot option list first
 172     //
 173     if (Link == &BootLists) {
 174       //
 175       // There are two ways to enter here:
 176       // 1. There is no active boot option, give user chance to
 177       //    add new boot option
 178       // 2. All the active boot option processed, and there is no
 179       //    one is success to boot, then we back here to allow user
 180       //    add new active boot option
 181       //
 182       Timeout = 0xffff;
 183       PlatformBdsEnterFrontPage (Timeout, FALSE);
 184       InitializeListHead (&BootLists);
 185       BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
 186       Link = BootLists.ForwardLink;
 187       continue;
 188     }
 189     //
 190     // Get the boot option from the link list
 191     //
 192     BootOption = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
 193
 194     //
 195     // According to EFI Specification, if a load option is not marked
 196     // as LOAD_OPTION_ACTIVE, the boot manager will not automatically
 197     // load the option.
 198     //
 199     if (!IS_LOAD_OPTION_TYPE (BootOption->Attribute, LOAD_OPTION_ACTIVE)) {
 200       //
 201       // skip the header of the link list, because it has no boot option
 202       //
 203       Link = Link->ForwardLink;
 204       continue;
 205     }
 206     //
 207     // Make sure the boot option device path connected,
 208     // but ignore the BBS device path
 209     //
 210     if (DevicePathType (BootOption->DevicePath) != BBS_DEVICE_PATH) {
 211       //
 212       // Notes: the internal shell can not been connected with device path
 213       // so we do not check the status here
 214       //
 215       BdsLibConnectDevicePath (BootOption->DevicePath);
 216     }
 217
 218     //
 219     // Restore to original mode before launching boot option.
 220     //
 221     BdsSetConsoleMode (FALSE);
 222
 223     //
 224     // All the driver options should have been processed since
 225     // now boot will be performed.
 226     //
 227     Status = BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);
 228     if (Status != EFI_SUCCESS) {
 229       //
 230       // Call platform action to indicate the boot fail
 231       //
 232       BootOption->StatusString = GetStringById (STRING_TOKEN (STR_BOOT_FAILED));
 233       PlatformBdsBootFail (BootOption, Status, ExitData, ExitDataSize);
 234
 235       //
 236       // Check the next boot option
 237       //
 238       Link = Link->ForwardLink;
 239
 240     } else {
 241       //
 242       // Call platform action to indicate the boot success
 243       //
 244       BootOption->StatusString = GetStringById (STRING_TOKEN (STR_BOOT_SUCCEEDED));
 245       PlatformBdsBootSuccess (BootOption);
 246
 247       //
 248       // Boot success, then stop process the boot order, and
 249       // present the boot manager menu, front page
 250       //
 251       Timeout = 0xffff;
 252       PlatformBdsEnterFrontPage (Timeout, FALSE);
 253
 254       //
 255       // Rescan the boot option list, avoid potential risk of the boot
 256       // option change in front page
 257       //
 258       if (BootNextExist) {
 259         LinkBootNext = BootLists.ForwardLink;
 260       }
 261
 262       InitializeListHead (&BootLists);
 263       if (LinkBootNext != NULL) {
 264         //
 265         // Reserve the boot next option
 266         //
 267         InsertTailList (&BootLists, LinkBootNext);
 268       }
 269
 270       BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
 271       Link = BootLists.ForwardLink;
 272     }
 273   }
 274
 275 }
 276
 277 /**
 278
 279   Validate input console variable data.
 280
 281   If found the device path is not a valid device path, remove the variable.
 282
 283   @param VariableName             Input console variable name.
 284
 285 **/
 286 VOID
 287 BdsFormalizeConsoleVariable (
 288   IN  CHAR16          *VariableName
 289   )
 290 {
 291   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 292   UINTN                     VariableSize;
 293   EFI_STATUS                Status;
 294
 295   DevicePath = BdsLibGetVariableAndSize (
 296                       VariableName,
 297                       &gEfiGlobalVariableGuid,
 298                       &VariableSize
 299                       );
 300   if ((DevicePath != NULL) && !IsDevicePathValid (DevicePath, VariableSize)) {
 301     Status = gRT->SetVariable (
 302                     VariableName,
 303                     &gEfiGlobalVariableGuid,
 304                     EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 305                     0,
 306                     NULL
 307                     );
 308     ASSERT_EFI_ERROR (Status);
 309   }
 310 }
 311
 312 /**
 313
 314   Formalize Bds global variables.
 315
 316  1. For ConIn/ConOut/ConErr, if found the device path is not a valid device path, remove the variable.
 317  2. For OsIndicationsSupported, Create a BS/RT/UINT64 variable to report caps
 318  3. Delete OsIndications variable if it is not NV/BS/RT UINT64
 319  Item 3 is used to solve case when OS corrupts OsIndications. Here simply delete this NV variable.
 320
 321 **/
 322 VOID
 323 BdsFormalizeEfiGlobalVariable (
 324   VOID
 325   )
 326 {
 327   EFI_STATUS Status;
 328   UINT64     OsIndicationSupport;
 329   UINT64     OsIndication;
 330   UINTN      DataSize;
 331   UINT32     Attributes;
 332
 333   //
 334   // Validate Console variable.
 335   //
 336   BdsFormalizeConsoleVariable (L"ConIn");
 337   BdsFormalizeConsoleVariable (L"ConOut");
 338   BdsFormalizeConsoleVariable (L"ErrOut");
 339
 340   //
 341   // OS indicater support variable
 342   //
 343   OsIndicationSupport = EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
 344   Status = gRT->SetVariable (
 345                   L"OsIndicationsSupported",
 346                   &gEfiGlobalVariableGuid,
 347                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 348                   sizeof(UINT64),
 349                   &OsIndicationSupport
 350                   );
 351   ASSERT_EFI_ERROR (Status);
 352
 353   //
 354   // If OsIndications is invalid, remove it.
 355   // Invalid case
 356   //   1. Data size != UINT64
 357   //   2. OsIndication value inconsistence
 358   //   3. OsIndication attribute inconsistence
 359   //
 360   OsIndication = 0;
 361   Attributes = 0;
 362   DataSize = sizeof(UINT64);
 363   Status = gRT->GetVariable (
 364                   L"OsIndications",
 365                   &gEfiGlobalVariableGuid,
 366                   &Attributes,
 367                   &DataSize,
 368                   &OsIndication
 369                   );
 370
 371   if (!EFI_ERROR(Status)) {
 372     if (DataSize != sizeof(UINT64) ||
 373         (OsIndication & ~OsIndicationSupport) != 0 ||
 374         Attributes != (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE)){
 375
 376       DEBUG ((EFI_D_ERROR, "Unformalized OsIndications variable exists. Delete it\n"));
 377       Status = gRT->SetVariable (
 378                       L"OsIndications",
 379                       &gEfiGlobalVariableGuid,
 380                       Attributes,
 381                       0,
 382                       &OsIndication
 383                       );
 384       ASSERT_EFI_ERROR (Status);
 385     }
 386   }
 387
 388 }
 389
 390 /**
 391
 392   Service routine for BdsInstance->Entry(). Devices are connected, the
 393   consoles are initialized, and the boot options are tried.
 394
 395   @param This             Protocol Instance structure.
 396
 397 **/
 398 VOID
 399 EFIAPI
 400 BdsEntry (
 401   IN EFI_BDS_ARCH_PROTOCOL  *This
 402   )
 403 {
 404   LIST_ENTRY                      DriverOptionList;
 405   LIST_ENTRY                      BootOptionList;
 406   UINTN                           BootNextSize;
 407   CHAR16                          *FirmwareVendor;
 408
 409   //
 410   // Insert the performance probe
 411   //
 412   PERF_END (NULL, "DXE", NULL, 0);
 413   PERF_START (NULL, "BDS", NULL, 0);
 414
 415   //
 416   // Initialize the global system boot option and driver option
 417   //
 418   InitializeListHead (&DriverOptionList);
 419   InitializeListHead (&BootOptionList);
 420
 421   //
 422   // Initialize hotkey service
 423   //
 424   InitializeHotkeyService ();
 425
 426   //
 427   // Fill in FirmwareVendor and FirmwareRevision from PCDs
 428   //
 429   FirmwareVendor = (CHAR16 *)PcdGetPtr (PcdFirmwareVendor);
 430   gST->FirmwareVendor = AllocateRuntimeCopyPool (StrSize (FirmwareVendor), FirmwareVendor);
 431   ASSERT (gST->FirmwareVendor != NULL);
 432   gST->FirmwareRevision = PcdGet32 (PcdFirmwareRevision);
 433
 434   //
 435   // Fixup Tasble CRC after we updated Firmware Vendor and Revision
 436   //
 437   gBS->CalculateCrc32 ((VOID *)gST, sizeof(EFI_SYSTEM_TABLE), &gST->Hdr.CRC32);
 438
 439   //
 440   // Validate Variable.
 441   //
 442   BdsFormalizeEfiGlobalVariable();
 443
 444   //
 445   // Do the platform init, can be customized by OEM/IBV
 446   //
 447   PERF_START (NULL, "PlatformBds", "BDS", 0);
 448   PlatformBdsInit ();
 449
 450   InitializeHwErrRecSupport();
 451
 452   //
 453   // bugbug: platform specific code
 454   // Initialize the platform specific string and language
 455   //
 456   InitializeStringSupport ();
 457   InitializeLanguage (TRUE);
 458   InitializeFrontPage (TRUE);
 459
 460   //
 461   // Set up the device list based on EFI 1.1 variables
 462   // process Driver#### and Load the driver's in the
 463   // driver option list
 464   //
 465   BdsLibBuildOptionFromVar (&DriverOptionList, L"DriverOrder");
 466   if (!IsListEmpty (&DriverOptionList)) {
 467     BdsLibLoadDrivers (&DriverOptionList);
 468   }
 469   //
 470   // Check if we have the boot next option
 471   //
 472   mBootNext = BdsLibGetVariableAndSize (
 473                 L"BootNext",
 474                 &gEfiGlobalVariableGuid,
 475                 &BootNextSize
 476                 );
 477
 478   //
 479   // Setup some platform policy here
 480   //
 481   PlatformBdsPolicyBehavior (&DriverOptionList, &BootOptionList, BdsProcessCapsules, BdsMemoryTest);
 482   PERF_END (NULL, "PlatformBds", "BDS", 0);
 483
 484   //
 485   // BDS select the boot device to load OS
 486   //
 487   BdsBootDeviceSelect ();
 488
 489   //
 490   // Only assert here since this is the right behavior, we should never
 491   // return back to DxeCore.
 492   //
 493   ASSERT (FALSE);
 494
 495   return ;
 496 }