Changeset 58459 in vbox for trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library

Timestamp:

Oct 28, 2015 8:17:18 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

103761

Message:

EFI/Firmware: 'svn merge ^{/vendor/edk2/UDK2010.SR1} /vendor/edk2/current .', reverting and removing files+dirs listed in ReadMe.vbox, resolving conflicts with help from ../UDK2014.SP1/. This is a raw untested merge.

Location:

trunk/src/VBox/Devices/EFI/Firmware

Files:

• . (modified) (1 prop)
• IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.c (modified) (2 diffs)
• IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf (modified) (3 diffs)
• IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.c (modified) (6 diffs)
• IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.inf (modified) (4 diffs)
• IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf (modified) (3 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/BdsBoot.c (modified) (32 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c (modified) (6 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c (modified) (10 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/BdsMisc.c (modified) (27 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/DevicePath.c (modified) (3 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/GenericBdsLib.inf (modified) (5 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h (modified) (5 diffs)
• IntelFrameworkModulePkg/Library/GenericBdsLib/Performance.c (modified) (6 diffs)
• IntelFrameworkModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf (modified) (3 diffs)
• IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/DebugLib.c (modified) (5 diffs)
• IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/PeiDxeDebugLibReportStatusCode.inf (modified) (4 diffs)
• IntelFrameworkModulePkg/Library/PeiRecoveryLib/PeiRecoveryLib.inf (modified) (2 diffs)
• IntelFrameworkModulePkg/Library/PeiS3Lib/PeiS3Lib.inf (modified) (3 diffs)
• IntelFrameworkModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf (modified) (2 diffs)
• IntelFrameworkModulePkg/Library/SmmRuntimeDxeReportStatusCodeLibFramework/SmmRuntimeDxeReportStatusCodeLibFramework.inf (modified) (5 diffs)

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.c

@@ -3 +3 @@
   It will do Tiano or UEFI decompress with different verison parameter.
   
-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD License         
@@ -324 +324 @@
   UINT32  Mask;
 
+  ASSERT (nn <= NPT);
   //
   // Read Extra Set Code Length Array size 

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf

@@ -3 +3 @@
 #  Tiano custom decompression algorithm shares most of code with Uefi Decompress algorithm.
 #
-#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -17 +17 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = BaseUefiTianoDecompressLib
+  MODULE_UNI_FILE                = BaseUefiTianoDecompressLib.uni
   FILE_GUID                      = d774c4d9-c121-4da3-a5e2-0f317e3c630c
   MODULE_TYPE                    = BASE
@@ -44 +45 @@
 
 [Guids]
-  gTianoCustomDecompressGuid      ## PRODUCED  ## GUID specifies tiano custom decompress algorithm.
+  gTianoCustomDecompressGuid      ## PRODUCES  ## UNDEFINED # specifies tiano custom decompress algorithm.
+

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.c

@@ -1 +1 @@
 /** @file
-  Capsule Library instance to update capsule image to flash.
-
-  Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+  Capsule Library instance to process capsule images.
+
+  Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
 
   This program and the accompanying materials
@@ -14 +14 @@
 **/
 #include <PiDxe.h>
+
 #include <Guid/Capsule.h>
+#include <Guid/FmpCapsule.h>
+
 #include <Library/DebugLib.h>
 #include <Library/BaseMemoryLib.h>
@@ -20 +23 @@
 #include <Library/MemoryAllocationLib.h>
 #include <Library/CapsuleLib.h>
+#include <Library/GenericBdsLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DevicePathLib.h>
+
+#include <Protocol/FirmwareManagement.h>
+#include <Protocol/DevicePath.h>
+
+
+/**
+  Function indicate the current completion progress of the firmware
+  update. Platform may override with own specific progress function.
+
+  @param  Completion    A value between 1 and 100 indicating the current completion progress of the firmware update
+
+  @retval EFI_SUCESS    Input capsule is a correct FMP capsule.
+**/
+EFI_STATUS
+EFIAPI
+Update_Image_Progress (
+   IN UINTN Completion
+)
+{
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Validate Fmp capsules layout.
+
+  @param  CapsuleHeader    Points to a capsule header.
+
+  @retval EFI_SUCESS                     Input capsule is a correct FMP capsule.
+  @retval EFI_INVALID_PARAMETER  Input capsule is not a correct FMP capsule.
+**/
+EFI_STATUS
+ValidateFmpCapsule (
+  IN EFI_CAPSULE_HEADER *CapsuleHeader
+  )
+{
+  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER       *FmpCapsuleHeader;
+  UINT8                                        *EndOfCapsule;
+  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
+  UINT8                                        *EndOfPayload;
+  UINT64                                       *ItemOffsetList;
+  UINT32                                       ItemNum;
+  UINTN                                        Index;
+
+  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
+  EndOfCapsule     = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize;
+
+  if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
+    return EFI_INVALID_PARAMETER;
+  }
+  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
+
+  ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
+
+  if (ItemNum == FmpCapsuleHeader->EmbeddedDriverCount) {
+    //
+    // No payload element 
+    //
+    if (((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemNum - 1]) < EndOfCapsule) {
+      return EFI_SUCCESS;
+    } else {
+      return EFI_INVALID_PARAMETER;
+    }
+  }
+
+  if (FmpCapsuleHeader->PayloadItemCount != 0) {
+    //
+    // Check if the last payload is within capsule image range
+    //
+    ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemNum - 1]);
+    EndOfPayload = (UINT8 *)(ImageHeader + 1) + ImageHeader->UpdateImageSize + ImageHeader->UpdateVendorCodeSize;
+  } else {
+    //
+    // No driver & payload element in FMP
+    //
+    EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1);
+  }
+
+  if (EndOfPayload != EndOfCapsule) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // All the address in ItemOffsetList must be stored in ascending order
+  //
+  if (ItemNum >= 2) {
+    for (Index = 0; Index < ItemNum - 1; Index++) {
+      if (ItemOffsetList[Index] >= ItemOffsetList[Index + 1]) {
+        return EFI_INVALID_PARAMETER;
+      }
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Process Firmware management protocol data capsule.  
+
+  @param  CapsuleHeader         Points to a capsule header.
+
+  @retval EFI_SUCESS            Process Capsule Image successfully.
+  @retval EFI_UNSUPPORTED       Capsule image is not supported by the firmware.
+  @retval EFI_VOLUME_CORRUPTED  FV volume in the capsule is corrupted.
+  @retval EFI_OUT_OF_RESOURCES  Not enough memory.
+**/
+EFI_STATUS
+ProcessFmpCapsuleImage (
+  IN EFI_CAPSULE_HEADER *CapsuleHeader
+  )
+{
+  EFI_STATUS                                    Status;
+  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER        *FmpCapsuleHeader;
+  UINT8                                         *EndOfCapsule;
+  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader;
+  EFI_HANDLE                                    ImageHandle;
+  UINT64                                        *ItemOffsetList;
+  UINT32                                        ItemNum;
+  UINTN                                         Index;
+  UINTN                                         ExitDataSize;
+  EFI_HANDLE                                    *HandleBuffer;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
+  UINTN                                         NumberOfHandles;
+  UINTN                                         DescriptorSize;
+  UINT8                                         FmpImageInfoCount;
+  UINT32                                        FmpImageInfoDescriptorVer;
+  UINTN                                         ImageInfoSize;
+  UINT32                                        PackageVersion;
+  CHAR16                                        *PackageVersionName;
+  CHAR16                                        *AbortReason;
+  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
+  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *TempFmpImageInfo;
+  UINTN                                         DriverLen;
+  UINTN                                         Index1;
+  UINTN                                         Index2;
+  MEMMAP_DEVICE_PATH                            MemMapNode;
+  EFI_DEVICE_PATH_PROTOCOL                      *DriverDevicePath;
+
+  Status           = EFI_SUCCESS;
+  HandleBuffer     = NULL;
+  ExitDataSize     = 0;
+  DriverDevicePath = NULL;
+
+  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
+  EndOfCapsule     = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize;
+
+  if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
+    return EFI_INVALID_PARAMETER;
+  }
+  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
+
+  ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
+
+  //
+  // capsule in which driver count and payload count are both zero is not processed.
+  //
+  if (ItemNum == 0) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // 1. ConnectAll to ensure 
+  //    All the communication protocol required by driver in capsule installed 
+  //    All FMP protocols are installed
+  //
+  BdsLibConnectAll();
+
+
+  //
+  // 2. Try to load & start all the drivers within capsule 
+  //
+  SetDevicePathNodeLength (&MemMapNode.Header, sizeof (MemMapNode));
+  MemMapNode.Header.Type     = HARDWARE_DEVICE_PATH;
+  MemMapNode.Header.SubType  = HW_MEMMAP_DP;
+  MemMapNode.MemoryType      = EfiBootServicesCode;
+  MemMapNode.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CapsuleHeader;
+  MemMapNode.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN)((UINT8 *)CapsuleHeader + CapsuleHeader->CapsuleImageSize - 1);
+
+  DriverDevicePath = AppendDevicePathNode (NULL, &MemMapNode.Header);
+  if (DriverDevicePath == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {
+    if (FmpCapsuleHeader->PayloadItemCount == 0 && Index == (UINTN)FmpCapsuleHeader->EmbeddedDriverCount - 1) {
+      //
+      // When driver is last element in the ItemOffsetList array, the driver size is calculated by reference CapsuleImageSize in EFI_CAPSULE_HEADER
+      //
+      DriverLen = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize - (UINTN)ItemOffsetList[Index];
+    } else {
+      DriverLen = (UINTN)ItemOffsetList[Index + 1] - (UINTN)ItemOffsetList[Index];
+    }
+
+    Status = gBS->LoadImage(
+                    FALSE,
+                    gImageHandle,
+                    DriverDevicePath,
+                    (UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index],
+                    DriverLen,
+                    &ImageHandle
+                    );
+    if (EFI_ERROR(Status)) {
+      goto EXIT;
+    }
+
+    Status = gBS->StartImage(
+                    ImageHandle, 
+                    &ExitDataSize, 
+                    NULL
+                    );
+    if (EFI_ERROR(Status)) {
+      DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));
+      goto EXIT;
+    }
+  }
+
+  //
+  // Connnect all again to connect drivers within capsule 
+  //
+  if (FmpCapsuleHeader->EmbeddedDriverCount > 0) {
+    BdsLibConnectAll();
+  }
+
+  //
+  // 3. Route payload to right FMP instance
+  //
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiFirmwareManagementProtocolGuid,
+                  NULL,
+                  &NumberOfHandles,
+                  &HandleBuffer
+                  );
+
+  if (!EFI_ERROR(Status)) {
+    for(Index1 = 0; Index1 < NumberOfHandles; Index1++) {
+      Status = gBS->HandleProtocol(
+                      HandleBuffer[Index1],
+                      &gEfiFirmwareManagementProtocolGuid,
+                      (VOID **)&Fmp
+                      );
+      if (EFI_ERROR(Status)) {
+        continue;
+      }
+
+      ImageInfoSize = 0;
+      Status = Fmp->GetImageInfo (
+                      Fmp,
+                      &ImageInfoSize,
+                      NULL,
+                      NULL,
+                      NULL,
+                      NULL,
+                      NULL,
+                      NULL
+                      );
+      if (Status != EFI_BUFFER_TOO_SMALL) {
+        continue;
+      }
+
+      FmpImageInfoBuf = NULL;
+      FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
+      if (FmpImageInfoBuf == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        goto EXIT;
+      }
+
+      PackageVersionName = NULL;
+      Status = Fmp->GetImageInfo (
+                      Fmp,
+                      &ImageInfoSize,               // ImageInfoSize
+                      FmpImageInfoBuf,              // ImageInfo
+                      &FmpImageInfoDescriptorVer,   // DescriptorVersion
+                      &FmpImageInfoCount,           // DescriptorCount
+                      &DescriptorSize,              // DescriptorSize
+                      &PackageVersion,              // PackageVersion
+                      &PackageVersionName           // PackageVersionName
+                      );
+
+      //
+      // If FMP GetInformation interface failed, skip this resource
+      //
+      if (EFI_ERROR(Status)) {
+        FreePool(FmpImageInfoBuf);
+        continue;
+      }
+
+      if (PackageVersionName != NULL) {
+        FreePool(PackageVersionName);
+      }
+
+      TempFmpImageInfo = FmpImageInfoBuf;
+      for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) {
+        //
+        // Check all the payload entry in capsule payload list 
+        //
+        for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {
+          ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
+          if (CompareGuid(&ImageHeader->UpdateImageTypeId, &TempFmpImageInfo->ImageTypeId) &&
+              ImageHeader->UpdateImageIndex == TempFmpImageInfo->ImageIndex) {
+            AbortReason = NULL;
+            if (ImageHeader->UpdateVendorCodeSize == 0) {
+              Status = Fmp->SetImage(
+                              Fmp,
+                              TempFmpImageInfo->ImageIndex,           // ImageIndex
+                              (UINT8 *)(ImageHeader + 1),             // Image
+                              ImageHeader->UpdateImageSize,           // ImageSize
+                              NULL,                                   // VendorCode
+                              Update_Image_Progress,                  // Progress
+                              &AbortReason                            // AbortReason
+                              );
+            } else {
+              Status = Fmp->SetImage(
+                              Fmp,
+                              TempFmpImageInfo->ImageIndex,                                          // ImageIndex
+                              (UINT8 *)(ImageHeader + 1),                                            // Image
+                              ImageHeader->UpdateImageSize,                                          // ImageSize
+                              (UINT8 *)((UINT8 *) (ImageHeader + 1) + ImageHeader->UpdateImageSize), // VendorCode
+                              Update_Image_Progress,                                                 // Progress
+                              &AbortReason                                                           // AbortReason
+                              );
+            }
+            if (AbortReason != NULL) {
+              DEBUG ((EFI_D_ERROR, "%s\n", AbortReason));
+              FreePool(AbortReason);
+            }
+          }
+        }
+        //
+        // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version
+        //
+        TempFmpImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)TempFmpImageInfo + DescriptorSize);
+      }
+      FreePool(FmpImageInfoBuf);
+    }
+  }
+
+EXIT:
+
+  if (HandleBuffer != NULL) {
+    FreePool(HandleBuffer);
+  }
+
+  if (DriverDevicePath != NULL) {
+    FreePool(DriverDevicePath);
+  }
+
+  return Status;
+}
 
 /**
@@ -28 +384 @@
   @retval EFI_SUCESS       Input capsule is supported by firmware.
   @retval EFI_UNSUPPORTED  Input capsule is not supported by the firmware.
+  @retval EFI_INVALID_PARAMETER Input capsule layout is not correct
 **/
 EFI_STATUS
