[mirror_edk2.git] / MdeModulePkg / Library / GenericBdsLib / BdsBoot.c

/** @file\r
  BDS Lib functions which relate with create or process the boot\r
  option.\r
\r
Copyright (c) 2004 - 2008, Intel Corporation. <BR>\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "InternalBdsLib.h"\r
\r
BOOLEAN mEnumBootDevice = FALSE;\r
\r
//\r
// This GUID is used for an EFI Variable that stores the front device pathes\r
// for a partial device path that starts with the HD node.\r
//\r
EFI_GUID  mHdBootVariablePrivateGuid = { 0xfab7e9e1, 0x39dd, 0x4f2b, { 0x84, 0x8, 0xe2, 0xe, 0x90, 0x6c, 0xb6, 0xde } };\r
\r
\r
\r
/**\r
  Boot the legacy system with the boot option\r
\r
  @param  Option                 The legacy boot option which have BBS device path\r
\r
  @retval EFI_UNSUPPORTED        There is no legacybios protocol, do not support\r
                                 legacy boot.\r
  @retval EFI_STATUS             Return the status of LegacyBios->LegacyBoot ().\r
\r
**/\r
EFI_STATUS\r
BdsLibDoLegacyBoot (\r
  IN  BDS_COMMON_OPTION           *Option\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;\r
\r
  Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // If no LegacyBios protocol we do not support legacy boot\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
  //\r
  // Notes: if we seperate the int 19, then we don't need to refresh BBS\r
  //\r
  BdsRefreshBbsTableForBoot (Option);\r
\r
  //\r
  // Write boot to OS performance data to a file\r
  //\r
  PERF_CODE (\r
    WriteBootToOsPerformanceData ();\r
  );\r
\r
  DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Legacy Boot: %S\n", Option->Description));\r
  return LegacyBios->LegacyBoot (\r
                      LegacyBios,\r
                      (BBS_BBS_DEVICE_PATH *) Option->DevicePath,\r
                      Option->LoadOptionsSize,\r
                      Option->LoadOptions\r
                      );\r
}\r
\r
\r
/**\r
  Process the boot option follow the EFI 1.1 specification and\r
  special treat the legacy boot option with BBS_DEVICE_PATH.\r
\r
  @param  Option                 The boot option need to be processed\r
  @param  DevicePath             The device path which describe where to load the\r
                                 boot image or the legcy BBS device path to boot\r
                                 the legacy OS\r
  @param  ExitDataSize           Returned directly from gBS->StartImage ()\r
  @param  ExitData               Returned directly from gBS->StartImage ()\r
\r
  @retval EFI_SUCCESS            Status from gBS->StartImage ()\r
  @retval EFI_NOT_FOUND          If the Device Path is not found in the system\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
BdsLibBootViaBootOption (\r
  IN  BDS_COMMON_OPTION             * Option,\r
  IN  EFI_DEVICE_PATH_PROTOCOL      * DevicePath,\r
  OUT UINTN                         *ExitDataSize,\r
  OUT CHAR16                        **ExitData OPTIONAL\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_HANDLE                Handle;\r
  EFI_HANDLE                ImageHandle;\r
  EFI_DEVICE_PATH_PROTOCOL  *FilePath;\r
  EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;\r
  EFI_DEVICE_PATH_PROTOCOL  *WorkingDevicePath;\r
  EFI_ACPI_S3_SAVE_PROTOCOL *AcpiS3Save;\r
  LIST_ENTRY                TempBootLists;\r
\r
  //\r
  // Record the performance data for End of BDS\r
  //\r
  PERF_END (0, BDS_TOK, NULL, 0);\r
\r
  *ExitDataSize = 0;\r
  *ExitData     = NULL;\r
\r
  //\r
  // Notes: put EFI64 ROM Shadow Solution\r
  //\r
  EFI64_SHADOW_ALL_LEGACY_ROM ();\r
\r
  //\r
  // Notes: this code can be remove after the s3 script table\r
  // hook on the event EFI_EVENT_SIGNAL_READY_TO_BOOT or\r
  // EFI_EVENT_SIGNAL_LEGACY_BOOT\r
  //\r
  Status = gBS->LocateProtocol (&gEfiAcpiS3SaveProtocolGuid, NULL, (VOID **) &AcpiS3Save);\r
  if (!EFI_ERROR (Status)) {\r
    AcpiS3Save->S3Save (AcpiS3Save, NULL);\r
  }\r
  //\r
  // If it's Device Path that starts with a hard drive path, append it with the front part to compose a\r
  // full device path\r
  //\r
  WorkingDevicePath = NULL;\r
  if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&\r
      (DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)) {\r
    WorkingDevicePath = BdsExpandPartitionPartialDevicePathToFull (\r
                          (HARDDRIVE_DEVICE_PATH *)DevicePath\r
                          );\r
    if (WorkingDevicePath != NULL) {\r
      DevicePath = WorkingDevicePath;\r
    }\r
  }\r
  //\r
  // Signal the EFI_EVENT_SIGNAL_READY_TO_BOOT event\r
  //\r
  EfiSignalEventReadyToBoot();\r
  \r
  \r
  //\r
  // Set Boot Current\r
  //\r
  gRT->SetVariable (\r
        L"BootCurrent",\r
        &gEfiGlobalVariableGuid,\r
        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
        sizeof (UINT16),\r
        &Option->BootCurrent\r
        );\r
\r
  if ((DevicePathType (Option->DevicePath) == BBS_DEVICE_PATH) &&\r
      (DevicePathSubType (Option->DevicePath) == BBS_BBS_DP)\r
    ) {\r
    //\r
    // Check to see if we should legacy BOOT. If yes then do the legacy boot\r
    //\r
    return BdsLibDoLegacyBoot (Option);\r
  }\r
\r
  //\r
  // If the boot option point to Internal FV shell, make sure it is valid\r
  //\r
  Status = BdsLibUpdateFvFileDevicePath (&DevicePath, &gEfiShellFileGuid);\r
  if (!EFI_ERROR(Status)) {\r
    if (Option->DevicePath != NULL) {\r
      SafeFreePool(Option->DevicePath);\r
    }\r
    Option->DevicePath  = AllocateZeroPool (GetDevicePathSize (DevicePath));\r
    CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));\r
    //\r
    // Update the shell boot option\r
    //\r
    InitializeListHead (&TempBootLists);\r
    BdsLibRegisterNewOption (&TempBootLists, DevicePath, L"EFI Internal Shell", L"BootOrder");\r
  }\r
\r
  //\r
  // Drop the TPL level from TPL_APPLICATION to TPL_APPLICATION\r
  //\r
  gBS->RestoreTPL (TPL_APPLICATION);\r
\r
  DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting EFI way %S\n", Option->Description));\r
\r
  Status = gBS->LoadImage (\r
                  TRUE,\r
                  mBdsImageHandle,\r
                  DevicePath,\r
                  NULL,\r
                  0,\r
                  &ImageHandle\r
                  );\r
\r
  //\r
  // If we didn't find an image directly, we need to try as if it is a removable device boot opotion\r
  // and load the image according to the default boot behavior for removable device.\r
  //\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // check if there is a bootable removable media could be found in this device path ,\r
    // and get the bootable media handle\r
    //\r
    Handle = BdsLibGetBootableHandle(DevicePath);\r
    if (Handle == NULL) {\r
       goto Done;\r
    }\r
    //\r
    // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media\r
    //  machinename is ia32, ia64, x64, ...\r
    //\r
    FilePath = FileDevicePath (Handle, DEFAULT_REMOVABLE_FILE_NAME);\r
    if (FilePath) {\r
      Status = gBS->LoadImage (\r
                      TRUE,\r
                      mBdsImageHandle,\r
                      FilePath,\r
                      NULL,\r
                      0,\r
                      &ImageHandle\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        //\r
        // The DevicePath failed, and it's not a valid\r
        // removable media device.\r
        //\r
        goto Done;\r
      }\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // It there is any error from the Boot attempt exit now.\r
    //\r
    goto Done;\r
  }\r
  //\r
  // Provide the image with it's load options\r
  //\r
  Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (Option->LoadOptionsSize != 0) {\r
    ImageInfo->LoadOptionsSize  = Option->LoadOptionsSize;\r
    ImageInfo->LoadOptions      = Option->LoadOptions;\r
  }\r
  //\r
  // Before calling the image, enable the Watchdog Timer for\r
  // the 5 Minute period\r
  //\r
  gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);\r
\r
  Status = gBS->StartImage (ImageHandle, ExitDataSize, ExitData);\r
  DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Image Return Status = %r\n", Status));\r
\r
  //\r
  // Clear the Watchdog Timer after the image returns\r
  //\r
  gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);\r
\r
Done:\r
  //\r
  // Clear Boot Current\r
  //\r
  gRT->SetVariable (\r
        L"BootCurrent",\r
        &gEfiGlobalVariableGuid,\r
        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
        0,\r
        &Option->BootCurrent\r
        );\r
\r
  //\r
  // Raise the TPL level back to TPL_APPLICATION\r
  //\r
  gBS->RaiseTPL (TPL_APPLICATION);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Expand a device path that starts with a hard drive media device path node to be a\r
  full device path that includes the full hardware path to the device. We need\r
  to do this so it can be booted. As an optimizaiton the front match (the part point\r
  to the partition node. E.g. ACPI() /PCI()/ATA()/Partition() ) is saved in a variable\r
  so a connect all is not required on every boot. All successful history device path\r
  which point to partition node (the front part) will be saved.\r
\r
  @param  HardDriveDevicePath    EFI Device Path to boot, if it starts with a hard\r
                                 drive media device path.\r
  @return A Pointer to the full device path or NULL if a valid Hard Drive devic path\r
          cannot be found.\r
\r
**/\r
EFI_DEVICE_PATH_PROTOCOL *\r
EFIAPI\r
BdsExpandPartitionPartialDevicePathToFull (\r
  IN  HARDDRIVE_DEVICE_PATH      *HardDriveDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINTN                     BlockIoHandleCount;\r
  EFI_HANDLE                *BlockIoBuffer;\r
  EFI_DEVICE_PATH_PROTOCOL  *FullDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *BlockIoDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  UINTN                     Index;\r
  UINTN                     InstanceNum;\r
  EFI_DEVICE_PATH_PROTOCOL  *CachedDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *TempNewDevicePath;\r
  UINTN                     CachedDevicePathSize;\r
  BOOLEAN                   DeviceExist;\r
  BOOLEAN                   NeedAdjust;\r
  EFI_DEVICE_PATH_PROTOCOL  *Instance;\r
  UINTN                     Size;\r
\r
  FullDevicePath = NULL;\r
  //\r
  // Check if there is prestore 'HDDP' variable.\r
  // If exist, search the front path which point to partition node in the variable instants.\r
  // If fail to find or 'HDDP' not exist, reconnect all and search in all system\r
  //\r
  CachedDevicePath = BdsLibGetVariableAndSize (\r
                      L"HDDP",\r
                      &mHdBootVariablePrivateGuid,\r
                      &CachedDevicePathSize\r
                      );\r
  if (CachedDevicePath != NULL) {\r
    TempNewDevicePath = CachedDevicePath;\r
    DeviceExist = FALSE;\r
    NeedAdjust = FALSE;\r
    do {\r
      //\r
      // Check every instance of the variable\r
      // First, check wheather the instance contain the partition node, which is needed for distinguishing  multi\r
      // partial partition boot option. Second, check wheather the instance could be connected.\r
      //\r
      Instance  = GetNextDevicePathInstance (&TempNewDevicePath, &Size);\r
      if (MatchPartitionDevicePathNode (Instance, HardDriveDevicePath)) {\r
        //\r
        // Connect the device path instance, the device path point to hard drive media device path node\r
        // e.g. ACPI() /PCI()/ATA()/Partition()\r
        //\r
        Status = BdsLibConnectDevicePath (Instance);\r
        if (!EFI_ERROR (Status)) {\r
          DeviceExist = TRUE;\r
          break;\r
        }\r
      }\r
      //\r
      // Come here means the first instance is not matched\r
      //\r
      NeedAdjust = TRUE;\r
      SafeFreePool(Instance);\r
    } while (TempNewDevicePath != NULL);\r
\r
    if (DeviceExist) {\r
      //\r
      // Find the matched device path.\r
      // Append the file path infomration from the boot option and return the fully expanded device path.\r
      //\r
      DevicePath    = NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);\r
      FullDevicePath = AppendDevicePath (Instance, DevicePath);\r
\r
      //\r
      // Adjust the 'HDDP' instances sequense if the matched one is not first one.\r
      //\r
      if (NeedAdjust) {\r
        //\r
        // First delete the matched instance.\r
        //\r
        TempNewDevicePath = CachedDevicePath;\r
        CachedDevicePath = BdsLibDelPartMatchInstance ( CachedDevicePath, Instance );\r
        SafeFreePool (TempNewDevicePath);\r
        //\r
        // Second, append the remaining parth after the matched instance\r
        //\r
        TempNewDevicePath = CachedDevicePath;\r
        CachedDevicePath = AppendDevicePathInstance ( Instance, CachedDevicePath );\r
        SafeFreePool (TempNewDevicePath);\r
        //\r
        // Save the matching Device Path so we don't need to do a connect all next time\r
        //\r
        Status = gRT->SetVariable (\r
                        L"HDDP",\r
                        &mHdBootVariablePrivateGuid,\r
                        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
                        GetDevicePathSize (CachedDevicePath),\r
                        CachedDevicePath\r
                        );\r
      }\r
      SafeFreePool(Instance);\r
      gBS->FreePool (CachedDevicePath);\r
      return FullDevicePath;\r
    }\r
  }\r