@@ -37 +394 @@
   if (CompareGuid (&gEfiCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
     return EFI_SUCCESS;
+  }
+
+  if (CompareGuid (&gEfiFmpCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
+    //
+    // Check layout of FMP capsule
+    //
+    return ValidateFmpCapsule(CapsuleHeader);
   }
 
@@ -74 +438 @@
 
   //
+  // Check FMP capsule layout
+  //
+  if (CompareGuid (&gEfiFmpCapsuleGuid, &CapsuleHeader->CapsuleGuid)){
+    Status = ValidateFmpCapsule(CapsuleHeader);
+    if (EFI_ERROR(Status)) {
+      return Status;
+    }
+
+    //
+    // Press EFI FMP Capsule
+    //
+    return ProcessFmpCapsuleImage(CapsuleHeader);
+  }
+
+  //
   // Skip the capsule header, move to the Firware Volume
   //

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.inf

@@ -1 +1 @@
 ## @file
-# Capsule library instance for DXE_DRIVER, DXE_RUNTIME_DRIVER
+# Capsule library instance for DXE_DRIVER, DXE_RUNTIME_DRIVER.
 #
-# Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
 #
 # This program and the accompanying materials
@@ -17 +17 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = DxeCapsuleLib
+  MODULE_UNI_FILE                = DxeCapsuleLib.uni
   FILE_GUID                      = 654950df-1ede-4b04-b144-6b77845736ad
   MODULE_TYPE                    = DXE_DRIVER
@@ -34 +35 @@
 [Packages]
   MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
   IntelFrameworkPkg/IntelFrameworkPkg.dec
-  MdeModulePkg/MdeModulePkg.dec
+  IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
 
 [LibraryClasses]
@@ -42 +44 @@
   MemoryAllocationLib
   DxeServicesTableLib
+  GenericBdsLib
+  UefiBootServicesTableLib
+  DevicePathLib
+
+[Protocols]
+  gEfiFirmwareManagementProtocolGuid      ## SOMETIMES_CONSUMES
 
 [Guids]
-  gEfiCapsuleGuid                         # SOMETIMES_CONSUMED
-  
+  gEfiCapsuleGuid                         ## SOMETIMES_CONSUMES ## GUID # Capsule Image Header Guid
+  gEfiFmpCapsuleGuid                      ## SOMETIMES_CONSUMES ## GUID

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

@@ -1 +1 @@
 ## @file
-#  DXE report status code library
+#  Framework DXE report status code library to support EFI1.1 and UEFI2.0 system.
 #
-#  Retrieve status code and report status code in DXE phase
-#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -18 +17 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = DxeReportStatusCodeLib
+  MODULE_UNI_FILE                = DxeReportStatusCodeLib.uni
   FILE_GUID                      = 3ddc3b12-99ea-4364-b315-6310a2050be5
   MODULE_TYPE                    = DXE_DRIVER
@@ -48 +48 @@
 
 [Guids]
-  gEfiStatusCodeSpecificDataGuid                ## CONSUMES
-  gEfiStatusCodeDataTypeDebugGuid               ## CONSUMES
+  gEfiStatusCodeSpecificDataGuid                ## SOMETIMES_CONSUMES ## UNDEFINED
+  gEfiStatusCodeDataTypeDebugGuid               ## SOMETIMES_CONSUMES ## UNDEFINED
 
 [Protocols]
-  gEfiStatusCodeRuntimeProtocolGuid             ## SOMETIMES_CONSUMES (Used if revision of the EFI Specification is not less than 0x20000)
+  gEfiStatusCodeRuntimeProtocolGuid             ## SOMETIMES_CONSUMES # Used if revision of the EFI Specification is not less than 0x20000
 
 [Pcd]
-  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask
+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask  ## CONSUMES
 

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsBoot.c

@@ -2 +2 @@
   BDS Lib functions which relate with create or process the boot option.
 
-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -49 +49 @@
   gBdsLibStringPackHandle = HiiAddPackages (
                               &gBdsLibStringPackageGuid,
-                              &ImageHandle,
+                              ImageHandle,
                               GenericBdsLibStrings,
                               NULL
@@ -59 +59 @@
 }
 
-
+/**
+  Deletete the Boot Option from EFI Variable. The Boot Order Arrray
+  is also updated.
+
+  @param OptionNumber    The number of Boot option want to be deleted.
+  @param BootOrder       The Boot Order array.
+  @param BootOrderSize   The size of the Boot Order Array.
+
+  @retval  EFI_SUCCESS           The Boot Option Variable was found and removed
+  @retval  EFI_UNSUPPORTED       The Boot Option Variable store was inaccessible
+  @retval  EFI_NOT_FOUND         The Boot Option Variable was not found
+**/
+EFI_STATUS
+EFIAPI
+BdsDeleteBootOption (
+  IN UINTN                       OptionNumber,
+  IN OUT UINT16                  *BootOrder,
+  IN OUT UINTN                   *BootOrderSize
+  )
+{
+  CHAR16      BootOption[9];
+  UINTN       Index;
+  EFI_STATUS  Status;
+
+  UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", OptionNumber);
+  Status = gRT->SetVariable (
+                  BootOption,
+                  &gEfiGlobalVariableGuid,
+                  0,
+                  0,
+                  NULL
+                  );
+  //
+  // Deleting variable with existing variable implementation shouldn't fail.
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // adjust boot order array
+  //
+  for (Index = 0; Index < *BootOrderSize / sizeof (UINT16); Index++) {
+    if (BootOrder[Index] == OptionNumber) {
+      CopyMem (&BootOrder[Index], &BootOrder[Index+1], *BootOrderSize - (Index+1) * sizeof (UINT16));
+      *BootOrderSize -= sizeof (UINT16);
+      break;
+    }
+  }
+
+  return Status;
+}
+/**
+
+  Translate the first n characters of an Ascii string to
+  Unicode characters. The count n is indicated by parameter
+  Size. If Size is greater than the length of string, then
+  the entire string is translated.
+
+
+  @param AStr               Pointer to input Ascii string.
+  @param Size               The number of characters to translate.
+  @param UStr               Pointer to output Unicode string buffer.
+
+**/
+VOID
+AsciiToUnicodeSize (
+  IN UINT8              *AStr,
+  IN UINTN              Size,
+  OUT UINT16            *UStr
+  )
+{
+  UINTN Idx;
+
+  Idx = 0;
+  while (AStr[Idx] != 0) {
+    UStr[Idx] = (CHAR16) AStr[Idx];
+    if (Idx == Size) {
+      break;
+    }
+
+    Idx++;
+  }
+  UStr[Idx] = 0;
+}
+
+/**
+  Build Legacy Device Name String according.
+
+  @param CurBBSEntry     BBS Table.
+  @param Index           Index.
+  @param BufSize         The buffer size.
+  @param BootString      The output string.
+
+**/
+VOID
+BdsBuildLegacyDevNameString (
+  IN  BBS_TABLE                 *CurBBSEntry,
+  IN  UINTN                     Index,
+  IN  UINTN                     BufSize,
+  OUT CHAR16                    *BootString
+  )
+{
+  CHAR16  *Fmt;
+  CHAR16  *Type;
+  UINT8   *StringDesc;
+  CHAR16  Temp[80];
+
+  switch (Index) {
+  //
+  // Primary Master
+  //
+  case 1:
+    Fmt = L"Primary Master %s";
+    break;
+
+ //
+ // Primary Slave
+ //
+  case 2:
+    Fmt = L"Primary Slave %s";
+    break;
+
+  //
+  // Secondary Master
+  //
+  case 3:
+    Fmt = L"Secondary Master %s";
+    break;
+
+  //
+  // Secondary Slave
+  //
+  case 4:
+    Fmt = L"Secondary Slave %s";
+    break;
+
+  default:
+    Fmt = L"%s";
+    break;
+  }
+
+  switch (CurBBSEntry->DeviceType) {
+  case BBS_FLOPPY:
+    Type = L"Floppy";
+    break;
+
+  case BBS_HARDDISK:
+    Type = L"Harddisk";
+    break;
+
+  case BBS_CDROM:
+    Type = L"CDROM";
+    break;
+
+  case BBS_PCMCIA:
+    Type = L"PCMCIAe";
+    break;
+
+  case BBS_USB:
+    Type = L"USB";
+    break;
+
+  case BBS_EMBED_NETWORK:
+    Type = L"Network";
+    break;
+
+  case BBS_BEV_DEVICE:
+    Type = L"BEVe";
+    break;
+
+  case BBS_UNKNOWN:
+  default:
+    Type = L"Unknown";
+    break;
+  }
+  //
+  // If current BBS entry has its description then use it.
+  //
+  StringDesc = (UINT8 *) (UINTN) ((CurBBSEntry->DescStringSegment << 4) + CurBBSEntry->DescStringOffset);
+  if (NULL != StringDesc) {
+    //
+    // Only get fisrt 32 characters, this is suggested by BBS spec
+    //
+    AsciiToUnicodeSize (StringDesc, 32, Temp);
+    Fmt   = L"%s";
+    Type  = Temp;
+  }
+
+  //
+  // BbsTable 16 entries are for onboard IDE.
+  // Set description string for SATA harddisks, Harddisk 0 ~ Harddisk 11
+  //
+  if (Index >= 5 && Index <= 16 && (CurBBSEntry->DeviceType == BBS_HARDDISK || CurBBSEntry->DeviceType == BBS_CDROM)) {
+    Fmt = L"%s %d";
+    UnicodeSPrint (BootString, BufSize, Fmt, Type, Index - 5);
+  } else {
+    UnicodeSPrint (BootString, BufSize, Fmt, Type);
+  }
+}
+
+/**
+
+  Create a legacy boot option for the specified entry of
+  BBS table, save it as variable, and append it to the boot
+  order list.
+
+
+  @param CurrentBbsEntry    Pointer to current BBS table.
+  @param CurrentBbsDevPath  Pointer to the Device Path Protocol instance of BBS
+  @param Index              Index of the specified entry in BBS table.
+  @param BootOrderList      On input, the original boot order list.
+                            On output, the new boot order list attached with the
+                            created node.
+  @param BootOrderListSize  On input, the original size of boot order list.
+                            On output, the size of new boot order list.
+
+  @retval  EFI_SUCCESS             Boot Option successfully created.
+  @retval  EFI_OUT_OF_RESOURCES    Fail to allocate necessary memory.
+  @retval  Other                   Error occurs while setting variable.
+
+**/
+EFI_STATUS
+BdsCreateLegacyBootOption (
+  IN BBS_TABLE                        *CurrentBbsEntry,
+  IN EFI_DEVICE_PATH_PROTOCOL         *CurrentBbsDevPath,
+  IN UINTN                            Index,
+  IN OUT UINT16                       **BootOrderList,
+  IN OUT UINTN                        *BootOrderListSize
+  )
+{
+  EFI_STATUS           Status;
+  UINT16               CurrentBootOptionNo;
+  UINT16               BootString[10];
+  CHAR16               BootDesc[100];
+  CHAR8                HelpString[100];
+  UINT16               *NewBootOrderList;
+  UINTN                BufferSize;
+  UINTN                StringLen;
+  VOID                 *Buffer;
+  UINT8                *Ptr;
+  UINT16               CurrentBbsDevPathSize;
+  UINTN                BootOrderIndex;
+  UINTN                BootOrderLastIndex;
+  UINTN                ArrayIndex;
+  BOOLEAN              IndexNotFound;
+  BBS_BBS_DEVICE_PATH  *NewBbsDevPathNode;
+
+  if ((*BootOrderList) == NULL) {
+    CurrentBootOptionNo = 0;
+  } else {
+    for (ArrayIndex = 0; ArrayIndex < (UINTN) (*BootOrderListSize / sizeof (UINT16)); ArrayIndex++) {
+      IndexNotFound = TRUE;
+      for (BootOrderIndex = 0; BootOrderIndex < (UINTN) (*BootOrderListSize / sizeof (UINT16)); BootOrderIndex++) {
+        if ((*BootOrderList)[BootOrderIndex] == ArrayIndex) {
+          IndexNotFound = FALSE;
+          break;
+        }
+      }
+
+      if (!IndexNotFound) {
+        continue;
+      } else {
+        break;
+      }
+    }
+
+    CurrentBootOptionNo = (UINT16) ArrayIndex;
+  }
+
+  UnicodeSPrint (
+    BootString,
+    sizeof (BootString),
+    L"Boot%04x",
+    CurrentBootOptionNo
+    );
+
+  BdsBuildLegacyDevNameString (CurrentBbsEntry, Index, sizeof (BootDesc), BootDesc);
+
+  //
+  // Create new BBS device path node with description string
+  //
+  UnicodeStrToAsciiStr (BootDesc, HelpString);
+
+  StringLen = AsciiStrLen (HelpString);
+  NewBbsDevPathNode = AllocateZeroPool (sizeof (BBS_BBS_DEVICE_PATH) + StringLen);
+  if (NewBbsDevPathNode == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  CopyMem (NewBbsDevPathNode, CurrentBbsDevPath, sizeof (BBS_BBS_DEVICE_PATH));
+  CopyMem (NewBbsDevPathNode->String, HelpString, StringLen + 1);
+  SetDevicePathNodeLength (&(NewBbsDevPathNode->Header), sizeof (BBS_BBS_DEVICE_PATH) + StringLen);
+
+  //
+  // Create entire new CurrentBbsDevPath with end node
+  //
+  CurrentBbsDevPath = AppendDevicePathNode (
+                        NULL,
+                        (EFI_DEVICE_PATH_PROTOCOL *) NewBbsDevPathNode
+                        );
+   if (CurrentBbsDevPath == NULL) {
+    FreePool (NewBbsDevPathNode);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  CurrentBbsDevPathSize = (UINT16) (GetDevicePathSize (CurrentBbsDevPath));
+
+  BufferSize = sizeof (UINT32) +
+    sizeof (UINT16) +
+    StrSize (BootDesc) +
+    CurrentBbsDevPathSize +
+    sizeof (BBS_TABLE) +
+    sizeof (UINT16);
+
+  Buffer = AllocateZeroPool (BufferSize);
+  if (Buffer == NULL) {
+    FreePool (NewBbsDevPathNode);
+    FreePool (CurrentBbsDevPath);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Ptr               = (UINT8 *) Buffer;
+
+  *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE;
+  Ptr += sizeof (UINT32);
+
+  *((UINT16 *) Ptr) = CurrentBbsDevPathSize;
+  Ptr += sizeof (UINT16);
+
+  CopyMem (
+    Ptr,
+    BootDesc,
+    StrSize (BootDesc)
+    );
+  Ptr += StrSize (BootDesc);
+
+  CopyMem (
+    Ptr,
+    CurrentBbsDevPath,
+    CurrentBbsDevPathSize
+    );
+  Ptr += CurrentBbsDevPathSize;
+
+  CopyMem (
+    Ptr,
+    CurrentBbsEntry,
+    sizeof (BBS_TABLE)
+    );
+
+  Ptr += sizeof (BBS_TABLE);
+  *((UINT16 *) Ptr) = (UINT16) Index;
+
+  Status = gRT->SetVariable (
+                  BootString,
+                  &gEfiGlobalVariableGuid,
+                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                  BufferSize,
+                  Buffer
+                  );
+
+  FreePool (Buffer);
+  
+  Buffer = NULL;
+
+  NewBootOrderList = AllocateZeroPool (*BootOrderListSize + sizeof (UINT16));
+  if (NULL == NewBootOrderList) {
+    FreePool (NewBbsDevPathNode);
+    FreePool (CurrentBbsDevPath);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  if (*BootOrderList != NULL) {
+    CopyMem (NewBootOrderList, *BootOrderList, *BootOrderListSize);
+    FreePool (*BootOrderList);
+  }
+
+  BootOrderLastIndex                    = (UINTN) (*BootOrderListSize / sizeof (UINT16));
+  NewBootOrderList[BootOrderLastIndex]  = CurrentBootOptionNo;
+  *BootOrderListSize += sizeof (UINT16);
+  *BootOrderList = NewBootOrderList;
+
+  FreePool (NewBbsDevPathNode);
+  FreePool (CurrentBbsDevPath);
+  return Status;
+}
+
+/**
+  Check if the boot option is a legacy one.
+
+  @param BootOptionVar   The boot option data payload.
+  @param BbsEntry        The BBS Table.
+  @param BbsIndex        The table index.
+
+  @retval TRUE           It is a legacy boot option.
+  @retval FALSE          It is not a legacy boot option.
+
+**/
+BOOLEAN
+BdsIsLegacyBootOption (
+  IN UINT8                 *BootOptionVar,
+  OUT BBS_TABLE            **BbsEntry,
+  OUT UINT16               *BbsIndex
+  )
+{
+  UINT8                     *Ptr;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
+  BOOLEAN                   Ret;
+  UINT16                    DevPathLen;
+
+  Ptr = BootOptionVar;
+  Ptr += sizeof (UINT32);
+  DevPathLen = *(UINT16 *) Ptr;
+  Ptr += sizeof (UINT16);
+  Ptr += StrSize ((UINT16 *) Ptr);
+  DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
+  if ((BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType)) {
+    Ptr += DevPathLen;
+    *BbsEntry = (BBS_TABLE *) Ptr;
+    Ptr += sizeof (BBS_TABLE);
+    *BbsIndex = *(UINT16 *) Ptr;
+    Ret       = TRUE;
+  } else {
+    *BbsEntry = NULL;
+    Ret       = FALSE;
+  }
+
+  return Ret;
+}
+
+/**
+  Delete all the invalid legacy boot options.
+
+  @retval EFI_SUCCESS             All invalide legacy boot options are deleted.
+  @retval EFI_OUT_OF_RESOURCES    Fail to allocate necessary memory.
+  @retval EFI_NOT_FOUND           Fail to retrive variable of boot order.
+**/
+EFI_STATUS
+EFIAPI
+BdsDeleteAllInvalidLegacyBootOptions (
+  VOID
+  )
+{
+  UINT16                    *BootOrder;
+  UINT8                     *BootOptionVar;
+  UINTN                     BootOrderSize;
+  UINTN                     BootOptionSize;
+  EFI_STATUS                Status;
+  UINT16                    HddCount;
+  UINT16                    BbsCount;
+  HDD_INFO                  *LocalHddInfo;
+  BBS_TABLE                 *LocalBbsTable;
+  BBS_TABLE                 *BbsEntry;
+  UINT16                    BbsIndex;
+  EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
+  UINTN                     Index;
+  UINT16                    BootOption[10];
+  UINT16                    BootDesc[100];
+  BOOLEAN                   DescStringMatch;
+
+  Status        = EFI_SUCCESS;
+  BootOrder     = NULL;
+  BootOrderSize = 0;
+  HddCount      = 0;
+  BbsCount      = 0;
+  LocalHddInfo  = NULL;
+  LocalBbsTable = NULL;
+  BbsEntry      = NULL;
+
+  Status        = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  BootOrder = BdsLibGetVariableAndSize (
+                L"BootOrder",
+                &gEfiGlobalVariableGuid,
+                &BootOrderSize
+                );
+  if (BootOrder == NULL) {
+    return EFI_NOT_FOUND;
+  }
+
+  LegacyBios->GetBbsInfo (
+                LegacyBios,
+                &HddCount,
+                &LocalHddInfo,
+                &BbsCount,
+                &LocalBbsTable
+                );
+
+  Index = 0;
+  while (Index < BootOrderSize / sizeof (UINT16)) {
+    UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
+    BootOptionVar = BdsLibGetVariableAndSize (
+                      BootOption,
+                      &gEfiGlobalVariableGuid,
+                      &BootOptionSize
+                      );
+    if (NULL == BootOptionVar) {
+      BootOptionSize = 0;
+      Status = gRT->GetVariable (
+                      BootOption,
+                      &gEfiGlobalVariableGuid,
+                      NULL,
+                      &BootOptionSize,
+                      BootOptionVar
+                      );
+      if (Status == EFI_NOT_FOUND) {
+        //
+        // Update BootOrder
+        //
+        BdsDeleteBootOption (
+          BootOrder[Index],
+          BootOrder,
+          &BootOrderSize
+          );
+        continue;
+      } else {
+        FreePool (BootOrder);
+        return EFI_OUT_OF_RESOURCES;
+      }
+    }
+  
+    //
+    // Skip Non-Legacy boot option
+    // 
+    if (!BdsIsLegacyBootOption (BootOptionVar, &BbsEntry, &BbsIndex)) {
+      if (BootOptionVar!= NULL) {
+        FreePool (BootOptionVar);
+      }
+      Index++;
+      continue;
+    }
+
+    if (BbsIndex < BbsCount) {
+      //
+      // Check if BBS Description String is changed
+      //
+      DescStringMatch = FALSE;
+      BdsBuildLegacyDevNameString (
+        &LocalBbsTable[BbsIndex],
+        BbsIndex,
+        sizeof (BootDesc),
+        BootDesc
+        );
+
+      if (StrCmp (BootDesc, (UINT16*)(BootOptionVar + sizeof (UINT32) + sizeof (UINT16))) == 0) {
+        DescStringMatch = TRUE;
+      }
+
+      if (!((LocalBbsTable[BbsIndex].BootPriority == BBS_IGNORE_ENTRY) ||
+            (LocalBbsTable[BbsIndex].BootPriority == BBS_DO_NOT_BOOT_FROM)) &&
+          (LocalBbsTable[BbsIndex].DeviceType == BbsEntry->DeviceType) &&
+          DescStringMatch) {
+        Index++;
+        continue;
+      }
+    }
+
+    if (BootOptionVar != NULL) {
+      FreePool (BootOptionVar);
+    }
+    //
+    // should delete
+    //
+    BdsDeleteBootOption (
+      BootOrder[Index],
+      BootOrder,
+      &BootOrderSize
+      );
+  }
+
+  //
+  // Adjust the number of boot options.
+  //
+  Status = gRT->SetVariable (
+                  L"BootOrder",
+                  &gEfiGlobalVariableGuid,
+                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                  BootOrderSize,
+                  BootOrder
+                  );
+  //
+  // Shrinking variable with existing variable implementation shouldn't fail.
+  //
+  ASSERT_EFI_ERROR (Status);
+  FreePool (BootOrder);
+
+  return Status;
+}
+
+/**
+  Find all legacy boot option by device type.
+
+  @param BootOrder       The boot order array.
+  @param BootOptionNum   The number of boot option.
+  @param DevType         Device type.
+  @param DevName         Device name.
+  @param Attribute       The boot option attribute.
+  @param BbsIndex        The BBS table index.
+  @param OptionNumber    The boot option index.
+
+  @retval TRUE           The Legacy boot option is found.
+  @retval FALSE          The legacy boot option is not found.
+
+**/
+BOOLEAN
+BdsFindLegacyBootOptionByDevTypeAndName (
+  IN UINT16                 *BootOrder,
+  IN UINTN                  BootOptionNum,
+  IN UINT16                 DevType,
+  IN CHAR16                 *DevName,
+  OUT UINT32                *Attribute,
+  OUT UINT16                *BbsIndex,
+  OUT UINT16                *OptionNumber
+  )
+{
+  UINTN     Index;
+  CHAR16    BootOption[9];
+  UINTN     BootOptionSize;
+  UINT8     *BootOptionVar;
+  BBS_TABLE *BbsEntry;
+  BOOLEAN   Found;
+
+  BbsEntry  = NULL;
+  Found     = FALSE;
+
+  if (NULL == BootOrder) {
+    return Found;
+  }
+
+  //
+  // Loop all boot option from variable
+  //
+  for (Index = 0; Index < BootOptionNum; Index++) {
+    UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", (UINTN) BootOrder[Index]);
+    BootOptionVar = BdsLibGetVariableAndSize (
+                      BootOption,
+                      &gEfiGlobalVariableGuid,
+                      &BootOptionSize
+                      );
+    if (NULL == BootOptionVar) {
+      continue;
+    }
+
+    //
+    // Skip Non-legacy boot option
+    //
+    if (!BdsIsLegacyBootOption (BootOptionVar, &BbsEntry, BbsIndex)) {
+      FreePool (BootOptionVar);
+      continue;
+    }
+
+    if (
+        (BbsEntry->DeviceType != DevType) ||
+        (StrCmp (DevName, (CHAR16*)(BootOptionVar + sizeof (UINT32) + sizeof (UINT16))) != 0)
+       ) {
+      FreePool (BootOptionVar);
+      continue;
+    }
+
+    *Attribute    = *(UINT32 *) BootOptionVar;
+    *OptionNumber = BootOrder[Index];
+    Found         = TRUE;
+    FreePool (BootOptionVar);
+    break;
+  }
+
+  return Found;
+}
+
+/**
+  Create a legacy boot option.
+
+  @param BbsItem         The BBS Table entry.
+  @param Index           Index of the specified entry in BBS table.
+  @param BootOrderList   The boot order list.
+  @param BootOrderListSize The size of boot order list.
+
+  @retval EFI_OUT_OF_RESOURCE  No enough memory.
+  @retval EFI_SUCCESS          The function complete successfully.
+  @return Other value if the legacy boot option is not created.
+
+**/
+EFI_STATUS
+BdsCreateOneLegacyBootOption (
+  IN BBS_TABLE              *BbsItem,
+  IN UINTN                  Index,
+  IN OUT UINT16             **BootOrderList,
+  IN OUT UINTN              *BootOrderListSize
+  )
+{
+  BBS_BBS_DEVICE_PATH       BbsDevPathNode;
+  EFI_STATUS                Status;
+  EFI_DEVICE_PATH_PROTOCOL  *DevPath;
+
+  DevPath                       = NULL;
+
+  //
+  // Create device path node.
+  //
+  BbsDevPathNode.Header.Type    = BBS_DEVICE_PATH;
+  BbsDevPathNode.Header.SubType = BBS_BBS_DP;
+  SetDevicePathNodeLength (&BbsDevPathNode.Header, sizeof (BBS_BBS_DEVICE_PATH));
+  BbsDevPathNode.DeviceType = BbsItem->DeviceType;
+  CopyMem (&BbsDevPathNode.StatusFlag, &BbsItem->StatusFlags, sizeof (UINT16));
+
+  DevPath = AppendDevicePathNode (
+              NULL,
+              (EFI_DEVICE_PATH_PROTOCOL *) &BbsDevPathNode
+              );
+  if (NULL == DevPath) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Status = BdsCreateLegacyBootOption (
+            BbsItem,
+            DevPath,
+            Index,
+            BootOrderList,
+            BootOrderListSize
+            );
+  BbsItem->BootPriority = 0x00;
+
+  FreePool (DevPath);
+
+  return Status;
+}
+
+/**
+  Add the legacy boot options from BBS table if they do not exist.
+
+  @retval EFI_SUCCESS          The boot options are added successfully 
+                               or they are already in boot options.
+  @retval EFI_NOT_FOUND        No legacy boot options is found.
+  @retval EFI_OUT_OF_RESOURCE  No enough memory.
+  @return Other value          LegacyBoot options are not added.
+**/
+EFI_STATUS
+EFIAPI
+BdsAddNonExistingLegacyBootOptions (
+  VOID
+  )
+{
+  UINT16                    *BootOrder;
+  UINTN                     BootOrderSize;
+  EFI_STATUS                Status;
+  CHAR16                    Desc[100];
+  UINT16                    HddCount;
+  UINT16                    BbsCount;
+  HDD_INFO                  *LocalHddInfo;
+  BBS_TABLE                 *LocalBbsTable;
+  UINT16                    BbsIndex;
+  EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
+  UINT16                    Index;
+  UINT32                    Attribute;
+  UINT16                    OptionNumber;
+  BOOLEAN                   Exist;
+
+  HddCount      = 0;
+  BbsCount      = 0;
+  LocalHddInfo  = NULL;
+  LocalBbsTable = NULL;
+
+  Status        = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  LegacyBios->GetBbsInfo (
+                LegacyBios,
+                &HddCount,
+                &LocalHddInfo,
+                &BbsCount,
+                &LocalBbsTable
+                );
+
+  BootOrder = BdsLibGetVariableAndSize (
+                L"BootOrder",
+                &gEfiGlobalVariableGuid,
+                &BootOrderSize
+                );
+  if (BootOrder == NULL) {
+    BootOrderSize = 0;
+  }
+
+  for (Index = 0; Index < BbsCount; Index++) {
+    if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
+        (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
+        ) {
+      continue;
+    }
+
+    BdsBuildLegacyDevNameString (&LocalBbsTable[Index], Index, sizeof (Desc), Desc);
+
+    Exist = BdsFindLegacyBootOptionByDevTypeAndName (
+              BootOrder,
+              BootOrderSize / sizeof (UINT16),
+              LocalBbsTable[Index].DeviceType,
+              Desc,
+              &Attribute,
+              &BbsIndex,
+              &OptionNumber
+              );
+    if (!Exist) {
+      //
+      // Not found such type of legacy device in boot options or we found but it's disabled
+      // so we have to create one and put it to the tail of boot order list
+      //
+      Status = BdsCreateOneLegacyBootOption (
+                &LocalBbsTable[Index],
+                Index,
+                &BootOrder,
+                &BootOrderSize
+                );
+      if (!EFI_ERROR (Status)) {
+        ASSERT (BootOrder != NULL);
+        BbsIndex     = Index;
+        OptionNumber = BootOrder[BootOrderSize / sizeof (UINT16) - 1];
+      }
+    }
+
+    ASSERT (BbsIndex == Index);
+  }
+
+  Status = gRT->SetVariable (
+                  L"BootOrder",
+                  &gEfiGlobalVariableGuid,
+                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                  BootOrderSize,
+                  BootOrder
+                  );
+  if (BootOrder != NULL) {
+    FreePool (BootOrder);
+  }
+
+  return Status;
+}
+
+/**
+  Fill the device order buffer.
+
+  @param BbsTable        The BBS table.
+  @param BbsType         The BBS Type.
+  @param BbsCount        The BBS Count.
+  @param Buf             device order buffer.
+
+  @return The device order buffer.
+
+**/
+UINT16 *
+BdsFillDevOrderBuf (
+  IN BBS_TABLE                    *BbsTable,
+  IN BBS_TYPE                     BbsType,
+  IN UINTN                        BbsCount,
+  OUT UINT16                      *Buf
+  )
+{
+  UINTN Index;
+
+  for (Index = 0; Index < BbsCount; Index++) {
+    if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {
+      continue;
+    }
+
+    if (BbsTable[Index].DeviceType != BbsType) {
+      continue;
+    }
+
+    *Buf = (UINT16) (Index & 0xFF);
+    Buf++;
+  }
+
+  return Buf;
+}
+
+/**
+  Create the device order buffer.
+
+  @param BbsTable        The BBS table.
+  @param BbsCount        The BBS Count.
+
+  @retval EFI_SUCCES             The buffer is created and the EFI variable named 
+                                 VAR_LEGACY_DEV_ORDER and gEfiLegacyDevOrderVariableGuid is
+                                 set correctly.
+  @retval EFI_OUT_OF_RESOURCES   Memmory or storage is not enough.
+  @retval EFI_DEVICE_ERROR       Fail to add the device order into EFI variable fail
+                                 because of hardware error.
+**/
+EFI_STATUS
+BdsCreateDevOrder (
+  IN BBS_TABLE                  *BbsTable,
+  IN UINT16                     BbsCount
+  )
+{
+  UINTN                       Index;
+  UINTN                       FDCount;
+  UINTN                       HDCount;
+  UINTN                       CDCount;
+  UINTN                       NETCount;
+  UINTN                       BEVCount;
+  UINTN                       TotalSize;
+  UINTN                       HeaderSize;
+  LEGACY_DEV_ORDER_ENTRY      *DevOrder;
+  LEGACY_DEV_ORDER_ENTRY      *DevOrderPtr;
+  EFI_STATUS                  Status;
+
+  FDCount     = 0;
+  HDCount     = 0;
+  CDCount     = 0;
+  NETCount    = 0;
+  BEVCount    = 0;
+  TotalSize   = 0;
+  HeaderSize  = sizeof (BBS_TYPE) + sizeof (UINT16);
+  DevOrder    = NULL;
+  Status      = EFI_SUCCESS;
+
+  //
+  // Count all boot devices
+  //
+  for (Index = 0; Index < BbsCount; Index++) {
+    if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {
+      continue;
+    }
+
+    switch (BbsTable[Index].DeviceType) {
+    case BBS_FLOPPY:
+      FDCount++;
+      break;
+
+    case BBS_HARDDISK:
+      HDCount++;
+      break;
+
+    case BBS_CDROM:
+      CDCount++;
+      break;
+
+    case BBS_EMBED_NETWORK:
+      NETCount++;
+      break;
+
+    case BBS_BEV_DEVICE:
+      BEVCount++;
+      break;
+
+    default:
+      break;
+    }
+  }
+
+  TotalSize += (HeaderSize + sizeof (UINT16) * FDCount);
+  TotalSize += (HeaderSize + sizeof (UINT16) * HDCount);
+  TotalSize += (HeaderSize + sizeof (UINT16) * CDCount);
+  TotalSize += (HeaderSize + sizeof (UINT16) * NETCount);
+  TotalSize += (HeaderSize + sizeof (UINT16) * BEVCount);
+
+  //
+  // Create buffer to hold all boot device order
+  //
+  DevOrder = AllocateZeroPool (TotalSize);
+  if (NULL == DevOrder) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  DevOrderPtr          = DevOrder;
+
+  DevOrderPtr->BbsType = BBS_FLOPPY;
+  DevOrderPtr->Length  = (UINT16) (sizeof (DevOrderPtr->Length) + FDCount * sizeof (UINT16));
+  DevOrderPtr          = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_FLOPPY, BbsCount, DevOrderPtr->Data);
+
+  DevOrderPtr->BbsType = BBS_HARDDISK;
+  DevOrderPtr->Length  = (UINT16) (sizeof (UINT16) + HDCount * sizeof (UINT16));
+  DevOrderPtr          = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_HARDDISK, BbsCount, DevOrderPtr->Data);
+  
+  DevOrderPtr->BbsType = BBS_CDROM;
+  DevOrderPtr->Length  = (UINT16) (sizeof (UINT16) + CDCount * sizeof (UINT16));
+  DevOrderPtr          = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_CDROM, BbsCount, DevOrderPtr->Data);
+  
+  DevOrderPtr->BbsType = BBS_EMBED_NETWORK;
+  DevOrderPtr->Length  = (UINT16) (sizeof (UINT16) + NETCount * sizeof (UINT16));
+  DevOrderPtr          = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_EMBED_NETWORK, BbsCount, DevOrderPtr->Data);
+
+  DevOrderPtr->BbsType = BBS_BEV_DEVICE;
+  DevOrderPtr->Length  = (UINT16) (sizeof (UINT16) + BEVCount * sizeof (UINT16));
+  DevOrderPtr          = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_BEV_DEVICE, BbsCount, DevOrderPtr->Data);
+
+  ASSERT (TotalSize == (UINTN) ((UINT8 *) DevOrderPtr - (UINT8 *) DevOrder));
+
+  //
+  // Save device order for legacy boot device to variable.
+  //
+  Status = gRT->SetVariable (
+                  VAR_LEGACY_DEV_ORDER,
+                  &gEfiLegacyDevOrderVariableGuid,
+                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                  TotalSize,
+                  DevOrder
+                  );
+  FreePool (DevOrder);
+
+  return Status;
+}
+
+/**
+  Add the legacy boot devices from BBS table into 
+  the legacy device boot order.
+
+  @retval EFI_SUCCESS           The boot devices are added successfully.
+  @retval EFI_NOT_FOUND         The legacy boot devices are not found.
+  @retval EFI_OUT_OF_RESOURCES  Memmory or storage is not enough.
+  @retval EFI_DEVICE_ERROR      Fail to add the legacy device boot order into EFI variable
+                                because of hardware error.
+**/
+EFI_STATUS
+EFIAPI
+BdsUpdateLegacyDevOrder (
+  VOID
+  )
+{
+  LEGACY_DEV_ORDER_ENTRY      *DevOrder;
+  LEGACY_DEV_ORDER_ENTRY      *NewDevOrder;
+  LEGACY_DEV_ORDER_ENTRY      *Ptr;
+  LEGACY_DEV_ORDER_ENTRY      *NewPtr;
+  UINTN                       DevOrderSize;
+  EFI_LEGACY_BIOS_PROTOCOL    *LegacyBios;
+  EFI_STATUS                  Status;
+  UINT16                      HddCount;
+  UINT16                      BbsCount;
+  HDD_INFO                    *LocalHddInfo;
+  BBS_TABLE                   *LocalBbsTable;
+  UINTN                       Index;
+  UINTN                       Index2;
+  UINTN                       *Idx;
+  UINTN                       FDCount;
+  UINTN                       HDCount;
+  UINTN                       CDCount;
+  UINTN                       NETCount;
+  UINTN                       BEVCount;
+  UINTN                       TotalSize;
+  UINTN                       HeaderSize;
+  UINT16                      *NewFDPtr;
+  UINT16                      *NewHDPtr;
+  UINT16                      *NewCDPtr;
+  UINT16                      *NewNETPtr;
+  UINT16                      *NewBEVPtr;
+  UINT16                      *NewDevPtr;
+  UINTN                       FDIndex;
+  UINTN                       HDIndex;
+  UINTN                       CDIndex;
+  UINTN                       NETIndex;
+  UINTN                       BEVIndex;
+
+  Idx           = NULL;
+  FDCount       = 0;
+  HDCount       = 0;
+  CDCount       = 0;
+  NETCount      = 0;
+  BEVCount      = 0;
+  TotalSize     = 0;
+  HeaderSize    = sizeof (BBS_TYPE) + sizeof (UINT16);
+  FDIndex       = 0;
+  HDIndex       = 0;
+  CDIndex       = 0;
+  NETIndex      = 0;
+  BEVIndex      = 0;
+  NewDevPtr     = NULL;
+
+  Status        = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = LegacyBios->GetBbsInfo (
+                         LegacyBios,
+                         &HddCount,
+                         &LocalHddInfo,
+                         &BbsCount,
+                         &LocalBbsTable
+                         );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  DevOrder = BdsLibGetVariableAndSize (
+               VAR_LEGACY_DEV_ORDER,
+               &gEfiLegacyDevOrderVariableGuid,
+               &DevOrderSize
+               );
+  if (NULL == DevOrder) {
+    return BdsCreateDevOrder (LocalBbsTable, BbsCount);
+  }
+  //
+  // First we figure out how many boot devices with same device type respectively
+  //
+  for (Index = 0; Index < BbsCount; Index++) {
+    if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
+        (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
+        ) {
+      continue;
+    }
+
+    switch (LocalBbsTable[Index].DeviceType) {
+    case BBS_FLOPPY:
+      FDCount++;
+      break;
+
+    case BBS_HARDDISK:
+      HDCount++;
+      break;
+
+    case BBS_CDROM:
+      CDCount++;
+      break;
+
+    case BBS_EMBED_NETWORK:
+      NETCount++;
+      break;
+
+    case BBS_BEV_DEVICE:
+      BEVCount++;
+      break;
+
+    default:
+      break;
+    }
+  }
+
+  TotalSize += (HeaderSize + FDCount * sizeof (UINT16));
+  TotalSize += (HeaderSize + HDCount * sizeof (UINT16));
+  TotalSize += (HeaderSize + CDCount * sizeof (UINT16));
+  TotalSize += (HeaderSize + NETCount * sizeof (UINT16));
+  TotalSize += (HeaderSize + BEVCount * sizeof (UINT16));
+
+  NewDevOrder = AllocateZeroPool (TotalSize);
+  if (NULL == NewDevOrder) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+
+
+  //
+  // copy FD
+  //
+  Ptr             = DevOrder;
+  NewPtr          = NewDevOrder;
+  NewPtr->BbsType = Ptr->BbsType;
+  NewPtr->Length  = (UINT16) (sizeof (UINT16) + FDCount * sizeof (UINT16));
+  for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
+    if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_FLOPPY
+        ) {
+      continue;
+    }
+
+    NewPtr->Data[FDIndex] = Ptr->Data[Index];
+    FDIndex++;
+  }
+  NewFDPtr = NewPtr->Data;
+
+  //
+  // copy HD
+  //
+  Ptr             = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
+  NewPtr          = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
+  NewPtr->BbsType = Ptr->BbsType;
+  NewPtr->Length  = (UINT16) (sizeof (UINT16) + HDCount * sizeof (UINT16));
+  for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
+    if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_HARDDISK
+        ) {
+      continue;
+    }
+
+    NewPtr->Data[HDIndex] = Ptr->Data[Index];
+    HDIndex++;
+  }
+  NewHDPtr = NewPtr->Data;
+
+  //
+  // copy CD
+  //
+  Ptr    = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
+  NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
+  NewPtr->BbsType = Ptr->BbsType;
+  NewPtr->Length  = (UINT16) (sizeof (UINT16) + CDCount * sizeof (UINT16));
+  for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
+    if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_CDROM
+        ) {
+      continue;
+    }
+
+    NewPtr->Data[CDIndex] = Ptr->Data[Index];
+    CDIndex++;
+  }
+  NewCDPtr = NewPtr->Data;
+
+  //
+  // copy NET
+  //
+  Ptr    = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
+  NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
+  NewPtr->BbsType = Ptr->BbsType;
+  NewPtr->Length  = (UINT16) (sizeof (UINT16) + NETCount * sizeof (UINT16));
+  for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
+    if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_EMBED_NETWORK
+        ) {
+      continue;
+    }
+
+    NewPtr->Data[NETIndex] = Ptr->Data[Index];
+    NETIndex++;
+  }
+  NewNETPtr = NewPtr->Data;
+  
+  //
+  // copy BEV
+  //
+  Ptr    = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
+  NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
+  NewPtr->BbsType = Ptr->BbsType;
+  NewPtr->Length  = (UINT16) (sizeof (UINT16) + BEVCount * sizeof (UINT16));
+  for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
+    if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
+        LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_BEV_DEVICE
+        ) {
+      continue;
+    }
+
+    NewPtr->Data[BEVIndex] = Ptr->Data[Index];
+    BEVIndex++;
+  }
+  NewBEVPtr = NewPtr->Data;
+
+  for (Index = 0; Index < BbsCount; Index++) {
+    if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
+        (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
+        ) {
+      continue;
+    }
+
+    switch (LocalBbsTable[Index].DeviceType) {
+    case BBS_FLOPPY:
+      Idx       = &FDIndex;
+      NewDevPtr = NewFDPtr;
+      break;
+
+    case BBS_HARDDISK:
+      Idx       = &HDIndex;
+      NewDevPtr = NewHDPtr;
+      break;
+
+    case BBS_CDROM:
+      Idx       = &CDIndex;
+      NewDevPtr = NewCDPtr;
+      break;
+
+    case BBS_EMBED_NETWORK:
+      Idx       = &NETIndex;
+      NewDevPtr = NewNETPtr;
+      break;
+
+    case BBS_BEV_DEVICE:
+      Idx       = &BEVIndex;
+      NewDevPtr = NewBEVPtr;
+      break;
+
+    default:
+      Idx = NULL;
+      break;
+    }
+    //
+    // at this point we have copied those valid indexes to new buffer
+    // and we should check if there is any new appeared boot device
+    //
+    if (Idx != NULL) {
+      for (Index2 = 0; Index2 < *Idx; Index2++) {
+        if ((NewDevPtr[Index2] & 0xFF) == (UINT16) Index) {
+          break;
+        }
+      }
+
+      if (Index2 == *Idx) {
+        //
+        // Index2 == *Idx means we didn't find Index
+        // so Index is a new appeared device's index in BBS table
+        // insert it before disabled indexes.
+        //
+        for (Index2 = 0; Index2 < *Idx; Index2++) {
+          if ((NewDevPtr[Index2] & 0xFF00) == 0xFF00) {
+            break;
+          }
+        }
+        CopyMem (&NewDevPtr[Index2 + 1], &NewDevPtr[Index2], (*Idx - Index2) * sizeof (UINT16));
+        NewDevPtr[Index2] = (UINT16) (Index & 0xFF);
+        (*Idx)++;
+      }
+    }
+  }
+
+  FreePool (DevOrder);
+
+  Status = gRT->SetVariable (
+                  VAR_LEGACY_DEV_ORDER,
+                  &gEfiLegacyDevOrderVariableGuid,
+                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                  TotalSize,
+                  NewDevOrder
+                  );
+  FreePool (NewDevOrder);
+
+  return Status;
+}
+
+/**
+  Set Boot Priority for specified device type.
+
+  @param DeviceType      The device type.
+  @param BbsIndex        The BBS index to set the highest priority. Ignore when -1.
+  @param LocalBbsTable   The BBS table.
+  @param Priority        The prority table.
+
+  @retval EFI_SUCCESS           The function completes successfully.
+  @retval EFI_NOT_FOUND         Failed to find device.
+  @retval EFI_OUT_OF_RESOURCES  Failed to get the efi variable of device order.
+
+**/
+EFI_STATUS
+BdsSetBootPriority4SameTypeDev (
+  IN UINT16                                              DeviceType,
+  IN UINTN                                               BbsIndex,
+  IN OUT BBS_TABLE                                       *LocalBbsTable,
+  IN OUT UINT16                                          *Priority
+  )
+{
+  LEGACY_DEV_ORDER_ENTRY      *DevOrder;
+  LEGACY_DEV_ORDER_ENTRY      *DevOrderPtr;
+  UINTN                       DevOrderSize;
+  UINTN                       Index;
+
+  DevOrder = BdsLibGetVariableAndSize (
+               VAR_LEGACY_DEV_ORDER,
+               &gEfiLegacyDevOrderVariableGuid,
+               &DevOrderSize
+               );
+  if (NULL == DevOrder) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  DevOrderPtr = DevOrder;
+  while ((UINT8 *) DevOrderPtr < (UINT8 *) DevOrder + DevOrderSize) {
+    if (DevOrderPtr->BbsType == DeviceType) {
+      break;
+    }
+
+    DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) ((UINTN) DevOrderPtr + sizeof (BBS_TYPE) + DevOrderPtr->Length);
+  }
+
+  if ((UINT8 *) DevOrderPtr >= (UINT8 *) DevOrder + DevOrderSize) {
+    FreePool (DevOrder);
+    return EFI_NOT_FOUND;
+  }
+
+  if (BbsIndex != (UINTN) -1) {
+    LocalBbsTable[BbsIndex].BootPriority = *Priority;
+    (*Priority)++;
+  }
+  //
+  // If the high byte of the DevIndex is 0xFF, it indicates that this device has been disabled.
+  //
+  for (Index = 0; Index < DevOrderPtr->Length / sizeof (UINT16) - 1; Index++) {
+    if ((DevOrderPtr->Data[Index] & 0xFF00) == 0xFF00) {
+      //
+      // LocalBbsTable[DevIndex[Index] & 0xFF].BootPriority = BBS_DISABLED_ENTRY;
+      //
+    } else if (DevOrderPtr->Data[Index] != BbsIndex) {
+      LocalBbsTable[DevOrderPtr->Data[Index]].BootPriority = *Priority;
+      (*Priority)++;
+    }
+  }
+
+  FreePool (DevOrder);
+  return EFI_SUCCESS;
+}
+
+/**
+  Print the BBS Table.
+
+  @param LocalBbsTable   The BBS table.
+  @param BbsCount        The count of entry in BBS table.
+**/
+VOID
+PrintBbsTable (
+  IN BBS_TABLE  *LocalBbsTable,
+  IN UINT16     BbsCount
+  )
+{
+  UINT16  Idx;
+
+  DEBUG ((DEBUG_ERROR, "\n"));
+  DEBUG ((DEBUG_ERROR, " NO  Prio bb/dd/ff cl/sc Type Stat segm:offs\n"));
+  DEBUG ((DEBUG_ERROR, "=============================================\n"));
+  for (Idx = 0; Idx < BbsCount; Idx++) {
+    if ((LocalBbsTable[Idx].BootPriority == BBS_IGNORE_ENTRY) ||
+        (LocalBbsTable[Idx].BootPriority == BBS_DO_NOT_BOOT_FROM) ||
+        (LocalBbsTable[Idx].BootPriority == BBS_LOWEST_PRIORITY)
+        ) {
+      continue;
+    }
+
+    DEBUG (
+      (DEBUG_ERROR,
+      " %02x: %04x %02x/%02x/%02x %02x/%02x %04x %04x %04x:%04x\n",
+      (UINTN) Idx,
+      (UINTN) LocalBbsTable[Idx].BootPriority,
+      (UINTN) LocalBbsTable[Idx].Bus,
+      (UINTN) LocalBbsTable[Idx].Device,
+      (UINTN) LocalBbsTable[Idx].Function,
+      (UINTN) LocalBbsTable[Idx].Class,
+      (UINTN) LocalBbsTable[Idx].SubClass,
+      (UINTN) LocalBbsTable[Idx].DeviceType,
+      (UINTN) * (UINT16 *) &LocalBbsTable[Idx].StatusFlags,
+      (UINTN) LocalBbsTable[Idx].BootHandlerSegment,
+      (UINTN) LocalBbsTable[Idx].BootHandlerOffset,
+      (UINTN) ((LocalBbsTable[Idx].MfgStringSegment << 4) + LocalBbsTable[Idx].MfgStringOffset),
+      (UINTN) ((LocalBbsTable[Idx].DescStringSegment << 4) + LocalBbsTable[Idx].DescStringOffset))
+      );
+  }
+
+  DEBUG ((DEBUG_ERROR, "\n"));
+}
+
+/**
+  Set the boot priority for BBS entries based on boot option entry and boot order.
+
+  @param  Entry             The boot option is to be checked for refresh BBS table.
+  
+  @retval EFI_SUCCESS           The boot priority for BBS entries is refreshed successfully.
+  @retval EFI_NOT_FOUND         BBS entries can't be found.
+  @retval EFI_OUT_OF_RESOURCES  Failed to get the legacy device boot order.
+**/
+EFI_STATUS
+EFIAPI
+BdsRefreshBbsTableForBoot (
+  IN BDS_COMMON_OPTION        *Entry
+  )
+{
+  EFI_STATUS                Status;
+  UINT16                    BbsIndex;
+  UINT16                    HddCount;
+  UINT16                    BbsCount;
+  HDD_INFO                  *LocalHddInfo;
+  BBS_TABLE                 *LocalBbsTable;
+  UINT16                    DevType;
+  EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
+  UINTN                     Index;
+  UINT16                    Priority;
+  UINT16                    *BootOrder;
+  UINTN                     BootOrderSize;
+  UINT8                     *BootOptionVar;
+  UINTN                     BootOptionSize;
+  CHAR16                    BootOption[9];
+  UINT8                     *Ptr;
+  UINT16                    DevPathLen;
+  EFI_DEVICE_PATH_PROTOCOL  *DevPath;
+  UINT16                    *DeviceType;
+  UINTN                     DeviceTypeCount;
+  UINTN                     DeviceTypeIndex;
+
+  HddCount      = 0;
+  BbsCount      = 0;
+  LocalHddInfo  = NULL;
+  LocalBbsTable = NULL;
+  DevType       = BBS_UNKNOWN;
+
+  Status        = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  LegacyBios->GetBbsInfo (
+                LegacyBios,
+                &HddCount,
+                &LocalHddInfo,
+                &BbsCount,
+                &LocalBbsTable
+                );
+  //
+  // First, set all the present devices' boot priority to BBS_UNPRIORITIZED_ENTRY
+  // We will set them according to the settings setup by user
+  //
+  for (Index = 0; Index < BbsCount; Index++) {
+    if (!((BBS_IGNORE_ENTRY == LocalBbsTable[Index].BootPriority) ||
+        (BBS_DO_NOT_BOOT_FROM == LocalBbsTable[Index].BootPriority) ||
+         (BBS_LOWEST_PRIORITY == LocalBbsTable[Index].BootPriority))) {
+      LocalBbsTable[Index].BootPriority = BBS_UNPRIORITIZED_ENTRY;
+    }
+  }
+  //
+  // boot priority always starts at 0
+  //
+  Priority = 0;
+  if (Entry->LoadOptionsSize == sizeof (BBS_TABLE) + sizeof (UINT16)) {
+    //
+    // If Entry stands for a legacy boot option, we prioritize the devices with the same type first.
+    //
+    DevType  = ((BBS_TABLE *) Entry->LoadOptions)->DeviceType;
+    BbsIndex = *(UINT16 *) ((BBS_TABLE *) Entry->LoadOptions + 1);
+    Status = BdsSetBootPriority4SameTypeDev (
+              DevType,
+              BbsIndex,
+              LocalBbsTable,
+              &Priority
+              );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  //
+  // we have to set the boot priority for other BBS entries with different device types
+  //
+  BootOrder = BdsLibGetVariableAndSize (
+                L"BootOrder",
+                &gEfiGlobalVariableGuid,
+                &BootOrderSize
+                );
+  DeviceType = AllocatePool (BootOrderSize + sizeof (UINT16));
+  ASSERT (DeviceType != NULL);
+
+  DeviceType[0]   = DevType;
+  DeviceTypeCount = 1;
+  for (Index = 0; ((BootOrder != NULL) && (Index < BootOrderSize / sizeof (UINT16))); Index++) {
+    UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
+    BootOptionVar = BdsLibGetVariableAndSize (
+                      BootOption,
+                      &gEfiGlobalVariableGuid,
+                      &BootOptionSize
+                      );
+    if (NULL == BootOptionVar) {
+      continue;
+    }
+
+    Ptr = BootOptionVar;
+
+    Ptr += sizeof (UINT32);
+    DevPathLen = *(UINT16 *) Ptr;
+    Ptr += sizeof (UINT16);
+    Ptr += StrSize ((UINT16 *) Ptr);
+    DevPath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
+    if (BBS_DEVICE_PATH != DevPath->Type || BBS_BBS_DP != DevPath->SubType) {
+      FreePool (BootOptionVar);
+      continue;
+    }
+
+    Ptr += DevPathLen;
+    DevType = ((BBS_TABLE *) Ptr)->DeviceType;
+    for (DeviceTypeIndex = 0; DeviceTypeIndex < DeviceTypeCount; DeviceTypeIndex++) {
+      if (DeviceType[DeviceTypeIndex] == DevType) {
+        break;
+      }
+    }
+    if (DeviceTypeIndex < DeviceTypeCount) {
+      //
+      // We don't want to process twice for a device type
+      //
+      FreePool (BootOptionVar);
+      continue;
+    }
+
+    DeviceType[DeviceTypeCount] = DevType;
+    DeviceTypeCount++;
+
+    Status = BdsSetBootPriority4SameTypeDev (
+              DevType,
+              (UINTN) -1,
+              LocalBbsTable,
+              &Priority
+              );
+    FreePool (BootOptionVar);
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+  }
+
+  FreePool (DeviceType);
+
+  if (BootOrder != NULL) {
+    FreePool (BootOrder);
+  }
+
+  DEBUG_CODE_BEGIN();
+    PrintBbsTable (LocalBbsTable, BbsCount);
+  DEBUG_CODE_END();
+
+  return Status;
+}
 
 /**
@@ -78 +1681 @@
   EFI_STATUS                Status;
   EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
+  EFI_EVENT                 LegacyBootEvent;
 
   Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
@@ -95 +1699 @@
   //
   PERF_CODE (
-    WriteBootToOsPerformanceData ();
+    //
+    // Create an event to be signalled when Legacy Boot occurs to write performance data.
+    //
+    Status = EfiCreateEventLegacyBootEx(
+               TPL_NOTIFY,
+               WriteBootToOsPerformanceData,
+               NULL, 
+               &LegacyBootEvent
+               );
+    ASSERT_EFI_ERROR (Status);
   );
 
@@ -658 +2271 @@
   EFI_BOOT_LOGO_PROTOCOL    *BootLogo;
 
-  //
-  // Record the performance data for End of BDS
-  //
-  PERF_END(NULL, "BDS", NULL, 0);
-
+#ifdef VBOX
   VBoxLog(("BdsLibBootViaBootOption: BootCurrent=0x%x OptionName=%s Description=%s StatusString=%s Attribute=0x%x LoadOptionsSize=0x%x\n",
            Option->BootCurrent, Option->OptionName, Option->Description, Option->StatusString, Option->Attribute, Option->LoadOptionsSize));
+#endif
 
   *ExitDataSize = 0;
@@ -702 +2312 @@
     // Only create the BootCurrent variable when it points to a valid Boot#### variable.
     //
-    gRT->SetVariable (
+    SetVariableAndReportStatusCodeOnError (
           L"BootCurrent",
           &gEfiGlobalVariableGuid,
@@ -710 +2320 @@
           );
   }
+
+  //
+  // Report Status Code to indicate ReadyToBoot event will be signalled
+  //
+  REPORT_STATUS_CODE (EFI_PROGRESS_CODE, (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_PC_READY_TO_BOOT_EVENT));
 
   //
@@ -803 +2418 @@
       Handle = BdsLibGetBootableHandle(DevicePath);
       VBoxLogFlowFuncMarkVar(Handle, "%p");
-      if (Handle == NULL) {
-        goto Done;
-      }
+      if (Handle != NULL) {
 #ifdef VBOX /* We have more options to try out because of apple. */
       //
@@ -813 +2426 @@
       if (Option->LoadOptionsSize) {
         /*
-         * First, see the there is a config=folder in the load options.  We
-         * interpret it as a path to the folder containing boot.efi and go
-         * about constructing the path in a bit of a round about way...
-         *
-         * This is what we got when Lion rebooted after the first installation stage:
-         *   Variable - fAttr=0x07 - '8be4df61-93ca-11d2-aa0d-00e098032b8c:Boot0080' - cb=0xbe
-         *   0000: 01 00 00 00 48 00 4d 00-61 00 63 00 20 00 4f 00 ....H.M.a.c. .O.
-         *   0010: 53 00 20 00 58 00 00 00-02 01 0c 00 d0 41 03 0a S. .X........A..
-         *   0020: 00 00 00 00 01 01 06 00-02 1f 03 01 08 00 00 01 ................
-         *   0030: 00 00 04 01 2a 00 02 00-00 00 28 40 06 00 00 00 ....*.....(@....
-         *   0040: 00 00 b0 bf 75 02 00 00-00 00 e5 b2 19 a7 cb 59 ....u..........Y
-         *   0050: 69 4c b9 92 51 3c fd 4b-d7 c4 02 02 7f ff 04 00 iL..Q<.K........
-         *   0060: 63 00 6f 00 6e 00 66 00-69 00 67 00 3d 00 22 00 c.o.n.f.i.g.=.".
-         *   0070: 5c 00 4d 00 61 00 63 00-20 00 4f 00 53 00 20 00 \.M.a.c. .O.S. .
-         *   0080: 58 00 20 00 49 00 6e 00-73 00 74 00 61 00 6c 00 X. .I.n.s.t.a.l.
-         *   0090: 6c 00 20 00 44 00 61 00-74 00 61 00 5c 00 63 00 l. .D.a.t.a.\.c.
-         *   00a0: 6f 00 6d 00 2e 00 61 00-70 00 70 00 6c 00 65 00 o.m...a.p.p.l.e.
-         *   00b0: 2e 00 42 00 6f 00 6f 00-74 00 22 00 00 00       ..B.o.o.t."...
-         *
-         * This is waht we got when Moutain Kitten reboot after the first installation stage:
-         * Variable - fAttr=0x07 - '8be4df61-93ca-11d2-aa0d-00e098032b8c:Boot0080' - cb=0xb6
-         *   0000: 01 00 00 00 48 00 4d 00-61 00 63 00 20 00 4f 00 ....H.M.a.c. .O.
-         *   0010: 53 00 20 00 58 00 00 00-02 01 0c 00 d0 41 03 0a S. .X........A..
-         *   0020: 00 00 00 00 01 01 06 00-02 1f 03 01 08 00 00 01 ................
-         *   0030: 00 00 04 01 2a 00 02 00-00 00 28 40 06 00 00 00 ....*.....(@....
-         *   0040: 00 00 98 b5 53 02 00 00-00 00 a5 9a 97 b7 33 60 ....S.........3`
-         *   0050: 2d 47 bf 1a fa 14 fe c5-f2 b8 02 02 7f ff 04 00 -G..............
-         *   0060: 63 00 6f 00 6e 00 66 00-69 00 67 00 3d 00 22 00 c.o.n.f.i.g.=.".
-         *   0070: 5c 00 4f 00 53 00 20 00-58 00 20 00 49 00 6e 00 \.O.S. .X. .I.n.
-         *   0080: 73 00 74 00 61 00 6c 00-6c 00 20 00 44 00 61 00 s.t.a.l.l. .D.a.
-         *   0090: 74 00 61 00 5c 00 63 00-6f 00 6d 00 2e 00 61 00 t.a.\.c.o.m...a.
-         *   00a0: 70 00 70 00 6c 00 65 00-2e 00 42 00 6f 00 6f 00 p.p.l.e...B.o.o.
-         *   00b0: 74 00 22 00 00 00                               t."...
-         */
-        VBoxLogFlowFuncMarkVar(Option->LoadOptions, "%s");
+           * First, see the there is a config=folder in the load options.  We
+           * interpret it as a path to the folder containing boot.efi and go
+           * about constructing the path in a bit of a round about way...
+           *
+           * This is what we got when Lion rebooted after the first installation stage:
+           *   Variable - fAttr=0x07 - '8be4df61-93ca-11d2-aa0d-00e098032b8c:Boot0080' - cb=0xbe
+           *   0000: 01 00 00 00 48 00 4d 00-61 00 63 00 20 00 4f 00 ....H.M.a.c. .O.
+           *   0010: 53 00 20 00 58 00 00 00-02 01 0c 00 d0 41 03 0a S. .X........A..
+           *   0020: 00 00 00 00 01 01 06 00-02 1f 03 01 08 00 00 01 ................
+           *   0030: 00 00 04 01 2a 00 02 00-00 00 28 40 06 00 00 00 ....*.....(@....
+           *   0040: 00 00 b0 bf 75 02 00 00-00 00 e5 b2 19 a7 cb 59 ....u..........Y
+           *   0050: 69 4c b9 92 51 3c fd 4b-d7 c4 02 02 7f ff 04 00 iL..Q<.K........
+           *   0060: 63 00 6f 00 6e 00 66 00-69 00 67 00 3d 00 22 00 c.o.n.f.i.g.=.".
+           *   0070: 5c 00 4d 00 61 00 63 00-20 00 4f 00 53 00 20 00 \.M.a.c. .O.S. .
+           *   0080: 58 00 20 00 49 00 6e 00-73 00 74 00 61 00 6c 00 X. .I.n.s.t.a.l.
+           *   0090: 6c 00 20 00 44 00 61 00-74 00 61 00 5c 00 63 00 l. .D.a.t.a.\.c.
+           *   00a0: 6f 00 6d 00 2e 00 61 00-70 00 70 00 6c 00 65 00 o.m...a.p.p.l.e.
+           *   00b0: 2e 00 42 00 6f 00 6f 00-74 00 22 00 00 00       ..B.o.o.t."...
+           *
+           * This is waht we got when Moutain Kitten reboot after the first installation stage:
+           * Variable - fAttr=0x07 - '8be4df61-93ca-11d2-aa0d-00e098032b8c:Boot0080' - cb=0xb6
+           *   0000: 01 00 00 00 48 00 4d 00-61 00 63 00 20 00 4f 00 ....H.M.a.c. .O.
+           *   0010: 53 00 20 00 58 00 00 00-02 01 0c 00 d0 41 03 0a S. .X........A..
+           *   0020: 00 00 00 00 01 01 06 00-02 1f 03 01 08 00 00 01 ................
+           *   0030: 00 00 04 01 2a 00 02 00-00 00 28 40 06 00 00 00 ....*.....(@....
+           *   0040: 00 00 98 b5 53 02 00 00-00 00 a5 9a 97 b7 33 60 ....S.........3`
+           *   0050: 2d 47 bf 1a fa 14 fe c5-f2 b8 02 02 7f ff 04 00 -G..............
+           *   0060: 63 00 6f 00 6e 00 66 00-69 00 67 00 3d 00 22 00 c.o.n.f.i.g.=.".
+           *   0070: 5c 00 4f 00 53 00 20 00-58 00 20 00 49 00 6e 00 \.O.S. .X. .I.n.
+           *   0080: 73 00 74 00 61 00 6c 00-6c 00 20 00 44 00 61 00 s.t.a.l.l. .D.a.
+           *   0090: 74 00 61 00 5c 00 63 00-6f 00 6d 00 2e 00 61 00 t.a.\.c.o.m...a.
+           *   00a0: 70 00 70 00 6c 00 65 00-2e 00 42 00 6f 00 6f 00 p.p.l.e...B.o.o.
+           *   00b0: 74 00 22 00 00 00                               t."...
+           */
+          VBoxLogFlowFuncMarkVar(Option->LoadOptions, "%s");
         if (StrnCmp(L"config=", (CHAR16 *)Option->LoadOptions, 7) == 0) {
           EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *Volume;
@@ -911 +2524 @@
       }
 #else  /* !VBOX */
-      //
-      // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
-      //  machinename is ia32, ia64, x64, ...
-      //
-      FilePath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
-      if (FilePath != NULL) {
-        REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
-        Status = gBS->LoadImage (
-                        TRUE,
-                        gImageHandle,
-                        FilePath,
-                        NULL,
-                        0,
-                        &ImageHandle
-                        );
-       if (EFI_ERROR (Status)) {
-          //
-          // The DevicePath failed, and it's not a valid
-          // removable media device.
-          //
-          goto Done;
+        //
+        // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
+        //  machinename is ia32, ia64, x64, ...
+        //
+        FilePath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
+        if (FilePath != NULL) {
+          REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
+          Status = gBS->LoadImage (
+                          TRUE,
+                          gImageHandle,
+                          FilePath,
+                          NULL,
+                          0,
+                          &ImageHandle
+                          );
         }
-      }
 #endif /* !VBOX */
     }
-
-    if (EFI_ERROR (Status)) {
-      //
-      // It there is any error from the Boot attempt exit now.
-      //
-      goto Done;
-    }
+  }
   }
   //
   // Provide the image with it's load options
   //
-  if (ImageHandle == NULL) {
+  if ((ImageHandle == NULL) || (EFI_ERROR(Status))) {
+    //
+    // Report Status Code to indicate that the failure to load boot option
+    //
+    REPORT_STATUS_CODE (
+      EFI_ERROR_CODE | EFI_ERROR_MINOR,
+      (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_LOAD_ERROR)
+      );    
     goto Done;
   }
+
   Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo);
   ASSERT_EFI_ERROR (Status);
@@ -957 +2565 @@
     ImageInfo->LoadOptions      = Option->LoadOptions;
   }
+
+  //
+  // Clean to NULL because the image is loaded directly from the firmwares boot manager.
+  //
+  ImageInfo->ParentHandle = NULL;
+
   //
   // Before calling the image, enable the Watchdog Timer for
@@ -967 +2581 @@
   //
   PERF_CODE (
-    WriteBootToOsPerformanceData ();
+    WriteBootToOsPerformanceData (NULL, NULL);
   );
 
@@ -977 +2591 @@
   Status = gBS->StartImage (ImageHandle, ExitDataSize, ExitData);
   DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Image Return Status = %r\n", Status));
+  if (EFI_ERROR (Status)) {
+    //
+    // Report Status Code to indicate that boot failure
+    //
+    REPORT_STATUS_CODE (
+      EFI_ERROR_CODE | EFI_ERROR_MINOR,
+      (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_FAILED)
+      );
+  }
 
   //
@@ -995 +2618 @@
   //
   // Clear Boot Current
+  // Deleting variable with current implementation shouldn't fail.
   //
   gRT->SetVariable (
@@ -1001 +2625 @@
         EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
         0,
-        &Option->BootCurrent
+        NULL
         );
 
@@ -1050 +2674 @@
   // If fail to find or HD_BOOT_DEVICE_PATH_VARIABLE_NAME not exist, reconnect all and search in all system
   //
-  CachedDevicePath = BdsLibGetVariableAndSize (
-                      HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
-                      &gHdBootDevicePathVariablGuid,
-                      &CachedDevicePathSize
-                      );
+  GetVariable2 (
+    HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
+    &gHdBootDevicePathVariablGuid,
+    (VOID **) &CachedDevicePath,
+    &CachedDevicePathSize
+    );
+
+  //
+  // Delete the invalid HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable.
+  //
+  if ((CachedDevicePath != NULL) && !IsDevicePathValid (CachedDevicePath, CachedDevicePathSize)) {
+    FreePool (CachedDevicePath);
+    CachedDevicePath = NULL;
+    Status = gRT->SetVariable (
+                    HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
+                    &gHdBootDevicePathVariablGuid,
+                    0,
+                    0,
+                    NULL
+                    );
+    ASSERT_EFI_ERROR (Status);
+  }
 
   if (CachedDevicePath != NULL) {
@@ -1112 +2753 @@
         //
         // Save the matching Device Path so we don't need to do a connect all next time
+        // Failure to set the variable only impacts the performance when next time expanding the short-form device path.
         //
         Status = gRT->SetVariable (
                         HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
                         &gHdBootDevicePathVariablGuid,
-                        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
                         GetDevicePathSize (CachedDevicePath),
                         CachedDevicePath
@@ -1169 +2811 @@
           CachedDevicePath = BdsLibDelPartMatchInstance (CachedDevicePath, BlockIoDevicePath);
           FreePool(TempNewDevicePath);
-
-          TempNewDevicePath = CachedDevicePath;
-          CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);
-          if (TempNewDevicePath != NULL) {
-            FreePool(TempNewDevicePath);
-          }
-        } else {
+        }
+
+        if (CachedDevicePath != NULL) {
           TempNewDevicePath = CachedDevicePath;
           CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);
           FreePool(TempNewDevicePath);
+        } else {
+          CachedDevicePath = DuplicateDevicePath (BlockIoDevicePath);
         }
+
         //
         // Here limit the device path instance number to 12, which is max number for a system support 3 IDE controller
@@ -1211 +2852 @@
       //
       // Save the matching Device Path so we don't need to do a connect all next time
+      // Failure to set the variable only impacts the performance when next time expanding the short-form device path.
       //
       Status = gRT->SetVariable (
                       HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
                       &gHdBootDevicePathVariablGuid,
-                      EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                      EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
                       GetDevicePathSize (CachedDevicePath),
                       CachedDevicePath
@@ -1420 +3062 @@
                   BootOrder
                   );
+  //
+  // Shrinking variable with existing variable implementation shouldn't fail.
+  //
+  ASSERT_EFI_ERROR (Status);
 
   FreePool (BootOrder);
@@ -1524 +3170 @@
                       );
       //
+      // Deleting variable with current variable implementation shouldn't fail.
+      //
+      ASSERT_EFI_ERROR (Status);
+      //
       // Mark this boot option in boot order as deleted
       //
@@ -1554 +3204 @@
                   );
   VBoxLogFlowFuncMarkRC(Status);
+  //
+  // Shrinking variable with current variable implementation shouldn't fail.
+  //
+  ASSERT_EFI_ERROR (Status);
+
   FreePool (BootOrder);
 
@@ -1662 +3317 @@
   //
   if (mEnumBootDevice) {
-    LastLang = GetVariable (LAST_ENUM_LANGUAGE_VARIABLE_NAME, &gLastEnumLangGuid);
-    PlatLang = GetEfiGlobalVariable (L"PlatformLang");
+    GetVariable2 (LAST_ENUM_LANGUAGE_VARIABLE_NAME, &gLastEnumLangGuid, (VOID**)&LastLang, NULL);
+    GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatLang, NULL);
     ASSERT (PlatLang != NULL);
     if ((LastLang != NULL) && (AsciiStrCmp (LastLang, PlatLang) == 0)) {
@@ -1679 +3334 @@
         PlatLang
         );
-      ASSERT_EFI_ERROR (Status);
+      //
+      // Failure to set the variable only impacts the performance next time enumerating the boot options.
+      //
 
       if (LastLang != NULL) {
@@ -1724 +3381 @@
                       );
       //
-      // skip the fixed block io then the removable block io
-      //
-      if (EFI_ERROR (Status) || (BlkIo->Media->RemovableMedia == Removable[RemovableIndex])) {
+      // skip the logical partition
+      //
+      if (EFI_ERROR (Status) || BlkIo->Media->LogicalPartition) {
+        continue;
+      }
+
+      //
+      // firstly fixed block io then the removable block io
+      //
+      if (BlkIo->Media->RemovableMedia == Removable[RemovableIndex]) {
         continue;
       }
@@ -1788 +3452 @@
 
       case BDS_EFI_MESSAGE_MISC_BOOT:
+      default:
         if (MiscNumber != 0) {
           UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC)), MiscNumber);
@@ -1795 +3460 @@
         BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
         MiscNumber++;
-        break;
-
-      default:
         break;
       }
@@ -2040 +3702 @@
   )
 {
+  EFI_STATUS        Status;
   UINT16            *BootNext;
   UINTN             BootNextSize;
@@ -2064 +3727 @@
   //
   if (BootNext != NULL) {
-    gRT->SetVariable (
-          L"BootNext",
-          &gEfiGlobalVariableGuid,
-          EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
-          0,
-          BootNext
-          );
+    Status = gRT->SetVariable (
+                    L"BootNext",
+                    &gEfiGlobalVariableGuid,
+                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+                    0,
+                    NULL
+                    );
+    //
+    // Deleting variable with current variable implementation shouldn't fail.
+    //
+    ASSERT_EFI_ERROR (Status);
 
     //
@@ -2080 +3747 @@
     BdsLibConnectDevicePath (BootOption->DevicePath);
     BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);
+    FreePool(BootOption);
+    FreePool(BootNext);
   }
 
@@ -2976 +4645 @@
     EfiInitializeFwVolDevicepathNode (&FvFileNode, FileGuid);
     NewDevicePath = AppendDevicePathNode (NewDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &FvFileNode);
+    ASSERT (NewDevicePath != NULL);
     *DevicePath = NewDevicePath;
     return EFI_SUCCESS;

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c

@@ -2 +2 @@
   BDS Lib functions which relate with connect the device
 
-Copyright (c) 2004 - 2008, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -66 +66 @@
 }
 
-
 /**
   This function will create all handles associate with every device
   path node. If the handle associate with one device path node can not
-  be created success, then still give one chance to do the dispatch,
+  be created successfully, then still give chance to do the dispatch,
   which load the missing drivers if possible.
 
@@ -98 +97 @@
   EFI_HANDLE                PreviousHandle;
   UINTN                     Size;
+  EFI_TPL                   CurrentTpl;
 
   if (DevicePathToConnect == NULL) {
     return EFI_SUCCESS;
   }
+
+  CurrentTpl  = EfiGetCurrentTpl ();
 
   DevicePath        = DuplicateDevicePath (DevicePathToConnect);
@@ -151 +153 @@
           // Status == EFI_NOT_FOUND means no new drivers were dispatched
           //
-          Status = gDS->Dispatch ();
+          if (CurrentTpl == TPL_APPLICATION) {
+            //
+            // Dispatch calls LoadImage/StartImage which cannot run at TPL > TPL_APPLICATION
+            //
+            Status = gDS->Dispatch ();
+          } else {
+            //
+            // Always return EFI_NOT_FOUND here
+            // to prevent dead loop when control handle is found but connection failded case
+            //
+            Status = EFI_NOT_FOUND;
+          }
         }
 
@@ -189 +202 @@
   return Status;
 }
-
 
 /**
@@ -411 +423 @@
     }
 
+    if (HandleArray != NULL) {
+      FreePool (HandleArray);
+    }
+
     if (AtLeastOneConnected) {
       return EFI_SUCCESS;

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c

@@ -2 +2 @@
   BDS Lib functions which contain all the code to connect console device
 
-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -66 +66 @@
   @param  ConsoleGuid        Specified Console protocol GUID.
   @param  ConsoleHandle      On IN,  console handle in System Table to be checked.
-                             On OUT, new console hanlde in system table.
+                             On OUT, new console handle in system table.
   @param  ProtocolInterface  On IN,  console protocol on console handle in System Table to be checked.
-                             On OUT, new console protocol on new console hanlde in system table.
+                             On OUT, new console protocol on new console handle in system table.
 
   @retval TRUE               System Table has been updated.
@@ -89 +89 @@
   VOID                      *Interface;
   EFI_HANDLE                NewHandle;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;
 
   ASSERT (VarName != NULL);
@@ -160 +161 @@
         *ConsoleHandle     = NewHandle;
         *ProtocolInterface = Interface;
+        if (CompareGuid (ConsoleGuid, &gEfiSimpleTextOutProtocolGuid)) {
+          //
+          // If it is console out device, set console mode 80x25 if current mode is invalid.
+          //
+          TextOut = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *) Interface;
+          if (TextOut->Mode->Mode == -1) {
+            TextOut->SetMode (TextOut, 0);
+          }
+        }
         return TRUE;
       }
@@ -294 +304 @@
   DevicePathSize = GetDevicePathSize (NewDevicePath);
   VBoxLogFlowFuncMark();
-  Status = gRT->SetVariable (
-                  ConVarName,
-                  &gEfiGlobalVariableGuid,
-                  Attributes,
-                  DevicePathSize,
-                  NewDevicePath
-                  );
+  Status = SetVariableAndReportStatusCodeOnError (
+             ConVarName,
+             &gEfiGlobalVariableGuid,
+             Attributes,
+             DevicePathSize,
+             NewDevicePath
+             );
   VBoxLogFlowFuncMarkRC(Status);
   if ((DevicePathSize == 0) && (Status == EFI_NOT_FOUND)) {
     Status = EFI_SUCCESS;
   }
-  ASSERT_EFI_ERROR (Status);
 
   if (VarConsole == NewDevicePath) {
@@ -328 +337 @@
 /**
   Connect the console device base on the variable ConVarName, if
-  device path of the ConVarName is multi-instance device path, if
+  device path of the ConVarName is multi-instance device path and
   anyone of the instances is connected success, then this function
   will return success.
+  If the handle associate with one device path node can not
+  be created successfully, then still give chance to do the dispatch,
+  which load the missing drivers if possible..
 
   @param  ConVarName               Console related variable name, ConIn, ConOut,
@@ -407 +419 @@
       //
       Status = BdsLibConnectDevicePath (Instance);
+
       if (EFI_ERROR (Status)) {
         //
@@ -427 +440 @@
   return EFI_SUCCESS;
 }
-
 
 /**
@@ -559 +571 @@
     SystemTableUpdated = TRUE;
   }
+  if (UpdateSystemTableConsole (L"ConOut", &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **) &gST->ConOut)) {
+    SystemTableUpdated = TRUE;
+  }
+  if (UpdateSystemTableConsole (L"ErrOut", &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **) &gST->StdErr)) {
+    SystemTableUpdated = TRUE;
+  }
+
+  if (SystemTableUpdated) {
+    //
+    // Update the CRC32 in the EFI System Table header
+    //
+    gST->Hdr.CRC32 = 0;
+    gBS->CalculateCrc32 (
+          (UINT8 *) &gST->Hdr,
+          gST->Hdr.HeaderSize,
+          &gST->Hdr.CRC32
+          );
+  }
+
+  return EFI_SUCCESS;
+
+}
+
+/**
+  This function will connect console device except ConIn base on the console
+  device variable  ConOut and ErrOut.
+
+  @retval EFI_SUCCESS              At least one of the ConOut device have
+                                   been connected success.
+  @retval EFI_STATUS               Return the status of BdsLibConnectConsoleVariable ().
+
+**/
+EFI_STATUS
+EFIAPI
+BdsLibConnectAllDefaultConsolesWithOutConIn (
+  VOID
+  )
+{
+  EFI_STATUS                Status;
+  BOOLEAN                   SystemTableUpdated;
+
+  //
+  // Connect all default console variables except ConIn
+  //
+
+  //
+  // It seems impossible not to have any ConOut device on platform,
+  // so we check the status here.
+  //
+  Status = BdsLibConnectConsoleVariable (L"ConOut");
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Insert the performance probe for Console Out
+  //
+  PERF_START (NULL, "ConOut", "BDS", 1);
+  PERF_END (NULL, "ConOut", "BDS", 0);
+
+  //
+  // The _ModuleEntryPoint err out var is legal.
+  //
+  BdsLibConnectConsoleVariable (L"ErrOut");
+
+  SystemTableUpdated = FALSE;
+  //
+  // Fill console handles in System Table if no console device assignd.
+  //
   if (UpdateSystemTableConsole (L"ConOut", &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **) &gST->ConOut)) {
     SystemTableUpdated = TRUE;
@@ -690 +771 @@
         break;
       }
-    if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) != sizeof (BMP_COLOR_MAP) * ColorMapNum) {
+    //
+    // BMP file may has padding data between the bmp header section and the bmp data section.
+    //
+    if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) < sizeof (BMP_COLOR_MAP) * ColorMapNum) {
       return EFI_INVALID_PARAMETER;
     }

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsMisc.c

@@ -2 +2 @@
   Misc BDS library function
 
-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -169 +169 @@
       break;
     }
+    FreePool(OptionBuffer);
     Index++;
   } while (TRUE);
@@ -218 +219 @@
   UINTN                     OrderItemNum;
 
+  if (DevicePath == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
 
   OptionPtr             = NULL;
@@ -268 +272 @@
     //
     if (!ValidateOption(OptionPtr, OptionSize)) {
+      FreePool(OptionPtr);
       continue;
     }
@@ -465 +470 @@
   invalidate string.
 
-  This function returns the number of Unicode characters in the Null-terminated
+  This function returns the byte length of Unicode characters in the Null-terminated
   Unicode string specified by String.
 
@@ -489 +494 @@
   ASSERT (((UINTN) String & BIT0) == 0);
 
-  for (Length = 0; *String != L'\0' && MaxStringLen != Length; String++, Length++);
+  for (Length = 0; *String != L'\0' && MaxStringLen != Length; String++, Length+=2);
 
   if (*String != L'\0' && MaxStringLen == Length) {
@@ -495 +500 @@
   }
 
-  return (Length + 1) * sizeof (*String);
+  return Length + 2;
 }
 
@@ -517 +522 @@
   UINT8                     *TempPtr;
   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
-  EFI_DEVICE_PATH_PROTOCOL  *TempPath;
   UINTN                     TempSize;
 
@@ -523 +527 @@
   VBoxLogFlowFuncMarkVar(Variable, "%s");
   VBoxLogFlowFuncMarkVar(VariableSize, "%d");
+
+  if (VariableSize <= sizeof (UINT16) + sizeof (UINT32)) {
+    return FALSE;
+  }
+
   //
   // Skip the option attribute
@@ -538 +547 @@
   // Get the option's description string size
   //
-  TempSize = StrSizeEx ((CHAR16 *) TempPtr, VariableSize);
+  TempSize = StrSizeEx ((CHAR16 *) TempPtr, VariableSize - sizeof (UINT16) - sizeof (UINT32));
   TempPtr += TempSize;
 
@@ -545 +554 @@
   //
   DevicePath =  (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
-  TempPtr    += FilePathSize;
+  TempPtr   += FilePathSize;
 
   //
@@ -555 +564 @@
   }
 
-  if (TempSize + FilePathSize + sizeof (UINT16) + sizeof (UINT16) > VariableSize) {
-    VBoxLogFlowFuncLeave();
-    return FALSE;
-  }
-
-  TempPath = DevicePath;
-  while (FilePathSize > 0) {
-    TempSize = GetDevicePathSizeEx (TempPath, FilePathSize);
-    if (TempSize == 0) {
+  if (TempSize + FilePathSize + sizeof (UINT16) + sizeof (UINT32) > VariableSize) {
       VBoxLogFlowFuncLeave();
       return FALSE;
-    }
-    FilePathSize = (UINT16) (FilePathSize - TempSize);
-    TempPath    += TempSize;
-  }
-
-  VBoxLogFlowFuncLeave();
-  return TRUE;
+  }
+
+  return (BOOLEAN) (GetDevicePathSizeEx (DevicePath, FilePathSize) != 0);
 }
 
@@ -625 +622 @@
   UINTN                     VariableSize;
   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
-  EFI_DEVICE_PATH_PROTOCOL  *TempPath;
   BDS_COMMON_OPTION         *Option;
   VOID                      *LoadOptions;
@@ -631 +627 @@
   CHAR16                    *Description;
   UINT8                     NumOff;
+#ifdef VBOX
   UINTN                     TempSize;
+#endif
+
   //
   // Read the variable. We will never free this data.
@@ -654 +653 @@
     VBoxLogFlowFuncMarkVar(Variable, "%p");
     VBoxLogFlowFuncLeave();
+    FreePool (Variable);
     return NULL;
   }
@@ -682 +682 @@
   // Get the option's description string size
   //
-  TempSize = StrSizeEx ((CHAR16 *) TempPtr, VariableSize);
-  if (TempSize == 0) {
-    return NULL;
-  }
-  TempPtr += TempSize;
+  TempPtr += StrSize((CHAR16 *) TempPtr);
 
   //
@@ -695 +691 @@
 
   //
-  // Validation device path.
-  //
-  TempPath       = DevicePath;
-  while (FilePathSize > 0) {
-    TempSize = GetDevicePathSizeEx (TempPath, FilePathSize);
-    if (TempSize == 0) {
-      return NULL;
-    }
-    FilePathSize = (UINT16) (FilePathSize - TempSize);
-    TempPath    += TempSize;
-  }
-
-  //
   // Get load opion data.
   //
   LoadOptions     = TempPtr;
-  if (VariableSize < (UINTN)(TempPtr - Variable)) {
-    VBoxLogFlowFuncMarkVar(Variable, "%p");
-    VBoxLogFlowFuncLeave();
-    return NULL;
-  }
   LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable));
 
@@ -726 +704 @@
     VBoxLogFlowFuncMarkVar(Variable, "%p");
     VBoxLogFlowFuncLeave();
+    FreePool (Variable);
     return NULL;
   }
@@ -763 +742 @@
                + (UINT16) (CharToUint (VariableName[NumOff+3]) * 0x1);
   }
-  //
-  // Insert active entry to BdsDeviceList
-  //
-  if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) {
-    InsertTailList (BdsCommonOptionList, &Option->Link);
-    FreePool (Variable);
-    VBoxLogFlowFuncMarkVar(Option, "%p");
-    VBoxLogFlowFuncLeave();
-    return Option;
-  }
-
+  InsertTailList (BdsCommonOptionList, &Option->Link);
   FreePool (Variable);
-  FreePool (Option->Description);
-  FreePool (Option->DevicePath);
-  FreePool (Option->LoadOptions);
-#ifdef VBOX
-  FreePool (Option->OptionName);
-#endif
-  FreePool (Option);
   VBoxLogFlowFuncLeave();
-  return NULL;
+  return Option;
 }
 
@@ -908 +870 @@
     Buffer = AllocateZeroPool (BufferSize);
     if (Buffer == NULL) {
+      *VariableSize = 0;
       return NULL;
     }
@@ -916 +879 @@
     VBoxLogFlowFuncMarkRC(Status);
     if (EFI_ERROR (Status)) {
+      FreePool (Buffer);
       BufferSize = 0;
-    }
-  }
-
+      Buffer     = NULL;
+    }
+  }
+
+  ASSERT (((Buffer == NULL) && (BufferSize == 0)) ||
+          ((Buffer != NULL) && (BufferSize != 0))
+          );
   *VariableSize = BufferSize;
   VBoxLogFlowFuncLeave();
@@ -1203 +1171 @@
       StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
       ASSERT (StringBuffer2 != NULL);
-      StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? ");
-      StrCpy (StringBuffer2, L"Enter (YES)  /   Esc (NO)");
+      StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now.");
+      StrCpy (StringBuffer2, L"Press ENTER to reset");
       //
       // Popup a menu to notice user
@@ -1210 +1178 @@
       do {
         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
-      } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
+      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
 
       FreePool (StringBuffer1);
       FreePool (StringBuffer2);
-      //
-      // If the user hits the YES Response key, reset
-      //
-      if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
-        gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
-      }
-      gST->ConOut->ClearScreen (gST->ConOut);
+
+      gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
     }
   }
@@ -1396 +1359 @@
 
 /**
-  This routine adjusts the memory information for different memory type and
-  saves them into the variables for next boot. It conditionally resets the
-  system when the memory information changes. Platform can reserve memory
-  large enough (125% of actual requirement) to avoid the reset in the first boot.
+  This routine adjust the memory information for different memory type and 
+  save them into the variables for next boot.
 **/
 VOID
@@ -1505 +1466 @@
 
     //
-    // Write next varible to 125% * current and Inconsistent Memory Reserved across bootings may lead to S4 fail
-    //
-    if (Current < Previous) {
+    // Inconsistent Memory Reserved across bootings may lead to S4 fail
+    // Write next varible to 125% * current when the pre-allocated memory is:
+    //  1. More than 150% of needed memory and boot mode is BOOT_WITH_DEFAULT_SETTING
+    //  2. Less than the needed memory
+    //
+    if ((Current + (Current >> 1)) < Previous) {
       if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {
         Next = Current + (Current >> 2);
-      } else if (!MemoryTypeInformationVariableExists) {
-        Next = MAX (Current + (Current >> 2), Previous);
       }
     } else if (Current > Previous) {
@@ -1533 +1495 @@
   //
   if (MemoryTypeInformationModified || !MemoryTypeInformationVariableExists) {
-    Status = gRT->SetVariable (
-                    EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
-                    &gEfiMemoryTypeInformationGuid,
-                    EFI_VARIABLE_NON_VOLATILE  | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
-                    VariableSize,
-                    PreviousMemoryTypeInformation
-                    );
-
-    //
-    // If the Memory Type Information settings have been modified, then reset the platform
-    // so the new Memory Type Information setting will be used to guarantee that an S4
-    // entry/resume cycle will not fail.
-    //
-    if (MemoryTypeInformationModified && PcdGetBool (PcdResetOnMemoryTypeInformationChange)) {
-      DEBUG ((EFI_D_INFO, "Memory Type Information settings change. Warm Reset!!!\n"));
-      gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
+    Status = SetVariableAndReportStatusCodeOnError (
+               EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
+               &gEfiMemoryTypeInformationGuid,
+               EFI_VARIABLE_NON_VOLATILE  | EFI_VARIABLE_BOOTSERVICE_ACCESS,
+               VariableSize,
+               PreviousMemoryTypeInformation
+               );
+
+    if (!EFI_ERROR (Status)) {
+      //
+      // If the Memory Type Information settings have been modified, then reset the platform
+      // so the new Memory Type Information setting will be used to guarantee that an S4
+      // entry/resume cycle will not fail.
+      //
+      if (MemoryTypeInformationModified && PcdGetBool (PcdResetOnMemoryTypeInformationChange)) {
+        DEBUG ((EFI_D_INFO, "Memory Type Information settings change. Warm Reset!!!\n"));
+        gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
+      }
+    } else {
+      DEBUG ((EFI_D_ERROR, "Memory Type Information settings cannot be saved. OS S4 may fail!\n"));
     }
   }
@@ -1596 +1562 @@
 }
 
+/**
+  Set the variable and report the error through status code upon failure.
+
+  @param  VariableName           A Null-terminated string that is the name of the vendor's variable.
+                                 Each VariableName is unique for each VendorGuid. VariableName must
+                                 contain 1 or more characters. If VariableName is an empty string,
+                                 then EFI_INVALID_PARAMETER is returned.
+  @param  VendorGuid             A unique identifier for the vendor.
+  @param  Attributes             Attributes bitmask to set for the variable.
+  @param  DataSize               The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE, 
+                                 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, or 
+                                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero 
+                                 causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is 
+                                 set, then a SetVariable() call with a DataSize of zero will not cause any change to 
+                                 the variable value (the timestamp associated with the variable may be updated however 
+                                 even if no new data value is provided,see the description of the 
+                                 EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not 
+                                 be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated). 
+  @param  Data                   The contents for the variable.
+
+  @retval EFI_SUCCESS            The firmware has successfully stored the variable and its data as
+                                 defined by the Attributes.
+  @retval EFI_INVALID_PARAMETER  An invalid combination of attribute bits, name, and GUID was supplied, or the
+                                 DataSize exceeds the maximum allowed.
+  @retval EFI_INVALID_PARAMETER  VariableName is an empty string.
+  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.
+  @retval EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval EFI_WRITE_PROTECTED    The variable in question is read-only.
+  @retval EFI_WRITE_PROTECTED    The variable in question cannot be deleted.
+  @retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 
+                                 or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS being set, but the AuthInfo 
+                                 does NOT pass the validation check carried out by the firmware.
+
+  @retval EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.
+**/
+EFI_STATUS
+SetVariableAndReportStatusCodeOnError (
+  IN CHAR16     *VariableName,
+  IN EFI_GUID   *VendorGuid,
+  IN UINT32     Attributes,
+  IN UINTN      DataSize,
+  IN VOID       *Data
+  )
+{
+  EFI_STATUS                 Status;
+  EDKII_SET_VARIABLE_STATUS  *SetVariableStatus;
+  UINTN                      NameSize;
+
+  Status = gRT->SetVariable (
+                  VariableName,
+                  VendorGuid,
+                  Attributes,
+                  DataSize,
+                  Data
+                  );
+  if (EFI_ERROR (Status)) {
+    NameSize = StrSize (VariableName);
+    SetVariableStatus = AllocatePool (sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + DataSize);
+    if (SetVariableStatus != NULL) {
+      CopyGuid (&SetVariableStatus->Guid, VendorGuid);
+      SetVariableStatus->NameSize   = NameSize;
+      SetVariableStatus->DataSize   = DataSize;
+      SetVariableStatus->SetStatus  = Status;
+      SetVariableStatus->Attributes = Attributes;
+      CopyMem (SetVariableStatus + 1,                          VariableName, NameSize);
+      if ((Data != NULL) && (DataSize != 0)) {
+        CopyMem (((UINT8 *) (SetVariableStatus + 1)) + NameSize, Data,         DataSize);
+      }
+
+      REPORT_STATUS_CODE_EX (
+        EFI_ERROR_CODE,
+        PcdGet32 (PcdErrorCodeSetVariable),
+        0,
+        NULL,
+        &gEdkiiStatusCodeDataTypeVariableGuid,
+        SetVariableStatus,
+        sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + DataSize
+        );
+
+      FreePool (SetVariableStatus);
+    }
+  }
+
+  return Status;
+}
+

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/DevicePath.c

@@ -3 +3 @@
   replaced by platform device path.
 
-Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -15 +15 @@
 
 #include "InternalBdsLib.h"
-
-/**
-  Concatenates a formatted unicode string to allocated pool.
-  The caller must free the resulting buffer.
-
-  @param  Str      Tracks the allocated pool, size in use, and amount of pool allocated.
-  @param  Fmt      The format string
-  @param  ...      The data will be printed.
-
-  @return Allocated buffer with the formatted string printed in it.
-          The caller must free the allocated buffer.
-          The buffer allocation is not packed.
-
-**/
-CHAR16 *
-EFIAPI
-CatPrint (
-  IN OUT POOL_PRINT   *Str,
-  IN CHAR16           *Fmt,
-  ...
-  )
-{
-  UINT16  *AppendStr;
-  VA_LIST Args;
-  UINTN   StringSize;
-
-  AppendStr = AllocateZeroPool (0x1000);
-  if (AppendStr == NULL) {
-    return Str->Str;
-  }
-
-  VA_START (Args, Fmt);
-  UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args);
-  VA_END (Args);
-  if (NULL == Str->Str) {
-    StringSize   = StrSize (AppendStr);
-    Str->Str  = AllocateZeroPool (StringSize);
-    ASSERT (Str->Str != NULL);
-  } else {
-    StringSize = StrSize (AppendStr);
-    StringSize += (StrSize (Str->Str) - sizeof (UINT16));
-
-    Str->Str = ReallocatePool (
-                StrSize (Str->Str),
-                StringSize,
-                Str->Str
-                );
-    ASSERT (Str->Str != NULL);
-  }
-
-  Str->Maxlen = MAX_CHAR * sizeof (UINT16);
-  if (StringSize < Str->Maxlen) {
-    StrCat (Str->Str, AppendStr);
-    Str->Len = StringSize - sizeof (UINT16);
-  }
-
-  FreePool (AppendStr);
-  return Str->Str;
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathPci (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  PCI_DEVICE_PATH *Pci;
-
-  Pci = DevPath;
-  CatPrint (Str, L"Pci(%x|%x)", (UINTN) Pci->Device, (UINTN) Pci->Function);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathPccard (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  PCCARD_DEVICE_PATH  *Pccard;
-
-  Pccard = DevPath;
-  CatPrint (Str, L"Pcmcia(Function%x)", (UINTN) Pccard->FunctionNumber);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathMemMap (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MEMMAP_DEVICE_PATH  *MemMap;
-
-  MemMap = DevPath;
-  CatPrint (
-    Str,
-    L"MemMap(%d:%lx-%lx)",
-    (UINTN) MemMap->MemoryType,
-    MemMap->StartingAddress,
-    MemMap->EndingAddress
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathController (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  CONTROLLER_DEVICE_PATH  *Controller;
-
-  Controller = DevPath;
-  CatPrint (Str, L"Ctrl(%d)", (UINTN) Controller->ControllerNumber);
-}
-
-
-/**
-  Convert Vendor device path to device name.
-
-  @param  Str      The buffer store device name
-  @param  DevPath  Pointer to vendor device path
-
-**/
-VOID
-DevPathVendor (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  VENDOR_DEVICE_PATH  *Vendor;
-  CHAR16              *Type;
-  UINTN               DataLength;
-  UINTN               Index;
-  UINT32              FlowControlMap;
-
-  UINT16              Info;
-
-  Vendor  = DevPath;
-
-  switch (DevicePathType (&Vendor->Header)) {
-  case HARDWARE_DEVICE_PATH:
-    Type = L"Hw";
-    break;
-
-  case MESSAGING_DEVICE_PATH:
-    Type = L"Msg";
-    if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
-      CatPrint (Str, L"VenPcAnsi()");
-      return ;
-    } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
-      CatPrint (Str, L"VenVt100()");
-      return ;
-    } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
-      CatPrint (Str, L"VenVt100Plus()");
-      return ;
-    } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
-      CatPrint (Str, L"VenUft8()");
-      return ;
-    } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid     )) {
-      FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
-      switch (FlowControlMap & 0x00000003) {
-      case 0:
-        CatPrint (Str, L"UartFlowCtrl(%s)", L"None");
-        break;
-
-      case 1:
-        CatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
-        break;
-
-      case 2:
-        CatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
-        break;
-
-      default:
-        break;
-      }
-
-      return ;
-
-    } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
-      CatPrint (
-        Str,
-        L"SAS(%lx,%lx,%x,",
-        ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
-        ((SAS_DEVICE_PATH *) Vendor)->Lun,
-        (UINTN) ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
-        );
-      Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
-      if ((Info & 0x0f) == 0) {
-        CatPrint (Str, L"NoTopology,0,0,0,");
-      } else if (((Info & 0x0f) == 1) || ((Info & 0x0f) == 2)) {
-        CatPrint (
-          Str,
-          L"%s,%s,%s,",
-          ((Info & (0x1 << 4)) != 0) ? L"SATA" : L"SAS",
-          ((Info & (0x1 << 5)) != 0) ? L"External" : L"Internal",
-          ((Info & (0x1 << 6)) != 0) ? L"Expanded" : L"Direct"
-          );
-        if ((Info & 0x0f) == 1) {
-          CatPrint (Str, L"0,");
-        } else {
-          CatPrint (Str, L"%x,", (UINTN) ((Info >> 8) & 0xff));
-        }
-      } else {
-        CatPrint (Str, L"0,0,0,0,");
-      }
-
-      CatPrint (Str, L"%x)", (UINTN) ((SAS_DEVICE_PATH *) Vendor)->Reserved);
-      return ;
-
-    } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
-      CatPrint (Str, L"DebugPort()");
-      return ;
-    }
-    break;
-
-  case MEDIA_DEVICE_PATH:
-    Type = L"Media";
-    break;
-
-  default:
-    Type = L"?";
-    break;
-  }
-
-  CatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
-  DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
-  if (DataLength > 0) {
-    CatPrint (Str, L",");
-    for (Index = 0; Index < DataLength; Index++) {
-      CatPrint (Str, L"%02x", (UINTN) ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
-    }
-  }
-  CatPrint (Str, L")");
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathAcpi (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  ACPI_HID_DEVICE_PATH  *Acpi;
-
-  Acpi = DevPath;
-  if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
-    CatPrint (Str, L"Acpi(PNP%04x,%x)", (UINTN)  EISA_ID_TO_NUM (Acpi->HID), (UINTN) Acpi->UID);
-  } else {
-    CatPrint (Str, L"Acpi(%08x,%x)", (UINTN) Acpi->HID, (UINTN) Acpi->UID);
-  }
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathExtendedAcpi (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  ACPI_EXTENDED_HID_DEVICE_PATH   *ExtendedAcpi;
-  
-  //
-  // Index for HID, UID and CID strings, 0 for non-exist
-  //
-  UINT16                          HIDSTRIdx;
-  UINT16                          UIDSTRIdx;
-  UINT16                          CIDSTRIdx;
-  UINT16                          Index;
-  UINT16                          Length;
-  UINT16                          Anchor;
-  CHAR8                           *AsChar8Array;
-
-  HIDSTRIdx    = 0;
-  UIDSTRIdx    = 0;
-  CIDSTRIdx    = 0;
-  ExtendedAcpi = DevPath;
-  Length       = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) ExtendedAcpi);
-
-  AsChar8Array = (CHAR8 *) ExtendedAcpi;
-
-  //
-  // find HIDSTR
-  //
-  Anchor = 16;
-  for (Index = Anchor; Index < Length && AsChar8Array[Index] != '\0'; Index++) {
-    ;
-  }
-  if (Index > Anchor) {
-    HIDSTRIdx = Anchor;
-  }
-  //
-  // find UIDSTR
-  //
-  Anchor = (UINT16) (Index + 1);
-  for (Index = Anchor; Index < Length && AsChar8Array[Index] != '\0'; Index++) {
-    ;
-  }
-  if (Index > Anchor) {
-    UIDSTRIdx = Anchor;
-  }
-  //
-  // find CIDSTR
-  //
-  Anchor = (UINT16) (Index + 1);
-  for (Index = Anchor; Index < Length && AsChar8Array[Index] != '\0'; Index++) {
-    ;
-  }
-  if (Index > Anchor) {
-    CIDSTRIdx = Anchor;
-  }
-
-  if (HIDSTRIdx == 0 && CIDSTRIdx == 0 && ExtendedAcpi->UID == 0) {
-    CatPrint (Str, L"AcpiExp(");
-    if ((ExtendedAcpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
-      CatPrint (Str, L"PNP%04x,", (UINTN) EISA_ID_TO_NUM (ExtendedAcpi->HID));
-    } else {
-      CatPrint (Str, L"%08x,", (UINTN) ExtendedAcpi->HID);
-    }
-    if ((ExtendedAcpi->CID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
-      CatPrint (Str, L"PNP%04x,", (UINTN)  EISA_ID_TO_NUM (ExtendedAcpi->CID));
-    } else {
-      CatPrint (Str, L"%08x,", (UINTN)  ExtendedAcpi->CID);
-    }
-    if (UIDSTRIdx != 0) {
-      CatPrint (Str, L"%a)", AsChar8Array + UIDSTRIdx);
-    } else {
-      CatPrint (Str, L"\"\")");
-    }
-  } else {
-    CatPrint (Str, L"AcpiEx(");
-    if ((ExtendedAcpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
-      CatPrint (Str, L"PNP%04x,", (UINTN)  EISA_ID_TO_NUM (ExtendedAcpi->HID));
-    } else {
-      CatPrint (Str, L"%08x,", (UINTN) ExtendedAcpi->HID);
-    }
-    if ((ExtendedAcpi->CID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
-      CatPrint (Str, L"PNP%04x,", (UINTN) EISA_ID_TO_NUM (ExtendedAcpi->CID));
-    } else {
-      CatPrint (Str, L"%08x,", (UINTN) ExtendedAcpi->CID);
-    }
-    CatPrint (Str, L"%x,", (UINTN) ExtendedAcpi->UID);
-
-    if (HIDSTRIdx != 0) {
-      CatPrint (Str, L"%a,", AsChar8Array + HIDSTRIdx);
-    } else {
-      CatPrint (Str, L"\"\",");
-    }
-    if (CIDSTRIdx != 0) {
-      CatPrint (Str, L"%a,", AsChar8Array + CIDSTRIdx);
-    } else {
-      CatPrint (Str, L"\"\",");
-    }
-    if (UIDSTRIdx != 0) {
-      CatPrint (Str, L"%a)", AsChar8Array + UIDSTRIdx);
-    } else {
-      CatPrint (Str, L"\"\")");
-    }
-  }
-
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathAdrAcpi (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  ACPI_ADR_DEVICE_PATH    *AcpiAdr;
-  UINT16                  Index;
-  UINT16                  Length;
-  UINT16                  AdditionalAdrCount;
-
-  AcpiAdr            = DevPath;
-  Length             = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
-  AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
-
-  CatPrint (Str, L"AcpiAdr(%x", (UINTN) AcpiAdr->ADR);
-  for (Index = 0; Index < AdditionalAdrCount; Index++) {
-    CatPrint (Str, L",%x", (UINTN) *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
-  }
-  CatPrint (Str, L")");
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathAtapi (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  ATAPI_DEVICE_PATH *Atapi;
-
-  Atapi = DevPath;
-  CatPrint (
-    Str,
-    L"Ata(%s,%s)",
-    (Atapi->PrimarySecondary != 0)? L"Secondary" : L"Primary",
-    (Atapi->SlaveMaster != 0)? L"Slave" : L"Master"
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathScsi (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  SCSI_DEVICE_PATH  *Scsi;
-
-  Scsi = DevPath;
-  CatPrint (Str, L"Scsi(Pun%x,Lun%x)", (UINTN) Scsi->Pun, (UINTN) Scsi->Lun);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathFibre (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  FIBRECHANNEL_DEVICE_PATH  *Fibre;
-
-  Fibre = DevPath;
-  CatPrint (Str, L"Fibre(Wwn%lx,Lun%x)", Fibre->WWN, Fibre->Lun);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPath1394 (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  F1394_DEVICE_PATH *F1394Path;
-
-  F1394Path = DevPath;
-  CatPrint (Str, L"1394(%lx)", &F1394Path->Guid);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathUsb (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  USB_DEVICE_PATH *Usb;
-
-  Usb = DevPath;
-  CatPrint (Str, L"Usb(%x,%x)", (UINTN) Usb->ParentPortNumber, (UINTN) Usb->InterfaceNumber);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathUsbWWID (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  USB_WWID_DEVICE_PATH  *UsbWWId;
-
-  UsbWWId = DevPath;
-  CatPrint (
-    Str,
-    L"UsbWwid(%x,%x,%x,\"WWID\")",
-    (UINTN) UsbWWId->VendorId,
-    (UINTN) UsbWWId->ProductId,
-    (UINTN) UsbWWId->InterfaceNumber
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathLogicalUnit (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
-
-  LogicalUnit = DevPath;
-  CatPrint (Str, L"Unit(%x)", (UINTN) LogicalUnit->Lun);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathUsbClass (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  USB_CLASS_DEVICE_PATH *UsbClass;
-
-  UsbClass = DevPath;
-  CatPrint (
-    Str,
-    L"Usb Class(%x,%x,%x,%x,%x)",
-    (UINTN) UsbClass->VendorId,
-    (UINTN) UsbClass->ProductId,
-    (UINTN) UsbClass->DeviceClass,
-    (UINTN) UsbClass->DeviceSubClass,
-    (UINTN) UsbClass->DeviceProtocol
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathSata (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  SATA_DEVICE_PATH *Sata;
-
-  Sata = DevPath;
-  if ((Sata->PortMultiplierPortNumber & SATA_HBA_DIRECT_CONNECT_FLAG) != 0) {
-    CatPrint (
-      Str,
-      L"Sata(%x,%x)",
-      (UINTN) Sata->HBAPortNumber,
-      (UINTN) Sata->Lun
-      );
-  } else {
-    CatPrint (
-      Str,
-      L"Sata(%x,%x,%x)",
-      (UINTN) Sata->HBAPortNumber,
-      (UINTN) Sata->PortMultiplierPortNumber,
-      (UINTN) Sata->Lun
-      );
-  }
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathI2O (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  I2O_DEVICE_PATH *I2OPath;
-
-  I2OPath = DevPath;
-  CatPrint (Str, L"I2O(%x)", (UINTN) I2OPath->Tid);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathMacAddr (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MAC_ADDR_DEVICE_PATH  *MACDevPath;
-  UINTN                 HwAddressSize;
-  UINTN                 Index;
-
-  MACDevPath           = DevPath;
-
-  HwAddressSize = sizeof (EFI_MAC_ADDRESS);
-  if (MACDevPath->IfType == 0x01 || MACDevPath->IfType == 0x00) {
-    HwAddressSize = 6;
-  }
-
-  CatPrint (Str, L"Mac(");
-
-  for (Index = 0; Index < HwAddressSize; Index++) {
-    CatPrint (Str, L"%02x", (UINTN) MACDevPath->MacAddress.Addr[Index]);
-  }
-
-  CatPrint (Str, L")");
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathIPv4 (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  IPv4_DEVICE_PATH  *IPDevPath;
-
-  IPDevPath = DevPath;
-  CatPrint (
-    Str,
-    L"IPv4(%d.%d.%d.%d:%d)",
-    (UINTN) IPDevPath->RemoteIpAddress.Addr[0],
-    (UINTN) IPDevPath->RemoteIpAddress.Addr[1],
-    (UINTN) IPDevPath->RemoteIpAddress.Addr[2],
-    (UINTN) IPDevPath->RemoteIpAddress.Addr[3],
-    (UINTN) IPDevPath->RemotePort
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathIPv6 (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  IPv6_DEVICE_PATH  *IPv6DevPath;
-
-  IPv6DevPath = DevPath;
-  CatPrint (
-    Str,
-    L"IPv6(%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x)",
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[0],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[1],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[2],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[3],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[4],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[5],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[6],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[7],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[8],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[9],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[10],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[11],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[12],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[13],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[14],
-    (UINTN) IPv6DevPath->RemoteIpAddress.Addr[15]
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathInfiniBand (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  INFINIBAND_DEVICE_PATH  *InfiniBand;
-
-  InfiniBand = DevPath;
-  CatPrint (
-    Str,
-    L"Infiniband(%x,%g,%lx,%lx,%lx)",
-    (UINTN) InfiniBand->ResourceFlags,
-    InfiniBand->PortGid,
-    InfiniBand->ServiceId,
-    InfiniBand->TargetPortId,
-    InfiniBand->DeviceId
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathUart (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  UART_DEVICE_PATH  *Uart;
-  CHAR8             Parity;
-
-  Uart = DevPath;
-  switch (Uart->Parity) {
-  case 0:
-    Parity = 'D';
-    break;
-
-  case 1:
-    Parity = 'N';
-    break;
-
-  case 2:
-    Parity = 'E';
-    break;
-
-  case 3:
-    Parity = 'O';
-    break;
-
-  case 4:
-    Parity = 'M';
-    break;
-
-  case 5:
-    Parity = 'S';
-    break;
-
-  default:
-    Parity = 'x';
-    break;
-  }
-
-  if (Uart->BaudRate == 0) {
-    CatPrint (Str, L"Uart(DEFAULT,%c,", Parity);
-  } else {
-    CatPrint (Str, L"Uart(%ld,%c,", Uart->BaudRate, Parity);
-  }
-
-  if (Uart->DataBits == 0) {
-    CatPrint (Str, L"D,");
-  } else {
-    CatPrint (Str, L"%d,", (UINTN) Uart->DataBits);
-  }
-
-  switch (Uart->StopBits) {
-  case 0:
-    CatPrint (Str, L"D)");
-    break;
-
-  case 1:
-    CatPrint (Str, L"1)");
-    break;
-
-  case 2:
-    CatPrint (Str, L"1.5)");
-    break;
-
-  case 3:
-    CatPrint (Str, L"2)");
-    break;
-
-  default:
-    CatPrint (Str, L"x)");
-    break;
-  }
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathiSCSI (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  ISCSI_DEVICE_PATH_WITH_NAME *IScsi;
-  UINT16                      Options;
-
-  IScsi = DevPath;
-  CatPrint (
-    Str,
-    L"iSCSI(%a,%x,%lx,",
-    IScsi->TargetName,
-    (UINTN) IScsi->TargetPortalGroupTag,
-    IScsi->Lun
-    );
-
-  Options = IScsi->LoginOption;
-  CatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
-  CatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
-  if (((Options >> 11) & 0x0001) != 0) {
-    CatPrint (Str, L"%s,", L"None");
-  } else if (((Options >> 12) & 0x0001) != 0) {
-    CatPrint (Str, L"%s,", L"CHAP_UNI");
-  } else {
-    CatPrint (Str, L"%s,", L"CHAP_BI");
-
-  }
-
-  CatPrint (Str, L"%s)", (IScsi->NetworkProtocol == 0) ? L"TCP" : L"reserved");
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathVlan (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  VLAN_DEVICE_PATH  *Vlan;
-
-  Vlan = DevPath;
-  CatPrint (Str, L"Vlan(%d)", (UINTN) Vlan->VlanId);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathHardDrive (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  HARDDRIVE_DEVICE_PATH *Hd;
-
-  Hd = DevPath;
-  switch (Hd->SignatureType) {
-  case SIGNATURE_TYPE_MBR:
-    CatPrint (
-      Str,
-      L"HD(Part%d,Sig%08x)",
-      (UINTN) Hd->PartitionNumber,
-      (UINTN) *((UINT32 *) (&(Hd->Signature[0])))
-      );
-    break;
-
-  case SIGNATURE_TYPE_GUID:
-    CatPrint (
-      Str,
-      L"HD(Part%d,Sig%g)",
-      (UINTN) Hd->PartitionNumber,
-      (EFI_GUID *) &(Hd->Signature[0])
-      );
-    break;
-
-  default:
-    CatPrint (
-      Str,
-      L"HD(Part%d,MBRType=%02x,SigType=%02x)",
-      (UINTN) Hd->PartitionNumber,
-      (UINTN) Hd->MBRType,
-      (UINTN) Hd->SignatureType
-      );
-    break;
-  }
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathCDROM (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  CDROM_DEVICE_PATH *Cd;
-
-  Cd = DevPath;
-  CatPrint (Str, L"CDROM(Entry%x)", (UINTN) Cd->BootEntry);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathFilePath (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  FILEPATH_DEVICE_PATH  *Fp;
-
-  Fp = DevPath;
-  CatPrint (Str, L"%s", Fp->PathName);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathMediaProtocol (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
-
-  MediaProt = DevPath;
-  CatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathFvFilePath (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;
-
-  FvFilePath = DevPath;
-  CatPrint (Str, L"%g", &FvFilePath->FvFileName);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathRelativeOffsetRange (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
-
-  Offset = DevPath;
-  CatPrint (
-    Str,
-    L"Offset(%lx,%lx)",
-    Offset->StartingOffset,
-    Offset->EndingOffset
-    );
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathBssBss (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  BBS_BBS_DEVICE_PATH *Bbs;
-  CHAR16              *Type;
-
-  Bbs = DevPath;
-  switch (Bbs->DeviceType) {
-  case BBS_TYPE_FLOPPY:
-    Type = L"Floppy";
-    break;
-
-  case BBS_TYPE_HARDDRIVE:
-    Type = L"Harddrive";
-    break;
-
-  case BBS_TYPE_CDROM:
-    Type = L"CDROM";
-    break;
-
-  case BBS_TYPE_PCMCIA:
-    Type = L"PCMCIA";
-    break;
-
-  case BBS_TYPE_USB:
-    Type = L"Usb";
-    break;
-
-  case BBS_TYPE_EMBEDDED_NETWORK:
-    Type = L"Net";
-    break;
-
-  case BBS_TYPE_BEV:
-    Type = L"BEV";
-    break;
-
-  default:
-    Type = L"?";
-    break;
-  }
-  CatPrint (Str, L"Legacy-%s", Type);
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathEndInstance (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  CatPrint (Str, L",");
-}
-
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maixmum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathNodeUnknown (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  CatPrint (Str, L"?");
-}
-/**
-  Convert Device Path to a Unicode string for printing.
-
-  @param Str             The buffer holding the output string.
-                         This buffer contains the length of the
-                         string and the maximum length reserved
-                         for the string buffer.
-  @param DevPath         The device path.
-
-**/
-VOID
-DevPathFvPath (
-  IN OUT POOL_PRINT       *Str,
-  IN VOID                 *DevPath
-  )
-{
-  MEDIA_FW_VOL_DEVICE_PATH *FvPath;
-
-  FvPath = DevPath;
-  CatPrint (Str, L"Fv(%g)", &FvPath->FvName);
-}
-
-DEVICE_PATH_STRING_TABLE  DevPathTable[] = {
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_PCI_DP,
-    DevPathPci
-  },
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_PCCARD_DP,
-    DevPathPccard
-  },
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_MEMMAP_DP,
-    DevPathMemMap
-  },
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_VENDOR_DP,
-    DevPathVendor
-  },
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_CONTROLLER_DP,
-    DevPathController
-  },
-  {
-    ACPI_DEVICE_PATH,
-    ACPI_DP,
-    DevPathAcpi
-  },
-  {
-    ACPI_DEVICE_PATH,
-    ACPI_EXTENDED_DP,
-    DevPathExtendedAcpi
-  },
-  {
-    ACPI_DEVICE_PATH,
-    ACPI_ADR_DP,
-    DevPathAdrAcpi
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_ATAPI_DP,
-    DevPathAtapi
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_SCSI_DP,
-    DevPathScsi
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_FIBRECHANNEL_DP,
-    DevPathFibre
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_1394_DP,
-    DevPath1394
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_USB_DP,
-    DevPathUsb
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_USB_WWID_DP,
-    DevPathUsbWWID
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_DEVICE_LOGICAL_UNIT_DP,
-    DevPathLogicalUnit
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_USB_CLASS_DP,
-    DevPathUsbClass
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_SATA_DP,
-    DevPathSata
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_I2O_DP,
-    DevPathI2O
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_MAC_ADDR_DP,
-    DevPathMacAddr
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_IPv4_DP,
-    DevPathIPv4
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_IPv6_DP,
-    DevPathIPv6
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_INFINIBAND_DP,
-    DevPathInfiniBand
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_UART_DP,
-    DevPathUart
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_VENDOR_DP,
-    DevPathVendor
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_ISCSI_DP,
-    DevPathiSCSI
-  },
-  {
-    MESSAGING_DEVICE_PATH,
-    MSG_VLAN_DP,
-    DevPathVlan
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_HARDDRIVE_DP,
-    DevPathHardDrive
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_CDROM_DP,
-    DevPathCDROM
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_VENDOR_DP,
-    DevPathVendor
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_FILEPATH_DP,
-    DevPathFilePath
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_PROTOCOL_DP,
-    DevPathMediaProtocol
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_PIWG_FW_VOL_DP,
-    DevPathFvPath,
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_PIWG_FW_FILE_DP,
-    DevPathFvFilePath
-  },
-  {
-    MEDIA_DEVICE_PATH,
-    MEDIA_RELATIVE_OFFSET_RANGE_DP,
-    DevPathRelativeOffsetRange,
-  },
-  {
-    BBS_DEVICE_PATH,
-    BBS_BBS_DP,
-    DevPathBssBss
-  },
-  {
-    END_DEVICE_PATH_TYPE,
-    END_INSTANCE_DEVICE_PATH_SUBTYPE,
-    DevPathEndInstance
-  },
-  {
-    0,
-    0,
-    NULL
-  }
-};
-
 
 /**
@@ -1490 +30 @@
   )
 {
-  POOL_PRINT                Str;
-  EFI_DEVICE_PATH_PROTOCOL  *DevPathNode;
-  VOID (*DumpNode) (POOL_PRINT *, VOID *);
-
-  UINTN Index;
-  UINTN NewSize;
-
-  EFI_STATUS                       Status;
-  CHAR16                           *ToText;
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevPathToText;
-
-  ZeroMem (&Str, sizeof (Str));
-
-  if (DevPath == NULL) {
-    goto Done;
-  }
-
-  Status = gBS->LocateProtocol (
-                  &gEfiDevicePathToTextProtocolGuid,
-                  NULL,
-                  (VOID **) &DevPathToText
-                  );
-  if (!EFI_ERROR (Status)) {
-    ToText = DevPathToText->ConvertDevicePathToText (
-                              DevPath,
-                              FALSE,
-                              TRUE
-                              );
-    ASSERT (ToText != NULL);
-    return ToText;
-  }
-
-  //
-  // Process each device path node
-  //
-  DevPathNode = DevPath;
-  while (!IsDevicePathEnd (DevPathNode)) {
-    //
-    // Find the handler to dump this device path node
-    //
-    DumpNode = NULL;
-    for (Index = 0; DevPathTable[Index].Function != NULL; Index += 1) {
-
-      if (DevicePathType (DevPathNode) == DevPathTable[Index].Type &&
-          DevicePathSubType (DevPathNode) == DevPathTable[Index].SubType
-          ) {
-        DumpNode = DevPathTable[Index].Function;
-        break;
-      }
-    }
-    //
-    // If not found, use a generic function
-    //
-    if (!DumpNode) {
-      DumpNode = DevPathNodeUnknown;
-    }
-    //
-    //  Put a path seperator in if needed
-    //
-    if ((Str.Len != 0) && (DumpNode != DevPathEndInstance)) {
-      CatPrint (&Str, L"/");
-    }
-    //
-    // Print this node of the device path
-    //
-    DumpNode (&Str, DevPathNode);
-
-    //
-    // Next device path node
-    //
-    DevPathNode = NextDevicePathNode (DevPathNode);
-  }
-
-Done:
-  NewSize = (Str.Len + 1) * sizeof (CHAR16);
-  Str.Str = ReallocatePool (NewSize, NewSize, Str.Str);
-  ASSERT (Str.Str != NULL);
-  Str.Str[Str.Len] = 0;
-  return Str.Str;
+  return ConvertDevicePathToText (DevPath, TRUE, TRUE);
 }

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/GenericBdsLib.inf

@@ -1 +1 @@
 ## @file
+#  General BDS library.
 #  
 #  General BDS defines and produce general interfaces for platform BDS driver including:
@@ -6 +7 @@
 #  3) BDS Misc interfaces for mainting boot variable, ouput string, etc.
 #  
-#  Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
@@ -20 +21 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = GenericBdsLib
+  MODULE_UNI_FILE                = GenericBdsLib.uni
   FILE_GUID                      = e405ec31-ccaa-4dd4-83e8-0aec01703f7e
   MODULE_TYPE                    = DXE_DRIVER
   VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = GenericBdsLib|DXE_DRIVER UEFI_APPLICATION 
+  LIBRARY_CLASS                  = GenericBdsLib|DXE_DRIVER DXE_RUNTIME_DRIVER UEFI_APPLICATION 
   CONSTRUCTOR                    = GenericBdsLibConstructor
 
@@ -71 +73 @@
 
 [Guids]
-  gEfiVT100PlusGuid                             ## CONSUMES ## GUID (The type of terminal)
-  gEfiVT100Guid                                 ## CONSUMES ## GUID (The type of terminal)
-                                                ## CONSUMES ## GUID HOB (The hob holding memory type information)
-  gEfiMemoryTypeInformationGuid                 ## CONSUMES ## GUID (The identifier of memory type information type in system table)
-  gEfiVTUTF8Guid                                ## CONSUMES ## GUID (The type of terminal)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"BootXX" (Boot option variable)
-                                                ## CONSUMES           ## Variable:L"Timeout" (The time out value in second of showing progress bar)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"BootOrder" (The boot option array)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"DriverOrder" (The driver order list)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"ConIn" (The device path of console in device)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"ConOut" (The device path of console out device)
-                                                ## SOMETIMES_CONSUMES ## Variable:L"ErrOut" (The device path of error out device)
-  gEfiGlobalVariableGuid                        ## SOMETIMES_PRODUCES ## Variable:L"BootCurrent" (The boot option of current boot)
-  gEfiFileInfoGuid                              ## CONSUMES ## GUID
-  gEfiPcAnsiGuid                                ## CONSUMES ## GUID (The type of terminal)
-  gPerformanceProtocolGuid                      ## SOMETIMES_PRODUCES ## Variable:L"PerfDataMemAddr" (The ACPI address of performance data)
-  gEfiUartDevicePathGuid                        ## CONSUMES ## GUID (Identify the device path for UARD device)
-  gEfiSasDevicePathGuid                         ## CONSUMES ## GUID (Identify the device path for SAS device)
-  gLastEnumLangGuid                             ## SOMETIMES_PRODUCES ## Variable:L"LastEnumLang" (Platform language at last time enumeration.)
-  gHdBootDevicePathVariablGuid                  ## SOMETIMES_PRODUCES ## Variable:L"HDDP" (The device path of Boot file on Hard device.)
-  gBdsLibStringPackageGuid                      ## PRODUCES ## GUID (HII String PackageList Guid)
+  ## SOMETIMES_CONSUMES ## HOB         # The hob holding memory type information
+  ## SOMETIMES_CONSUMES ## SystemTable # The identifier of memory type information type in system table
+  ## SOMETIMES_CONSUMES ## Variable:L"MemoryTypeInformation"
+  ## SOMETIMES_PRODUCES ## Variable:L"MemoryTypeInformation"
+  gEfiMemoryTypeInformationGuid                 
+  ## SOMETIMES_CONSUMES ## Variable:L"BootXXXX"    # Boot option variable
+  ## SOMETIMES_PRODUCES ## Variable:L"BootXXXX"    # Boot option variable
+  ## SOMETIMES_CONSUMES ## Variable:L"DriverXXXX"  # Driver load option.
+  ## SOMETIMES_PRODUCES ## Variable:L"DriverXXXX"  # Driver load option.
+  ## SOMETIMES_CONSUMES ## Variable:L"BootNext"    # Next Boot Option
+  ## SOMETIMES_PRODUCES ## Variable:L"BootNext"    # Next Boot Option
+  ## SOMETIMES_CONSUMES ## Variable:L"BootOrder"   # The boot option array
+  ## SOMETIMES_PRODUCES ## Variable:L"BootOrder"   # The boot option array
+  ## SOMETIMES_CONSUMES ## Variable:L"DriverOrder" # The driver order list
+  ## SOMETIMES_CONSUMES ## Variable:L"ConIn"       # The device path of console in device
+  ## SOMETIMES_PRODUCES ## Variable:L"ConIn"       # The device path of console in device
+  ## SOMETIMES_CONSUMES ## Variable:L"ConOut"      # The device path of console out device
+  ## SOMETIMES_PRODUCES ## Variable:L"ConOut"      # The device path of console out device
+  ## SOMETIMES_CONSUMES ## Variable:L"ErrOut"      # The device path of error out device
+  ## SOMETIMES_PRODUCES ## Variable:L"ErrOut"      # The device path of error out device
+  ## SOMETIMES_PRODUCES ## Variable:L"BootCurrent" # The boot option of current boot
+  ## SOMETIMES_PRODUCES ## Variable:L"BootNext"    # The number of next boot option
+  gEfiGlobalVariableGuid
+  gEfiFileInfoGuid                              ## SOMETIMES_CONSUMES ## GUID
+  gPerformanceProtocolGuid                      ## SOMETIMES_PRODUCES ## Variable:L"PerfDataMemAddr" # The ACPI address of performance data
+  gLastEnumLangGuid                             ## SOMETIMES_PRODUCES ## Variable:L"LastEnumLang" # Platform language at last time enumeration.
+  gHdBootDevicePathVariablGuid                  ## SOMETIMES_PRODUCES ## Variable:L"HDDP" # The device path of Boot file on Hard device.
+  gBdsLibStringPackageGuid                      ## CONSUMES ## HII # HII String PackageList Guid
+  ## SOMETIMES_PRODUCES ## Variable:L"LegacyDevOrder"
+  ## SOMETIMES_CONSUMES ## Variable:L"LegacyDevOrder"
+  gEfiLegacyDevOrderVariableGuid
+  gEdkiiStatusCodeDataTypeVariableGuid          ## SOMETIMES_CONSUMES ## GUID
 
 [Protocols]
-  gEfiSimpleFileSystemProtocolGuid              # PROTOCOL CONSUMES
-  gEfiLoadFileProtocolGuid                      # PROTOCOL CONSUMES
-  gEfiSimpleTextOutProtocolGuid                 # PROTOCOL CONSUMES
-  gEfiPciIoProtocolGuid                         # PROTOCOL CONSUMES
-  gEfiLoadedImageProtocolGuid                   # PROTOCOL CONSUMES
-  gEfiDevicePathToTextProtocolGuid              # PROTOCOL SOMETIMES_CONSUMES
-  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL CONSUMES
-  gEfiDebugPortProtocolGuid                     # PROTOCOL CONSUMES
-  gEfiSimpleTextInProtocolGuid                  # PROTOCOL CONSUMES
-  gEfiBlockIoProtocolGuid                       # PROTOCOL CONSUMES
-  gEfiFirmwareVolume2ProtocolGuid               # PROTOCOL CONSUMES
-  gEfiLegacyBiosProtocolGuid                    # PROTOCOL SOMETIMES_CONSUMES
-  gEfiCpuArchProtocolGuid                       # PROTOCOL CONSUMES
-  gEfiDevicePathProtocolGuid                    # PROTOCOL CONSUMES
-  gEfiAcpiS3SaveProtocolGuid                    # PROTOCOL CONSUMES
-  gEfiGraphicsOutputProtocolGuid                # PROTOCOL SOMETIMES_CONSUMES
-  gEfiUgaDrawProtocolGuid |gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport # PROTOCOL SOMETIMES_CONSUMES
-  gEfiOEMBadgingProtocolGuid                    # PROTOCOL CONSUMES
-  gEfiHiiFontProtocolGuid                       # PROTOCOL CONSUMES
-  gEfiUserManagerProtocolGuid                   # PROTOCOL CONSUMES
-  gEfiUsbIoProtocolGuid                         # PROTOCOL SOMETIMES_CONSUMES
-  gEfiBootLogoProtocolGuid                      # PROTOCOL SOMETIMES_CONSUMES
+  gEfiSimpleFileSystemProtocolGuid              ## SOMETIMES_CONSUMES
+  gEfiLoadFileProtocolGuid                      ## SOMETIMES_CONSUMES
+  gEfiSimpleTextOutProtocolGuid                 ## CONSUMES
+  gEfiPciIoProtocolGuid                         ## SOMETIMES_CONSUMES
+  gEfiLoadedImageProtocolGuid                   ## SOMETIMES_CONSUMES
+  gEfiSimpleNetworkProtocolGuid                 ## SOMETIMES_CONSUMES
+  gEfiDebugPortProtocolGuid                     ## SOMETIMES_CONSUMES
+  gEfiSimpleTextInProtocolGuid                  ## CONSUMES
+  gEfiBlockIoProtocolGuid                       ## SOMETIMES_CONSUMES
+  gEfiFirmwareVolume2ProtocolGuid               ## SOMETIMES_CONSUMES
+  gEfiLegacyBiosProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiCpuArchProtocolGuid                       ## CONSUMES
+  gEfiDevicePathProtocolGuid                    ## CONSUMES
+  gEfiAcpiS3SaveProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiGraphicsOutputProtocolGuid                ## SOMETIMES_CONSUMES
+  gEfiUgaDrawProtocolGuid |gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport ## SOMETIMES_CONSUMES
+  gEfiOEMBadgingProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiHiiFontProtocolGuid                       ## CONSUMES
+  gEfiUserManagerProtocolGuid                   ## SOMETIMES_CONSUMES
+  gEfiUsbIoProtocolGuid                         ## SOMETIMES_CONSUMES
+  gEfiBootLogoProtocolGuid                      ## SOMETIMES_CONSUMES
 
 [FeaturePcd]
-  gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport
-  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdBootlogoOnlyEnable
+  gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport                   ## CONSUMES
+  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdBootlogoOnlyEnable ## CONSUMES
 
 [Pcd]
-  gEfiMdeModulePkgTokenSpaceGuid.PcdResetOnMemoryTypeInformationChange
-  gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderLoad
-  gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderStart
-  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdShellFile
+  gEfiMdeModulePkgTokenSpaceGuid.PcdResetOnMemoryTypeInformationChange ## SOMETIMES_CONSUMES
+  gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderLoad  ## SOMETIMES_CONSUMES
+  gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderStart ## SOMETIMES_CONSUMES
+  gEfiMdeModulePkgTokenSpaceGuid.PcdErrorCodeSetVariable      ## CONSUMES
+  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdShellFile      ## CONSUMES
+
+#
+# [BootMode] 
+#   RECOVERY_FULL    ## SOMETIMES_CONSUMES # Memory Type Information variable
+#
 
 [BuildOptions.common]
@@ -131 +149 @@
    MSFT:*_*_*_CC_FLAGS = -DEFI_LOG_ENABLED=1
   INTEL:*_*_*_CC_FLAGS = -DEFI_LOG_ENABLED=1
+

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h

@@ -2 +2 @@
   BDS library definition, include the file and data structure
 
-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -32 +32 @@
 #include <Protocol/SimpleTextOut.h>
 #include <Protocol/SimpleNetwork.h>
-#include <Protocol/DevicePathToText.h>
 #include <Protocol/FirmwareVolume2.h>
 #include <Protocol/PciIo.h>
@@ -52 +51 @@
 #include <Guid/HdBootVariable.h>
 #include <Guid/LastEnumLang.h>
+#include <Guid/LegacyDevOrder.h>
+#include <Guid/StatusCodeDataTypeVariable.h>
 
 #include <Library/PrintLib.h>
@@ -96 +97 @@
 /**
 
-  Allocates a block of memory and writes performance data of booting into it.
-  OS can processing these record.
-  
+  Writes performance data of booting into the allocated memory.
+  OS can process these records.
+
+  @param  Event                 The triggered event.
+  @param  Context               Context for this event.
+
 **/
 VOID
+EFIAPI
 WriteBootToOsPerformanceData (
-  VOID
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
   );
 
@@ -152 +158 @@
   );
 
+/**
+  Set the variable and report the error through status code upon failure.
+
+  @param  VariableName           A Null-terminated string that is the name of the vendor's variable.
+                                 Each VariableName is unique for each VendorGuid. VariableName must
+                                 contain 1 or more characters. If VariableName is an empty string,
+                                 then EFI_INVALID_PARAMETER is returned.
+  @param  VendorGuid             A unique identifier for the vendor.
+  @param  Attributes             Attributes bitmask to set for the variable.
+  @param  DataSize               The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE, 
+                                 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, or 
+                                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero 
+                                 causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is 
+                                 set, then a SetVariable() call with a DataSize of zero will not cause any change to 
+                                 the variable value (the timestamp associated with the variable may be updated however 
+                                 even if no new data value is provided,see the description of the 
+                                 EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not 
+                                 be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated). 
+  @param  Data                   The contents for the variable.
+
+  @retval EFI_SUCCESS            The firmware has successfully stored the variable and its data as
+                                 defined by the Attributes.
+  @retval EFI_INVALID_PARAMETER  An invalid combination of attribute bits, name, and GUID was supplied, or the
+                                 DataSize exceeds the maximum allowed.
+  @retval EFI_INVALID_PARAMETER  VariableName is an empty string.
+  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.
+  @retval EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval EFI_WRITE_PROTECTED    The variable in question is read-only.
+  @retval EFI_WRITE_PROTECTED    The variable in question cannot be deleted.
+  @retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 
+                                 or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS being set, but the AuthInfo 
+                                 does NOT pass the validation check carried out by the firmware.
+
+  @retval EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.
+**/
+EFI_STATUS
+SetVariableAndReportStatusCodeOnError (
+  IN CHAR16     *VariableName,
+  IN EFI_GUID   *VendorGuid,
+  IN UINT32     Attributes,
+  IN UINTN      DataSize,
+  IN VOID       *Data
+  );
+
 #endif // _BDS_LIB_H_

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/GenericBdsLib/Performance.c

@@ -4 +4 @@
   switch is set.
 
-Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
@@ -136 +136 @@
 /**
 
-  Allocates a block of memory and writes performance data of booting into it.
-  OS can processing these record.
-  
+  Writes performance data of booting into the allocated memory.
+  OS can process these records.
+
+  @param  Event                 The triggered event.
+  @param  Context               Context for this event.
+
 **/
 VOID
+EFIAPI
 WriteBootToOsPerformanceData (
-  VOID
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
   )
 {
   EFI_STATUS                Status;
-  UINT32                    AcpiLowMemoryLength;
   UINT32                    LimitCount;
   EFI_HANDLE                *Handles;
@@ -171 +175 @@
   //
   BOOLEAN                   *PerfEntriesAsDxeHandle;
+  UINTN                     VarSize;
+
+  //
+  // Record the performance data for End of BDS
+  //
+  PERF_END(NULL, "BDS", NULL, 0);
 
   //
@@ -192 +202 @@
     mPerfHeader.BDSRaw = StartValue - Ticker;
     CountUp            = FALSE;
+  }
+
+  if (mAcpiLowMemoryBase == 0x0FFFFFFFF) {
+    VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
+    Status = gRT->GetVariable (
+                    L"PerfDataMemAddr",
+                    &gPerformanceProtocolGuid,
+                    NULL,
+                    &VarSize,
+                    &mAcpiLowMemoryBase
+                    );
+    if (EFI_ERROR (Status)) {
+      //
+      // Fail to get the variable, return.
+      //
+      return;
+    }
   }
 
@@ -209 +236 @@
   }
 
-
-  AcpiLowMemoryLength = 0x4000;
-  if (mAcpiLowMemoryBase == 0x0FFFFFFFF) {
-    //
-    // Allocate a block of memory that contain performance data to OS
-    //
-    Status = gBS->AllocatePages (
-                    AllocateMaxAddress,
-                    EfiReservedMemoryType,
-                    EFI_SIZE_TO_PAGES (AcpiLowMemoryLength),
-                    &mAcpiLowMemoryBase
-                    );
-    if (EFI_ERROR (Status)) {
-      FreePool (Handles);
-      return ;
-    }
-  }
-
-
   Ptr        = (UINT8 *) ((UINT32) mAcpiLowMemoryBase + sizeof (PERF_HEADER));
-  LimitCount = (AcpiLowMemoryLength - sizeof (PERF_HEADER)) / sizeof (PERF_DATA);
+  LimitCount = (UINT32) (PERF_DATA_MAX_LENGTH - sizeof (PERF_HEADER)) / sizeof (PERF_DATA);
 
   NumPerfEntries = 0;
@@ -347 +355 @@
     );
 
-  gRT->SetVariable (
-        L"PerfDataMemAddr",
-        &gPerformanceProtocolGuid,
-        EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
-        sizeof (EFI_PHYSICAL_ADDRESS),
-        &mAcpiLowMemoryBase
-        );
-
   return ;
 }

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf

@@ -3 +3 @@
 #
 #  It is based on the LZMA SDK 4.65.
-#  LZMA SDK 4.65 was placed in the public domain on 2009-02-03.  
+#  LZMA SDK 4.65 was placed in the public domain on 2009-02-03.
 #  It was released on the http://www.7-zip.org/sdk.html website.
 #
-#  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -21 +21 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = LzmaDecompressLib
+  MODULE_UNI_FILE                = LzmaDecompressLib.uni
   FILE_GUID                      = 35194660-7421-44ad-9636-e44885f092d1
   MODULE_TYPE                    = BASE
@@ -49 +50 @@
 [Packages]
   MdePkg/MdePkg.dec
-  IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
 
 [Guids]
-  gLzmaCustomDecompressGuid  ## PRODUCED  ## GUID specifies LZMA custom decompress algorithm.
+  gLzmaCustomDecompressGuid  ## PRODUCES  ## UNDEFINED # specifies LZMA custom decompress algorithm.
 
 [LibraryClasses]

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/DebugLib.c

@@ -5 +5 @@
   record length, then the debug message will be ignored directly.
 
-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
@@ -16 +16 @@
 **/
 
-#include <FrameworkPei.h>
+#include <PiPei.h>
 
 #include <Guid/StatusCodeDataTypeId.h>
@@ -259 +259 @@
   UINT64                 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE / sizeof(UINT64)];
   EFI_DEBUG_ASSERT_DATA  *AssertData;
+  UINTN                  HeaderSize;
   UINTN                  TotalSize;
   CHAR8                  *Temp;
@@ -265 +266 @@
 
   //
-  // Make sure it will all fit in the passed in buffer
-  //
-  FileNameSize    = AsciiStrSize (FileName);
-  DescriptionSize = AsciiStrSize (Description);
-  TotalSize = sizeof (EFI_DEBUG_ASSERT_DATA) + FileNameSize + DescriptionSize;
-  if (TotalSize <= sizeof (Buffer)) {
-    //
-    // Fill in EFI_DEBUG_ASSERT_DATA
-    //
-    AssertData = (EFI_DEBUG_ASSERT_DATA *)Buffer;
-    AssertData->LineNumber = (UINT32)LineNumber;
-
-    //
-    // Copy Ascii FileName including NULL.
-    //
-    Temp = AsciiStrCpy ((CHAR8 *)(AssertData + 1), FileName);
-
-    //
-    // Copy Ascii Description
-    //
-    AsciiStrCpy (Temp + FileNameSize, Description);
-
-    REPORT_STATUS_CODE_EX (
-      (EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
-      (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
-      0,
-      NULL,
-      NULL,
-      AssertData,
-      TotalSize
-      );
+  // Get string size
+  //
+  HeaderSize       = sizeof (EFI_DEBUG_ASSERT_DATA);
+  FileNameSize     = AsciiStrSize (FileName);
+  DescriptionSize  = AsciiStrSize (Description);
+
+  //
+  // Make sure it will all fit in the passed in buffer.
+  //
+  if (HeaderSize + FileNameSize + DescriptionSize > sizeof (Buffer)) {
+    //
+    // FileName + Description is too long to be filled into buffer. 
+    //
+    if (HeaderSize + FileNameSize < sizeof (Buffer)) {
+      //
+      // Description has enough buffer to be truncated. 
+      //
+      DescriptionSize = sizeof (Buffer) - HeaderSize - FileNameSize;
+    } else {
+      //
+      // FileName is too long to be filled into buffer.
+      // FileName will be truncated. Reserved one byte for Description NULL terminator.
+      //
+      DescriptionSize = 1;
+      FileNameSize    = sizeof (Buffer) - HeaderSize - DescriptionSize;
+    }
   }
+ 
+  //
+  // Fill in EFI_DEBUG_ASSERT_DATA
+  //
+  AssertData = (EFI_DEBUG_ASSERT_DATA *)Buffer;
+  AssertData->LineNumber = (UINT32)LineNumber;
+  TotalSize  = sizeof (EFI_DEBUG_ASSERT_DATA);
+
+  //
+  // Copy Ascii FileName including NULL terminator.
+  //
+  Temp = CopyMem (AssertData + 1, FileName, FileNameSize);
+  Temp[FileNameSize - 1] = 0;
+  TotalSize += FileNameSize;
+
+  //
+  // Copy Ascii Description include NULL terminator.
+  //
+  Temp = CopyMem (Temp + FileNameSize, Description, DescriptionSize);
+  Temp[DescriptionSize - 1] = 0;
+  TotalSize += DescriptionSize;
+
+  REPORT_STATUS_CODE_EX (
+    (EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
+    (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
+    0,
+    NULL,
+    NULL,
+    AssertData,
+    TotalSize
+    );
 
   //
@@ -415 +442 @@
   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
 }
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
+}

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/PeiDxeDebugLibReportStatusCode.inf

@@ -3 +3 @@
 #
 #  Debug Library for PEIMs and DXE drivers that sends debug messages to ReportStatusCode
-#  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -18 +18 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = PeiDxeDebugLibReportStatusCode
+  MODULE_UNI_FILE                = PeiDxeDebugLibReportStatusCode.uni
   FILE_GUID                      = bda39d3a-451b-4350-8266-81ab10fa0523
   MODULE_TYPE                    = PEIM
@@ -36 +37 @@
   MdePkg/MdePkg.dec
   MdeModulePkg/MdeModulePkg.dec
-  IntelFrameworkPkg/IntelFrameworkPkg.dec
-  IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
   
 [LibraryClasses]
@@ -47 +46 @@
 
 [Pcd]
-  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue  ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask      ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel ## CONSUMES
 
 [Guids]
-  gEfiStatusCodeDataTypeDebugGuid    ## CONSUMES
-  
-  
+  gEfiStatusCodeDataTypeDebugGuid    ## SOMETIMES_CONSUMES ## GUID
+

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/PeiRecoveryLib/PeiRecoveryLib.inf

@@ -6 +6 @@
 #  in PI 1.2 specification. 
 #
-#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -21 +21 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = PeiRecoveryLib
+  MODULE_UNI_FILE                = PeiRecoveryLib.uni
   FILE_GUID                      = C0227547-0811-4cbb-ABEA-DECD22829122
   MODULE_TYPE                    = PEIM

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/PeiS3Lib/PeiS3Lib.inf

@@ -1 +1 @@
 ## @file
+#  This library provides API to invoke the S3 resume vector in the ACPI Table in S3 resume mode.
 #
-#  This library provides API to invoke the S3 resume vector in the APCI Table in S3 resume mode. 
 #  This library instance is no longer used and module using this library
 #  class should update to directly locate EFI_PEI_S3_RESUME_PPI defined
 #  in PI 1.2 specification. 
 #
-#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -21 +21 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = PeiS3Lib
+  MODULE_UNI_FILE                = PeiS3Lib.uni
   FILE_GUID                      = EFB7D3A8-DEB9-4bed-B6D6-3B09BEEB835A
   MODULE_TYPE                    = PEIM
@@ -45 +46 @@
 
 [Ppis]
-  gEfiPeiS3ResumePpiGuid                # ALWAYS_CONSUMES
+  gEfiPeiS3ResumePpiGuid                ## CONSUMES
 
-

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf

@@ -1 +1 @@
 ## @file
+#  NULL implementation for PlatformBdsLib library class interfaces.
 #  
-#  Provide NULL implementation for PlatformBdsLib library class interfaces which
-#  should be implemented by OEM.
-#  
-#  Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 #  are licensed and made available under the terms and conditions of the BSD License
@@ -18 +16 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = PlatformBdsLib
+  MODULE_UNI_FILE                = PlatformBdsLib.uni
   FILE_GUID                      = 143B5044-7C1B-4904-9778-EA16F1F3D554
   MODULE_TYPE                    = DXE_DRIVER

trunk/src/VBox/Devices/EFI/Firmware/IntelFrameworkModulePkg/Library/SmmRuntimeDxeReportStatusCodeLibFramework/SmmRuntimeDxeReportStatusCodeLibFramework.inf

@@ -1 +1 @@
 ## @file
-#  Report status code library instance which supports logging message in SMM, as well as DXE & runtime phase.
+#  Framework Report status code library instance which supports logging message in SMM, as well as DXE & runtime phase.
 #
 #  This library instance supports status code report in SMM, as well as DXE & runtime phase.
@@ -6 +6 @@
 #  Otherwise, it logs message to ReportStatusCode() in framework runtime services table or runtime report status code protocol.
 #
-#  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #
 #  This program and the accompanying materials
@@ -21 +21 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = SmmRuntimeDxeReportStatusCodeLibFramework
+  MODULE_UNI_FILE                = SmmRuntimeDxeReportStatusCodeLibFramework.uni
   FILE_GUID                      = D65D9F72-7BCE-4f73-A673-47AF446A1A31
   MODULE_TYPE                    = DXE_RUNTIME_DRIVER
@@ -57 +58 @@
 
 [Guids]
-  gEfiStatusCodeSpecificDataGuid                ## CONSUMES
-  gEfiStatusCodeDataTypeDebugGuid               ## CONSUMES
+  gEfiStatusCodeSpecificDataGuid                ## SOMETIMES_CONSUMES ## UNDEFINED
+  gEfiStatusCodeDataTypeDebugGuid               ## SOMETIMES_CONSUMES ## UNDEFINED
   gEfiEventExitBootServicesGuid                 ## CONSUMES ## Event
   gEfiEventVirtualAddressChangeGuid             ## CONSUMES ## Event
@@ -64 +65 @@
 
 [Protocols]
-  gEfiStatusCodeRuntimeProtocolGuid             ## CONSUMES
-  gEfiSmmBaseProtocolGuid                       ## CONSUMES
-  gEfiSmmStatusCodeProtocolGuid                 ## CONSUMES
+  gEfiStatusCodeRuntimeProtocolGuid             ## SOMETIMES_CONSUMES
+  gEfiSmmBaseProtocolGuid                       ## SOMETIMES_CONSUMES
+  gEfiSmmStatusCodeProtocolGuid                 ## SOMETIMES_CONSUMES
 
 [Pcd]
-  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask
+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask ## CONSUMES