\r
  //\r
  // If we get here we fail to find or 'HDDP' not exist, and now we need\r
  // to seach all devices in the system for a matched partition\r
  //\r
  BdsLibConnectAllDriversToAllControllers ();\r
  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &BlockIoHandleCount, &BlockIoBuffer);\r
  if (EFI_ERROR (Status) || BlockIoHandleCount == 0) {\r
    //\r
    // If there was an error or there are no device handles that support\r
    // the BLOCK_IO Protocol, then return.\r
    //\r
    return NULL;\r
  }\r
  //\r
  // Loop through all the device handles that support the BLOCK_IO Protocol\r
  //\r
  for (Index = 0; Index < BlockIoHandleCount; Index++) {\r
\r
    Status = gBS->HandleProtocol (BlockIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &BlockIoDevicePath);\r
    if (EFI_ERROR (Status) || BlockIoDevicePath == NULL) {\r
      continue;\r
    }\r
\r
    if (MatchPartitionDevicePathNode (BlockIoDevicePath, HardDriveDevicePath)) {\r
      //\r
      // Find the matched partition device path\r
      //\r
      DevicePath    = NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);\r
      FullDevicePath = AppendDevicePath (BlockIoDevicePath, DevicePath);\r
\r
      //\r
      // Save the matched patition device path in 'HDDP' variable\r
      //\r
      if (CachedDevicePath != NULL) {\r
        //\r
        // Save the matched patition device path as first instance of 'HDDP' variable\r
        //\r
        if (BdsLibMatchDevicePaths (CachedDevicePath, BlockIoDevicePath)) {\r
          TempNewDevicePath = CachedDevicePath;\r
          CachedDevicePath = BdsLibDelPartMatchInstance (CachedDevicePath, BlockIoDevicePath);\r
          SafeFreePool(TempNewDevicePath);\r
\r
          TempNewDevicePath = CachedDevicePath;\r
          CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);\r
          SafeFreePool(TempNewDevicePath);\r
        } else {\r
          TempNewDevicePath = CachedDevicePath;\r
          CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);\r
          SafeFreePool(TempNewDevicePath);\r
        }\r
        //\r
        // Here limit the device path instance number to 12, which is max number for a system support 3 IDE controller\r
        // If the user try to boot many OS in different HDs or partitions, in theary, the 'HDDP' variable maybe become larger and larger.\r
        //\r
        InstanceNum = 0;\r
        TempNewDevicePath = CachedDevicePath;\r
        while (!IsDevicePathEnd (TempNewDevicePath)) {\r
          TempNewDevicePath = NextDevicePathNode (TempNewDevicePath);\r
          //\r
          // Parse one instance\r
          //\r
          while (!IsDevicePathEndType (TempNewDevicePath)) {\r
            TempNewDevicePath = NextDevicePathNode (TempNewDevicePath);\r
          }\r
          InstanceNum++;\r
          //\r
          // If the CachedDevicePath variable contain too much instance, only remain 12 instances.\r
          //\r
          if (InstanceNum >= 12) {\r
            SetDevicePathEndNode (TempNewDevicePath);\r
            break;\r
          }\r
        }\r
      } else {\r
        CachedDevicePath = DuplicateDevicePath (BlockIoDevicePath);\r
      }\r
\r
      //\r
      // Save the matching Device Path so we don't need to do a connect all next time\r
      //\r
      Status = gRT->SetVariable (\r
                      L"HDDP",\r
                      &mHdBootVariablePrivateGuid,\r
                      EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
                      GetDevicePathSize (CachedDevicePath),\r
                      CachedDevicePath\r
                      );\r
\r
      break;\r
    }\r
  }\r
  gBS->FreePool (CachedDevicePath);\r
  gBS->FreePool (BlockIoBuffer);\r
  return FullDevicePath;\r
}\r
\r
\r
/**\r
  Check whether there is a instance in BlockIoDevicePath, which contain multi device path\r
  instances, has the same partition node with HardDriveDevicePath device path\r
\r
  @param  BlockIoDevicePath      Multi device path instances which need to check\r
  @param  HardDriveDevicePath    A device path which starts with a hard drive media\r
                                 device path.\r
\r
  @retval TRUE                   There is a matched device path instance FALSE\r
                                 -There is no matched device path instance\r
\r
**/\r
BOOLEAN\r
EFIAPI\r
MatchPartitionDevicePathNode (\r
  IN  EFI_DEVICE_PATH_PROTOCOL   *BlockIoDevicePath,\r
  IN  HARDDRIVE_DEVICE_PATH      *HardDriveDevicePath\r
  )\r
{\r
  HARDDRIVE_DEVICE_PATH     *TmpHdPath;\r
  HARDDRIVE_DEVICE_PATH     *TempPath;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  BOOLEAN                   Match;\r
  EFI_DEVICE_PATH_PROTOCOL  *BlockIoHdDevicePathNode;\r
\r
  if ((BlockIoDevicePath == NULL) || (HardDriveDevicePath == NULL)) {\r
    return FALSE;\r
  }\r
  //\r
  // Make PreviousDevicePath == the device path node before the end node\r
  //\r
  DevicePath          = BlockIoDevicePath;\r
  BlockIoHdDevicePathNode = NULL;\r
\r
  //\r
  // find the partition device path node\r
  //\r
  while (!IsDevicePathEnd (DevicePath)) {\r
    if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&\r
        (DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)\r
        ) {\r
      BlockIoHdDevicePathNode = DevicePath;\r
      break;\r
    }\r
\r
    DevicePath = NextDevicePathNode (DevicePath);\r
  }\r
\r
  if (BlockIoHdDevicePathNode == NULL) {\r
    return FALSE;\r
  }\r
  //\r
  // See if the harddrive device path in blockio matches the orig Hard Drive Node\r
  //\r
  TmpHdPath = (HARDDRIVE_DEVICE_PATH *) BlockIoHdDevicePathNode;\r
  TempPath  = (HARDDRIVE_DEVICE_PATH *) BdsLibUnpackDevicePath ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);\r
  Match = FALSE;\r
  //\r
  // Check for the match\r
  //\r
  if ((TmpHdPath->MBRType == TempPath->MBRType) &&\r
      (TmpHdPath->SignatureType == TempPath->SignatureType)) {\r
    switch (TmpHdPath->SignatureType) {\r
    case SIGNATURE_TYPE_GUID:\r
      Match = CompareGuid ((EFI_GUID *)TmpHdPath->Signature, (EFI_GUID *)TempPath->Signature);\r
      break;\r
    case SIGNATURE_TYPE_MBR:\r
      Match = (BOOLEAN)(*((UINT32 *)(&(TmpHdPath->Signature[0]))) == *(UINT32 *)(&(TempPath->Signature[0])));\r
      break;\r
    default:\r
      Match = FALSE;\r
      break;\r
    }\r
  }\r
\r
  return Match;\r
}\r
\r
\r
/**\r
  Delete the boot option associated with the handle passed in\r
\r
  @param  Handle                 The handle which present the device path to create\r
                                 boot option\r
\r
  @retval EFI_SUCCESS            Delete the boot option success\r
  @retval EFI_NOT_FOUND          If the Device Path is not found in the system\r
  @retval EFI_OUT_OF_RESOURCES   Lack of memory resource\r
  @retval Other                  Error return value from SetVariable()\r
\r
**/\r
EFI_STATUS\r
BdsLibDeleteOptionFromHandle (\r
  IN  EFI_HANDLE                 Handle\r
  )\r
{\r
  UINT16                    *BootOrder;\r
  UINT8                     *BootOptionVar;\r
  UINTN                     BootOrderSize;\r
  UINTN                     BootOptionSize;\r
  EFI_STATUS                Status;\r
  UINTN                     Index;\r
  UINT16                    BootOption[BOOT_OPTION_MAX_CHAR];\r
  UINTN                     DevicePathSize;\r
  UINTN                     OptionDevicePathSize;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *OptionDevicePath;\r
  UINT8                     *TempPtr;\r
\r
  Status        = EFI_SUCCESS;\r
  BootOrder     = NULL;\r
  BootOrderSize = 0;\r
\r
  BootOrder = BdsLibGetVariableAndSize (\r
                L"BootOrder",\r
                &gEfiGlobalVariableGuid,\r
                &BootOrderSize\r
                );\r
  if (NULL == BootOrder) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  DevicePath = DevicePathFromHandle (Handle);\r
  if (DevicePath == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
  DevicePathSize = GetDevicePathSize (DevicePath);\r
\r
  Index = 0;\r
  while (Index < BootOrderSize / sizeof (UINT16)) {\r
    UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);\r
    BootOptionVar = BdsLibGetVariableAndSize (\r
                      BootOption,\r
                      &gEfiGlobalVariableGuid,\r
                      &BootOptionSize\r
                      );\r
    if (NULL == BootOptionVar) {\r
      gBS->FreePool (BootOrder);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    TempPtr = BootOptionVar;\r
    TempPtr += sizeof (UINT32) + sizeof (UINT16);\r
    TempPtr += StrSize ((CHAR16 *) TempPtr);\r
    OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;\r
    OptionDevicePathSize = GetDevicePathSize (OptionDevicePath);\r
\r
    //\r
    // Check whether the device path match\r
    //\r
    if ((OptionDevicePathSize == DevicePathSize) &&\r
        (CompareMem (DevicePath, OptionDevicePath, DevicePathSize) == 0)) {\r
      BdsDeleteBootOption (BootOrder[Index], BootOrder, &BootOrderSize);\r
      gBS->FreePool (BootOptionVar);\r
      break;\r
    }\r
\r
    gBS->FreePool (BootOptionVar);\r
    Index++;\r
  }\r
\r
  Status = gRT->SetVariable (\r
                  L"BootOrder",\r
                  &gEfiGlobalVariableGuid,\r
                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
                  BootOrderSize,\r
                  BootOrder\r
                  );\r
\r
  gBS->FreePool (BootOrder);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Delete all invalid EFI boot options. The probable invalid boot option could\r
  be Removable media or Network boot device.\r
\r
  VOID\r
\r
  @retval EFI_SUCCESS            Delete all invalid boot option success\r
  @retval EFI_NOT_FOUND          Variable "BootOrder" is not found\r
  @retval EFI_OUT_OF_RESOURCES   Lack of memory resource\r
  @retval Other                  Error return value from SetVariable()\r
\r
**/\r
EFI_STATUS\r
BdsDeleteAllInvalidEfiBootOption (\r
  VOID\r
  )\r
{\r
  UINT16                    *BootOrder;\r
  UINT8                     *BootOptionVar;\r
  UINTN                     BootOrderSize;\r
  UINTN                     BootOptionSize;\r
  EFI_STATUS                Status;\r
  UINTN                     Index;\r
  UINTN                     Index2;\r
  UINT16                    BootOption[BOOT_OPTION_MAX_CHAR];\r
  EFI_DEVICE_PATH_PROTOCOL  *OptionDevicePath;\r
  UINT8                     *TempPtr;\r
\r
  Status        = EFI_SUCCESS;\r
  BootOrder     = NULL;\r
  BootOrderSize = 0;\r
\r
  BootOrder = BdsLibGetVariableAndSize (\r
                L"BootOrder",\r
                &gEfiGlobalVariableGuid,\r
                &BootOrderSize\r
                );\r
  if (NULL == BootOrder) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  Index = 0;\r
  while (Index < BootOrderSize / sizeof (UINT16)) {\r
    UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);\r
    BootOptionVar = BdsLibGetVariableAndSize (\r
                      BootOption,\r
                      &gEfiGlobalVariableGuid,\r
                      &BootOptionSize\r
                      );\r
    if (NULL == BootOptionVar) {\r
      gBS->FreePool (BootOrder);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    TempPtr = BootOptionVar;\r
    TempPtr += sizeof (UINT32) + sizeof (UINT16);\r
    TempPtr += StrSize ((CHAR16 *) TempPtr);\r
    OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;\r
\r
    //\r
    // Skip legacy boot option (BBS boot device)\r
    //\r
    if ((DevicePathType (OptionDevicePath) == BBS_DEVICE_PATH) &&\r
        (DevicePathSubType (OptionDevicePath) == BBS_BBS_DP)) {\r
      gBS->FreePool (BootOptionVar);\r
      Index++;\r
      continue;\r
    }\r
\r
    if (!BdsLibIsValidEFIBootOptDevicePath (OptionDevicePath, FALSE)) {\r
      //\r
      // Delete this invalid boot option "Boot####"\r
      //\r
      Status = gRT->SetVariable (\r
                      BootOption,\r
                      &gEfiGlobalVariableGuid,\r
                      EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
                      0,\r
                      NULL\r
                      );\r
      //\r
      // Mark this boot option in boot order as deleted\r
      //\r
      BootOrder[Index] = 0xffff;\r
    }\r
\r
    gBS->FreePool (BootOptionVar);\r
    Index++;\r
  }\r
\r
  //\r
  // Adjust boot order array\r
  //\r
  Index2 = 0;\r
  for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {\r
    if (BootOrder[Index] != 0xffff) {\r
      BootOrder[Index2] = BootOrder[Index];\r
      Index2 ++;\r
    }\r
  }\r
  Status = gRT->SetVariable (\r
                  L"BootOrder",\r
                  &gEfiGlobalVariableGuid,\r
                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
                  Index2 * sizeof (UINT16),\r
                  BootOrder\r
                  );\r
\r
  gBS->FreePool (BootOrder);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  This function will enumerate all possible boot device in the system,\r
  it will only excute once of every boot.\r
\r
  @param  BdsBootOptionList      The header of the link list which indexed all\r
                                 current boot options\r
\r
  @retval EFI_SUCCESS            Finished all the boot device enumerate and create\r
                                 the boot option base on that boot device\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
BdsLibEnumerateAllBootOption (\r
  IN OUT LIST_ENTRY          *BdsBootOptionList\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  UINT16                        FloppyNumber;\r
  UINT16                        CdromNumber;\r
  UINT16                        UsbNumber;\r
  UINT16                        MiscNumber;\r
  UINT16                        NonBlockNumber;\r
  UINTN                         NumberBlockIoHandles;\r
  EFI_HANDLE                    *BlockIoHandles;\r
  EFI_BLOCK_IO_PROTOCOL         *BlkIo;\r
  UINTN                         Index;\r
  UINTN                         NumberSimpleNetworkHandles;\r
  EFI_HANDLE                    *SimpleNetworkHandles;\r
  UINTN                         FvHandleCount;\r
  EFI_HANDLE                    *FvHandleBuffer;\r
  EFI_FV_FILETYPE               Type;\r
  UINTN                         Size;\r
  EFI_FV_FILE_ATTRIBUTES        Attributes;\r
  UINT32                        AuthenticationStatus;\r
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *Fv;\r
  EFI_DEVICE_PATH_PROTOCOL     *DevicePath;\r
  UINTN                         DevicePathType;\r
  CHAR16                        Buffer[40];\r
  EFI_HANDLE                    *FileSystemHandles;\r
  UINTN                         NumberFileSystemHandles;\r
  BOOLEAN                       NeedDelete;\r
  EFI_IMAGE_DOS_HEADER          DosHeader;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION       HdrData;\r
  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;\r
\r
  FloppyNumber = 0;\r
  CdromNumber = 0;\r
  UsbNumber = 0;\r
  MiscNumber = 0;\r
  ZeroMem (Buffer, sizeof (Buffer));\r
  //\r
  // If the boot device enumerate happened, just get the boot\r
  // device from the boot order variable\r
  //\r
  if (mEnumBootDevice) {\r
    BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");\r
    return EFI_SUCCESS;\r
  }\r
  //\r
  // Notes: this dirty code is to get the legacy boot option from the\r
  // BBS table and create to variable as the EFI boot option, it should\r
  // be removed after the CSM can provide legacy boot option directly\r
  //\r
  REFRESH_LEGACY_BOOT_OPTIONS;\r
\r
  //\r
  // Delete invalid boot option\r
  //\r
  BdsDeleteAllInvalidEfiBootOption ();\r
  //\r
  // Parse removable media\r
  //\r
  gBS->LocateHandleBuffer (\r
        ByProtocol,\r
        &gEfiBlockIoProtocolGuid,\r
        NULL,\r
        &NumberBlockIoHandles,\r
        &BlockIoHandles\r
        );\r
  for (Index = 0; Index < NumberBlockIoHandles; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    BlockIoHandles[Index],\r
                    &gEfiBlockIoProtocolGuid,\r
                    (VOID **) &BlkIo\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
      if (!BlkIo->Media->RemovableMedia) {\r
        //\r
        // skip the non-removable block devices\r
        //\r
        continue;\r
      }\r
    }\r
    DevicePath  = DevicePathFromHandle (BlockIoHandles[Index]);\r
    DevicePathType = BdsGetBootTypeFromDevicePath (DevicePath);\r
\r
    switch (DevicePathType) {\r
    case BDS_EFI_ACPI_FLOPPY_BOOT:\r
      if (FloppyNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Floppy");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Floppy %d", FloppyNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
      FloppyNumber++;\r
      break;\r
\r
    case BDS_EFI_MESSAGE_ATAPI_BOOT:\r
      if (CdromNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI DVD/CDROM");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI DVD/CDROM %d", CdromNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
      CdromNumber++;\r
      break;\r
\r
    case BDS_EFI_MESSAGE_USB_DEVICE_BOOT:\r
      if (UsbNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI USB Device");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI USB Device %d", UsbNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
      UsbNumber++;\r
      break;\r
\r
    case BDS_EFI_MESSAGE_SCSI_BOOT:\r
      if (UsbNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI SCSI Device");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI SCSI Device %d", UsbNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
      UsbNumber++;\r
      break;\r
\r
    case BDS_EFI_MESSAGE_MISC_BOOT:\r
      if (MiscNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Misc Device");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Misc Device %d", MiscNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
      MiscNumber++;\r
      break;\r
\r
    default:\r
      break;\r
    }\r
  }\r
\r
  if (NumberBlockIoHandles) {\r
    gBS->FreePool (BlockIoHandles);\r
  }\r
\r
  //\r
  // If there is simple file protocol which does not consume block Io protocol, create a boot option for it here.\r
  //\r
  NonBlockNumber = 0;\r
  gBS->LocateHandleBuffer (\r
        ByProtocol,\r
        &gEfiSimpleFileSystemProtocolGuid,\r
        NULL,\r
        &NumberFileSystemHandles,\r
        &FileSystemHandles\r
        );\r
  for (Index = 0; Index < NumberFileSystemHandles; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    FileSystemHandles[Index],\r
                    &gEfiBlockIoProtocolGuid,\r
                    (VOID **) &BlkIo\r
                    );\r
     if (!EFI_ERROR (Status)) {\r
      //\r
      //  Skip if the file system handle supports a BlkIo protocol,\r
      //\r
      continue;\r
    }\r
\r
    //\r
    // Do the removable Media thing. \EFI\BOOT\boot{machinename}.EFI\r
    //  machinename is ia32, ia64, x64, ...\r
    //\r
    Hdr.Union = &HdrData;\r
    NeedDelete = TRUE;\r
    Status     = BdsLibGetImageHeader (\r
                   FileSystemHandles[Index],\r
                   DEFAULT_REMOVABLE_FILE_NAME,\r
                   &DosHeader,\r
                   Hdr\r
                   );\r
    if (!EFI_ERROR (Status) &&\r
        EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr.Pe32->FileHeader.Machine) &&\r
        Hdr.Pe32->OptionalHeader.Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {\r
      NeedDelete = FALSE;\r
    }\r
\r
    if (NeedDelete) {\r
      //\r
      // No such file or the file is not a EFI application, delete this boot option\r
      //\r
      BdsLibDeleteOptionFromHandle (FileSystemHandles[Index]);\r
    } else {\r
      if (NonBlockNumber == 0) {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Non-Block Boot Device");\r
      } else {\r
        UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Non-Block Boot Device %d", NonBlockNumber);\r
      }\r
      BdsLibBuildOptionFromHandle (FileSystemHandles[Index], BdsBootOptionList, Buffer);\r
      NonBlockNumber++;\r
    }\r
  }\r
\r
  if (NumberFileSystemHandles) {\r
    gBS->FreePool (FileSystemHandles);\r
  }\r
\r
  //\r
  // Parse Network Boot Device\r
  //\r
  gBS->LocateHandleBuffer (\r
        ByProtocol,\r
        &gEfiSimpleNetworkProtocolGuid,\r
        NULL,\r
        &NumberSimpleNetworkHandles,\r
        &SimpleNetworkHandles\r
        );\r
  for (Index = 0; Index < NumberSimpleNetworkHandles; Index++) {\r
    if (Index == 0) {\r
      UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Network");\r
    } else {\r
      UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Network %d", Index);\r
    }\r
    BdsLibBuildOptionFromHandle (SimpleNetworkHandles[Index], BdsBootOptionList, Buffer);\r
  }\r
\r
  if (NumberSimpleNetworkHandles) {\r
    gBS->FreePool (SimpleNetworkHandles);\r
  }\r
\r
  //\r
  // Check if we have on flash shell\r
  //\r
  gBS->LocateHandleBuffer (\r
        ByProtocol,\r
        &gEfiFirmwareVolume2ProtocolGuid,\r
        NULL,\r
        &FvHandleCount,\r
        &FvHandleBuffer\r
        );\r
  for (Index = 0; Index < FvHandleCount; Index++) {\r
    //\r
    // Only care the dispatched FV. If no dispatch protocol on the FV, it is not dispatched, then skip it.\r
    //\r
    Status = gBS->HandleProtocol (\r
                    FvHandleBuffer[Index],\r
                    &gEfiFirmwareVolumeDispatchProtocolGuid,\r
                    (VOID **) &Fv\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      continue;\r
    }\r
    \r
    gBS->HandleProtocol (\r
          FvHandleBuffer[Index],\r
          &gEfiFirmwareVolume2ProtocolGuid,\r
          (VOID **) &Fv\r
          );\r
\r
    Status = Fv->ReadFile (\r
                  Fv,\r
                  &gEfiShellFileGuid,\r
                  NULL,\r
                  &Size,\r
                  &Type,\r
                  &Attributes,\r
                  &AuthenticationStatus\r
                  );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // Skip if no shell file in the FV\r
      //\r
      continue;\r
    }\r
    //\r
    // Build the shell boot option\r
    //\r
    BdsLibBuildOptionFromShell (FvHandleBuffer[Index], BdsBootOptionList);\r
  }\r
\r
  if (FvHandleCount) {\r
    gBS->FreePool (FvHandleBuffer);\r
  }\r
  //\r
  // Make sure every boot only have one time\r
  // boot device enumerate\r
  //\r
  BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");\r
  mEnumBootDevice = TRUE;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Build the boot option with the handle parsed in\r
\r
  @param  Handle                 The handle which present the device path to create\r
                                 boot option\r
  @param  BdsBootOptionList      The header of the link list which indexed all\r
                                 current boot options\r
\r
  @return VOID\r
\r
**/\r
VOID\r
EFIAPI\r
BdsLibBuildOptionFromHandle (\r
  IN  EFI_HANDLE                 Handle,\r
  IN  LIST_ENTRY                 *BdsBootOptionList,\r
  IN  CHAR16                     *String\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
\r
  DevicePath  = DevicePathFromHandle (Handle);\r
\r
  //\r
  // Create and register new boot option\r
  //\r
  BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, String, L"BootOrder");\r
}\r
\r
\r
/**\r
  Build the on flash shell boot option with the handle parsed in\r
\r
  @param  Handle                 The handle which present the device path to create\r
                                 on flash shell boot option\r
  @param  BdsBootOptionList      The header of the link list which indexed all\r
                                 current boot options\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
BdsLibBuildOptionFromShell (\r
  IN EFI_HANDLE                  Handle,\r
  IN OUT LIST_ENTRY              *BdsBootOptionList\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL          *DevicePath;\r
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ShellNode;\r
\r
  DevicePath = DevicePathFromHandle (Handle);\r
\r
  //\r
  // Build the shell device path\r
  //\r
  EfiInitializeFwVolDevicepathNode (&ShellNode, &gEfiShellFileGuid);\r
  //\r
  //ShellNode.Header.Type     = MEDIA_DEVICE_PATH;\r
  //ShellNode.Header.SubType  = MEDIA_FV_FILEPATH_DP;\r
  //SetDevicePathNodeLength (&ShellNode.Header, sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH));\r
  //CopyMem (&ShellNode.NameGuid, &gEfiShellFileGuid, sizeof (EFI_GUID));\r
  //\r
  DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &ShellNode);\r
\r
  //\r
  // Create and register the shell boot option\r
  //\r
  BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, L"EFI Internal Shell", L"BootOrder");\r
\r
}\r
\r
\r
/**\r
  Boot from the EFI1.1 spec defined "BootNext" variable\r
\r
**/\r
VOID\r
EFIAPI\r
BdsLibBootNext (\r
  VOID\r
  )\r
{\r
  UINT16            *BootNext;\r
  UINTN             BootNextSize;\r
  CHAR16            Buffer[20];\r
  BDS_COMMON_OPTION *BootOption;\r
  LIST_ENTRY        TempList;\r
  UINTN             ExitDataSize;\r
  CHAR16            *ExitData;\r
\r
  //\r
  // Init the boot option name buffer and temp link list\r
  //\r
  InitializeListHead (&TempList);\r
  ZeroMem (Buffer, sizeof (Buffer));\r
\r
  BootNext = BdsLibGetVariableAndSize (\r
              L"BootNext",\r
              &gEfiGlobalVariableGuid,\r
              &BootNextSize\r
              );\r
\r
  //\r
  // Clear the boot next variable first\r
  //\r
  if (BootNext != NULL) {\r
    gRT->SetVariable (\r
          L"BootNext",\r
          &gEfiGlobalVariableGuid,\r
          EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
          0,\r
          BootNext\r
          );\r
\r
    //\r
    // Start to build the boot option and try to boot\r
    //\r
    UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", *BootNext);\r
    BootOption = BdsLibVariableToOption (&TempList, Buffer);\r
    BdsLibConnectDevicePath (BootOption->DevicePath);\r
    BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);\r
  }\r
\r
}\r
\r
\r
\r
/**\r
  Return the bootable media handle.\r
  First, check the device is connected\r
  Second, check whether the device path point to a device which support SimpleFileSystemProtocol,\r
  Third, detect the the default boot file in the Media, and return the removable Media handle.\r
\r
  @param  DevicePath             Device Path to a  bootable device\r
\r
  @retval NULL                   The device path points to an EFI bootable Media\r
  @retval NULL                   The media on the DevicePath is not bootable\r
\r
**/\r
EFI_HANDLE\r
EFIAPI\r
BdsLibGetBootableHandle (\r
  IN  EFI_DEVICE_PATH_PROTOCOL      *DevicePath\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_DEVICE_PATH_PROTOCOL        *UpdatedDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL        *DupDevicePath;\r
  EFI_HANDLE                      Handle;\r
  EFI_BLOCK_IO_PROTOCOL           *BlockIo;\r
  VOID                            *Buffer;\r
  EFI_DEVICE_PATH_PROTOCOL        *TempDevicePath;\r
  UINTN                           Size;\r
  UINTN                           TempSize;\r
  EFI_HANDLE                      ReturnHandle;\r
  EFI_HANDLE                      *SimpleFileSystemHandles;\r
\r
  UINTN                           NumberSimpleFileSystemHandles;\r
  UINTN                           Index;\r
  EFI_IMAGE_DOS_HEADER            DosHeader;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION       HdrData;\r
  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;\r
\r
  UpdatedDevicePath = DevicePath;\r
  //\r
  // Check whether the device is connected\r
  //\r
  Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &UpdatedDevicePath, &Handle);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Skip the case that the boot option point to a simple file protocol which does not consume block Io protocol,\r
    //\r
    Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &UpdatedDevicePath, &Handle);\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // Fail to find the proper BlockIo and simple file protocol, maybe because device not present,  we need to connect it firstly\r
      //\r
      UpdatedDevicePath = DevicePath;\r
      Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &UpdatedDevicePath, &Handle);\r
      gBS->ConnectController (Handle, NULL, NULL, TRUE);\r
    }\r
  } else {\r
    //\r
    // Get BlockIo protocal and check removable attribute\r
    //\r
    Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **)&BlockIo);\r
    //\r
    // Issue a dummy read to the device to check for media change.\r
    // When the removable media is changed, any Block IO read/write will\r
    // cause the BlockIo protocol be reinstalled and EFI_MEDIA_CHANGED is\r
    // returned. After the Block IO protocol is reinstalled, subsequent\r
    // Block IO read/write will success.\r
    //\r
    Buffer = AllocatePool (BlockIo->Media->BlockSize);\r
    if (Buffer != NULL) {\r
      BlockIo->ReadBlocks (\r
               BlockIo,\r
               BlockIo->Media->MediaId,\r
               0,\r
               BlockIo->Media->BlockSize,\r
               Buffer\r
               );\r
      gBS->FreePool (Buffer);\r
    }\r
  }\r
\r
  //\r
  // Detect the the default boot file from removable Media\r
  //\r
\r
  //\r
  // If fail to get bootable handle specified by a USB boot option, the BDS should try to find other bootable device in the same USB bus\r
  // Try to locate the USB node device path first, if fail then use its previour PCI node to search\r
  //\r
  DupDevicePath = DuplicateDevicePath (DevicePath);\r
  UpdatedDevicePath = DupDevicePath;\r
  Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &UpdatedDevicePath, &Handle);\r
  //\r
  // if the resulting device path point to a usb node, and the usb node is a dummy node, should only let device path only point to the previous Pci node\r
  // Acpi()/Pci()/Usb() --> Acpi()/Pci()\r
  //\r
  if ((DevicePathType (UpdatedDevicePath) == MESSAGING_DEVICE_PATH) &&\r
      (DevicePathSubType (UpdatedDevicePath) == MSG_USB_DP)) {\r
    //\r
    // Remove the usb node, let the device path only point to PCI node\r
    //\r
    SetDevicePathEndNode (UpdatedDevicePath);\r
    UpdatedDevicePath = DupDevicePath;\r
  } else {\r
    UpdatedDevicePath = DevicePath;\r
  }\r
\r
  //\r
  // Get the device path size of boot option\r
  //\r
  Size = GetDevicePathSize(UpdatedDevicePath) - sizeof (EFI_DEVICE_PATH_PROTOCOL); // minus the end node\r
  ReturnHandle = NULL;\r
  gBS->LocateHandleBuffer (\r
      ByProtocol,\r
      &gEfiSimpleFileSystemProtocolGuid,\r
      NULL,\r
      &NumberSimpleFileSystemHandles,\r
      &SimpleFileSystemHandles\r
      );\r
  for (Index = 0; Index < NumberSimpleFileSystemHandles; Index++) {\r
    //\r
    // Get the device path size of SimpleFileSystem handle\r
    //\r
    TempDevicePath = DevicePathFromHandle (SimpleFileSystemHandles[Index]);\r
    TempSize = GetDevicePathSize (TempDevicePath)- sizeof (EFI_DEVICE_PATH_PROTOCOL); // minus the end node\r
    //\r
    // Check whether the device path of boot option is part of the  SimpleFileSystem handle's device path\r
    //\r
    if (Size <= TempSize && CompareMem (TempDevicePath, UpdatedDevicePath, Size)==0) {\r
      //\r
      // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media\r
      //  machinename is ia32, ia64, x64, ...\r
      //\r
      Hdr.Union = &HdrData;\r
      Status = BdsLibGetImageHeader (\r
                 SimpleFileSystemHandles[Index],\r
                 DEFAULT_REMOVABLE_FILE_NAME,\r
                 &DosHeader,\r
                 Hdr\r
                 );\r
      if (!EFI_ERROR (Status) &&\r
        EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr.Pe32->FileHeader.Machine) &&\r
        Hdr.Pe32->OptionalHeader.Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {\r
        ReturnHandle = SimpleFileSystemHandles[Index];\r
        break;\r
      }\r
    }\r
  }\r
\r
  if (DupDevicePath != NULL) {\r
    SafeFreePool(DupDevicePath);\r
  }\r
  if (SimpleFileSystemHandles !=NULL ) {\r
    gBS->FreePool (SimpleFileSystemHandles);\r
  }\r
\r
  return ReturnHandle;\r
}\r
\r
\r
\r
\r
/**\r
  Check to see if the network cable is plugged in. If the DevicePath is not\r
  connected it will be connected.\r
\r
  @param  DevicePath             Device Path to check\r
\r
  @retval TRUE                   DevicePath points to an Network that is connected\r
  @retval FALSE                  DevicePath does not point to a bootable network\r
\r
**/\r
BOOLEAN\r
BdsLibNetworkBootWithMediaPresent (\r
  IN  EFI_DEVICE_PATH_PROTOCOL      *DevicePath\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_DEVICE_PATH_PROTOCOL        *UpdatedDevicePath;\r
  EFI_HANDLE                      Handle;\r
  EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;\r
  BOOLEAN                         MediaPresent;\r
\r
  MediaPresent = FALSE;\r
\r
  UpdatedDevicePath = DevicePath;\r
  Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Device not present so see if we need to connect it\r
    //\r
    Status = BdsLibConnectDevicePath (DevicePath);\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // This one should work after we did the connect\r
      //\r
      Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);\r
    }\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->HandleProtocol (Handle, &gEfiSimpleNetworkProtocolGuid, (VOID **)&Snp);\r
    if (!EFI_ERROR (Status)) {\r
      if (Snp->Mode->MediaPresentSupported) {\r
        if (Snp->Mode->State == EfiSimpleNetworkInitialized) {\r
          //\r
          // In case some one else is using the SNP check to see if it's connected\r
          //\r
          MediaPresent = Snp->Mode->MediaPresent;\r
        } else {\r
          //\r
          // No one is using SNP so we need to Start and Initialize so\r
          // MediaPresent will be valid.\r
          //\r
          Status = Snp->Start (Snp);\r
          if (!EFI_ERROR (Status)) {\r
            Status = Snp->Initialize (Snp, 0, 0);\r
            if (!EFI_ERROR (Status)) {\r
              MediaPresent = Snp->Mode->MediaPresent;\r
              Snp->Shutdown (Snp);\r
            }\r
            Snp->Stop (Snp);\r
          }\r
        }\r
      } else {\r
        MediaPresent = TRUE;\r
      }\r
    }\r
  }\r
\r
  return MediaPresent;\r
}\r
\r
\r
\r
/**\r
  For a bootable Device path, return its boot type\r
\r
  @param  DevicePath                      The bootable device Path to check\r
\r
  @retval BDS_EFI_MEDIA_HD_BOOT           If the device path contains any media deviec path node, it is media boot type\r
                                          For the floppy node, handle it as media node\r
  @retval BDS_EFI_MEDIA_CDROM_BOOT        If the device path contains any media deviec path node, it is media boot type\r
                                          For the floppy node, handle it as media node\r
  @retval BDS_EFI_ACPI_FLOPPY_BOOT        If the device path contains any media deviec path node, it is media boot type\r
                                          For the floppy node, handle it as media node\r
  @retval BDS_EFI_MESSAGE_ATAPI_BOOT      If the device path not contains any media deviec path node,  and\r
                                          its last device path node point to a message device path node, it is\r
  \r
  @retval BDS_EFI_MESSAGE_SCSI_BOOT       If the device path not contains any media deviec path node,  and\r
                                          its last device path node point to a message device path node, it is\r
  @retval BDS_EFI_MESSAGE_USB_DEVICE_BOOT If the device path not contains any media deviec path node,  and\r
                                          its last device path node point to a message device path node, it is\r
  @retval BDS_EFI_MESSAGE_MISC_BOOT       If the device path not contains any media deviec path node,  and\r
                                          its last device path node point to a message device path node, it is\r
  @retval BDS_LEGACY_BBS_BOOT             Legacy boot type\r
  @retval BDS_EFI_UNSUPPORT               An EFI Removable BlockIO device path not point to a media and message devie,   \r
\r
**/\r
UINT32\r
EFIAPI\r
BdsGetBootTypeFromDevicePath (\r
  IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath\r
  )\r
{\r
  ACPI_HID_DEVICE_PATH          *Acpi;\r
  EFI_DEVICE_PATH_PROTOCOL      *TempDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL      *LastDeviceNode;\r
\r
\r
  if (NULL == DevicePath) {\r
    return BDS_EFI_UNSUPPORT;\r
  }\r
\r
  TempDevicePath = DevicePath;\r
\r
  while (!IsDevicePathEndType (TempDevicePath)) {\r
    switch (DevicePathType (TempDevicePath)) {\r
      case BBS_DEVICE_PATH:\r
         return BDS_LEGACY_BBS_BOOT;\r
      case MEDIA_DEVICE_PATH:\r
        if (DevicePathSubType (TempDevicePath) == MEDIA_HARDDRIVE_DP) {\r
          return BDS_EFI_MEDIA_HD_BOOT;\r
        } else if (DevicePathSubType (TempDevicePath) == MEDIA_CDROM_DP) {\r
          return BDS_EFI_MEDIA_CDROM_BOOT;\r
        }\r
        break;\r
      case ACPI_DEVICE_PATH:\r
        Acpi = (ACPI_HID_DEVICE_PATH *) TempDevicePath;\r
        if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {\r
          return BDS_EFI_ACPI_FLOPPY_BOOT;\r
        }\r
        break;\r
      case MESSAGING_DEVICE_PATH:\r
        //\r
        // if the device path not only point to driver device, it is not a messaging device path.\r
        //\r
        LastDeviceNode = NextDevicePathNode (TempDevicePath);\r
        if (!IsDevicePathEndType (LastDeviceNode)) {\r
          break;\r
        }\r
\r
        if (DevicePathSubType(TempDevicePath) == MSG_ATAPI_DP) {\r
          return BDS_EFI_MESSAGE_ATAPI_BOOT;\r
        } else if (DevicePathSubType(TempDevicePath) == MSG_USB_DP) {\r
          return BDS_EFI_MESSAGE_USB_DEVICE_BOOT;\r
        } else if (DevicePathSubType(TempDevicePath) == MSG_SCSI_DP) {\r
          return BDS_EFI_MESSAGE_SCSI_BOOT;\r
        }\r
        return BDS_EFI_MESSAGE_MISC_BOOT;\r
      default:\r
        break;\r
    }\r
    TempDevicePath = NextDevicePathNode (TempDevicePath);\r
  }\r
\r
  return BDS_EFI_UNSUPPORT;\r
}\r
\r
\r
/**\r
  Check whether the Device path in a boot option point to a valide bootable device,\r
  And if CheckMedia is true, check the device is ready to boot now.\r
\r
  DevPath -- the Device path in a boot option\r
  CheckMedia -- if true, check the device is ready to boot now.\r
\r
  @return TRUE      -- the Device path  is valide\r
  @return FALSE   -- the Device path  is invalide .\r
\r
**/\r
BOOLEAN\r
EFIAPI\r
BdsLibIsValidEFIBootOptDevicePath (\r
  IN EFI_DEVICE_PATH_PROTOCOL     *DevPath,\r
  IN BOOLEAN                      CheckMedia\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_HANDLE                Handle;\r
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *LastDeviceNode;\r
  EFI_BLOCK_IO_PROTOCOL     *BlockIo;\r
\r
  TempDevicePath = DevPath;\r
  LastDeviceNode = DevPath;\r
  //\r
  // Check if it's a valid boot option for network boot device\r
  // Only check if there is SimpleNetworkProtocol installed. If yes, that means\r
  // there is the network card there.\r
  //\r
  Status = gBS->LocateDevicePath (\r
                  &gEfiSimpleNetworkProtocolGuid,\r
                  &TempDevicePath,\r
                  &Handle\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Device not present so see if we need to connect it\r
    //\r
    TempDevicePath = DevPath;\r
    BdsLibConnectDevicePath (TempDevicePath);\r
    Status = gBS->LocateDevicePath (\r
                    &gEfiSimpleNetworkProtocolGuid,\r
                    &TempDevicePath,\r
                    &Handle\r
                    );\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    if (CheckMedia) {\r
      //\r
      // Test if it is ready to boot now\r
      //\r
      if (BdsLibNetworkBootWithMediaPresent(DevPath)) {\r
        return TRUE;\r
      }\r
    } else {\r
      return TRUE;\r
    }\r
  }\r
\r
  //\r
  // If the boot option point to a file, it is a valid EFI boot option,\r
  // and assume it is ready to boot now\r
  //\r
  while (!EfiIsDevicePathEnd (TempDevicePath)) {\r
     LastDeviceNode = TempDevicePath;\r
     TempDevicePath = EfiNextDevicePathNode (TempDevicePath);\r
  }\r
  if ((DevicePathType (LastDeviceNode) == MEDIA_DEVICE_PATH) &&\r
    (DevicePathSubType (LastDeviceNode) == MEDIA_FILEPATH_DP)) {\r
    return TRUE;\r
  }\r
\r
  //\r
  // If the boot option point to a internal Shell, it is a valid EFI boot option,\r
  // and assume it is ready to boot now\r
  //\r
  if (EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode) != NULL) {\r
     return TRUE;\r
  }\r
\r
  //\r
  // If the boot option point to a blockIO device, no matter whether or not it is a removeable device, it is a valid EFI boot option\r
  //\r
  TempDevicePath = DevPath;\r
  Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // Device not present so see if we need to connect it\r
    //\r
    Status = BdsLibConnectDevicePath (DevPath);\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Try again to get the Block Io protocol after we did the connect\r
      //\r
      TempDevicePath = DevPath;\r
      Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);\r
    }\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **)&BlockIo);\r
    if (!EFI_ERROR (Status)) {\r
      if (CheckMedia) {\r
        //\r
        // Test if it is ready to boot now\r
        //\r
        if (BdsLibGetBootableHandle (DevPath) != NULL) {\r
          return TRUE;\r
        }\r
      } else {\r
        return TRUE;\r
      }\r
    }\r
  } else {\r
    //\r
    // if the boot option point to a simple file protocol which does not consume block Io protocol, it is also a valid EFI boot option,\r
    //\r
    Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &TempDevicePath, &Handle);\r
    if (!EFI_ERROR (Status)) {\r
      if (CheckMedia) {\r
        //\r
        // Test if it is ready to boot now\r
        //\r
        if (BdsLibGetBootableHandle (DevPath) != NULL) {\r
          return TRUE;\r
        }\r
      } else {\r
        return TRUE;\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
\r
/**\r
  According to a file guild, check a Fv file device path is valid. If it is invalid,\r
  try to return the valid device path.\r
  FV address maybe changes for memory layout adjust from time to time, use this funciton\r
  could promise the Fv file device path is right.\r
\r
  @param  DevicePath             on input, the Fv file device path need to check on\r
                                 output, the updated valid Fv file device path\r
  @param  FileGuid               the Fv file guild\r
\r
  @retval EFI_INVALID_PARAMETER  the input DevicePath or FileGuid is invalid\r
                                 parameter\r
  @retval EFI_UNSUPPORTED        the input DevicePath does not contain Fv file\r
                                 guild at all\r
  @retval EFI_ALREADY_STARTED    the input DevicePath has pointed to Fv file, it is\r
                                 valid\r
  @retval EFI_SUCCESS            has successfully updated the invalid DevicePath,\r
                                 and return the updated device path in DevicePath\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
BdsLibUpdateFvFileDevicePath (\r
  IN  OUT EFI_DEVICE_PATH_PROTOCOL      ** DevicePath,\r
  IN  EFI_GUID                          *FileGuid\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL      *TempDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL      *LastDeviceNode;\r
  EFI_STATUS                    Status;\r
  EFI_GUID                      *GuidPoint;\r
  UINTN                         Index;\r
  UINTN                         FvHandleCount;\r
  EFI_HANDLE                    *FvHandleBuffer;\r
  EFI_FV_FILETYPE               Type;\r
  UINTN                         Size;\r
  EFI_FV_FILE_ATTRIBUTES        Attributes;\r
  UINT32                        AuthenticationStatus;\r
  BOOLEAN                       FindFvFile;\r
  EFI_LOADED_IMAGE_PROTOCOL     *LoadedImage;\r
  EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FvFileNode;\r
  EFI_HANDLE                    FoundFvHandle;\r
  EFI_DEVICE_PATH_PROTOCOL      *NewDevicePath;\r
\r
  if ((DevicePath == NULL) || (*DevicePath == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if (FileGuid == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  //\r
  // Check whether the device path point to the default the input Fv file\r
  //\r
  TempDevicePath = *DevicePath;\r
  LastDeviceNode = TempDevicePath;\r
  while (!EfiIsDevicePathEnd (TempDevicePath)) {\r
     LastDeviceNode = TempDevicePath;\r
     TempDevicePath = EfiNextDevicePathNode (TempDevicePath);\r
  }\r
  GuidPoint = EfiGetNameGuidFromFwVolDevicePathNode (\r
                (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode\r
                );\r
  if (GuidPoint == NULL) {\r
    //\r
    // if this option does not points to a Fv file, just return EFI_UNSUPPORTED\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
  if (!CompareGuid (GuidPoint, FileGuid)) {\r
    //\r
    // If the Fv file is not the input file guid, just return EFI_UNSUPPORTED\r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Check whether the input Fv file device path is valid\r
  //\r
  TempDevicePath = *DevicePath;\r
  FoundFvHandle = NULL;\r
  Status = gBS->LocateDevicePath (\r
                  &gEfiFirmwareVolume2ProtocolGuid,\r
                  &TempDevicePath,\r
                  &FoundFvHandle\r
                  );\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->HandleProtocol (\r
                    FoundFvHandle,\r
                    &gEfiFirmwareVolume2ProtocolGuid,\r
                    (VOID **) &Fv\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Set FV ReadFile Buffer as NULL, only need to check whether input Fv file exist there\r
      //\r
      Status = Fv->ReadFile (\r
                    Fv,\r
                    FileGuid,\r
                    NULL,\r
                    &Size,\r
                    &Type,\r
                    &Attributes,\r
                    &AuthenticationStatus\r
                    );\r
      if (!EFI_ERROR (Status)) {\r
        return EFI_ALREADY_STARTED;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Look for the input wanted FV file in current FV\r
  // First, try to look for in Bds own FV. Bds and input wanted FV file usually are in the same FV\r
  //\r
  FindFvFile = FALSE;\r
  FoundFvHandle = NULL;\r
  Status = gBS->HandleProtocol (\r
             mBdsImageHandle,\r
             &gEfiLoadedImageProtocolGuid,\r
             (VOID **) &LoadedImage\r
             );\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->HandleProtocol (\r
                    LoadedImage->DeviceHandle,\r
                    &gEfiFirmwareVolume2ProtocolGuid,\r
                    (VOID **) &Fv\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
      Status = Fv->ReadFile (\r
                    Fv,\r
                    FileGuid,\r
                    NULL,\r
                    &Size,\r
                    &Type,\r
                    &Attributes,\r
                    &AuthenticationStatus\r
                    );\r
      if (!EFI_ERROR (Status)) {\r
        FindFvFile = TRUE;\r
        FoundFvHandle = LoadedImage->DeviceHandle;\r
      }\r
    }\r
  }\r
  //\r
  // Second, if fail to find, try to enumerate all FV\r
  //\r
  if (!FindFvFile) {\r
    gBS->LocateHandleBuffer (\r
          ByProtocol,\r
          &gEfiFirmwareVolume2ProtocolGuid,\r
          NULL,\r
          &FvHandleCount,\r
          &FvHandleBuffer\r
          );\r
    for (Index = 0; Index < FvHandleCount; Index++) {\r
      gBS->HandleProtocol (\r
            FvHandleBuffer[Index],\r
            &gEfiFirmwareVolume2ProtocolGuid,\r
            (VOID **) &Fv\r
            );\r
\r
      Status = Fv->ReadFile (\r
                    Fv,\r
                    FileGuid,\r
                    NULL,\r
                    &Size,\r
                    &Type,\r
                    &Attributes,\r
                    &AuthenticationStatus\r
                    );\r
      if (EFI_ERROR (Status)) {\r
        //\r
        // Skip if input Fv file not in the FV\r
        //\r
        continue;\r
      }\r
      FindFvFile = TRUE;\r
      FoundFvHandle = FvHandleBuffer[Index];\r
      break;\r
    }\r
  }\r
\r
  if (FindFvFile) {\r
    //\r
    // Build the shell device path\r
    //\r
    NewDevicePath = DevicePathFromHandle (FoundFvHandle);\r
    EfiInitializeFwVolDevicepathNode (&FvFileNode, FileGuid);\r
    NewDevicePath = AppendDevicePathNode (NewDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &FvFileNode);\r
    *DevicePath = NewDevicePath;\r
    return EFI_SUCCESS;\r
  }\r
  return EFI_NOT_FOUND;\r
}\r