MdeModulePkg/Application/CapsuleApp/CapsuleDump.c

   1 /** @file
   2   Dump Capsule image information.
   3
   4   Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <PiDxe.h>
  16 #include <Library/BaseLib.h>
  17 #include <Library/DebugLib.h>
  18 #include <Library/BaseMemoryLib.h>
  19 #include <Library/MemoryAllocationLib.h>
  20 #include <Library/UefiBootServicesTableLib.h>
  21 #include <Library/UefiRuntimeServicesTableLib.h>
  22 #include <Library/UefiLib.h>
  23 #include <Library/PrintLib.h>
  24 #include <Library/FileHandleLib.h>
  25 #include <Library/SortLib.h>
  26 #include <Library/UefiBootManagerLib.h>
  27 #include <Library/DevicePathLib.h>
  28 #include <Protocol/FirmwareManagement.h>
  29 #include <Protocol/SimpleFileSystem.h>
  30 #include <Protocol/Shell.h>
  31 #include <Guid/ImageAuthentication.h>
  32 #include <Guid/CapsuleReport.h>
  33 #include <Guid/SystemResourceTable.h>
  34 #include <Guid/FmpCapsule.h>
  35 #include <Guid/CapsuleVendor.h>
  36 #include <IndustryStandard/WindowsUxCapsule.h>
  37
  38 //
  39 // (20 * (6+5+2))+1) unicode characters from EFI FAT spec (doubled for bytes)
  40 //
  41 #define MAX_FILE_NAME_SIZE   522
  42 #define MAX_FILE_NAME_LEN    (MAX_FILE_NAME_SIZE / sizeof(CHAR16))
  43
  44 /**
  45   Read a file.
  46
  47   @param[in]  FileName        The file to be read.
  48   @param[out] BufferSize      The file buffer size
  49   @param[out] Buffer          The file buffer
  50
  51   @retval EFI_SUCCESS    Read file successfully
  52   @retval EFI_NOT_FOUND  File not found
  53 **/
  54 EFI_STATUS
  55 ReadFileToBuffer (
  56   IN  CHAR16                               *FileName,
  57   OUT UINTN                                *BufferSize,
  58   OUT VOID                                 **Buffer
  59   );
  60
  61 /**
  62   Write a file.
  63
  64   @param[in] FileName        The file to be written.
  65   @param[in] BufferSize      The file buffer size
  66   @param[in] Buffer          The file buffer
  67
  68   @retval EFI_SUCCESS    Write file successfully
  69 **/
  70 EFI_STATUS
  71 WriteFileFromBuffer (
  72   IN  CHAR16                               *FileName,
  73   IN  UINTN                                BufferSize,
  74   IN  VOID                                 *Buffer
  75   );
  76
  77 /**
  78   Get shell protocol.
  79
  80   @return Pointer to shell protocol.
  81
  82 **/
  83 EFI_SHELL_PROTOCOL *
  84 GetShellProtocol (
  85   VOID
  86   );
  87
  88 /**
  89   Get SimpleFileSystem from boot option file path.
  90
  91   @param[in]  DevicePath     The file path of boot option
  92   @param[out] FullPath       The full device path of boot device
  93   @param[out] Fs             The file system within EfiSysPartition
  94
  95   @retval EFI_SUCCESS    Get file system successfully
  96   @retval EFI_NOT_FOUND  No valid file system found
  97   @retval others         Get file system failed
  98
  99 **/
 100 EFI_STATUS
 101 EFIAPI
 102 GetEfiSysPartitionFromBootOptionFilePath (
 103   IN  EFI_DEVICE_PATH_PROTOCOL         *DevicePath,
 104   OUT EFI_DEVICE_PATH_PROTOCOL         **FullPath,
 105   OUT EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  **Fs
 106   );
 107
 108 /**
 109   Validate if it is valid capsule header
 110
 111   This function assumes the caller provided correct CapsuleHeader pointer
 112   and CapsuleSize.
 113
 114   This function validates the fields in EFI_CAPSULE_HEADER.
 115
 116   @param[in] CapsuleHeader  Points to a capsule header.
 117   @param[in] CapsuleSize    Size of the whole capsule image.
 118
 119 **/
 120 BOOLEAN
 121 IsValidCapsuleHeader (
 122   IN EFI_CAPSULE_HEADER     *CapsuleHeader,
 123   IN UINT64                 CapsuleSize
 124   );
 125
 126 /**
 127   Dump UX capsule information.
 128
 129   @param[in] CapsuleHeader      The UX capsule header
 130 **/
 131 VOID
 132 DumpUxCapsule (
 133   IN EFI_CAPSULE_HEADER  *CapsuleHeader
 134   )
 135 {
 136   EFI_DISPLAY_CAPSULE                           *DisplayCapsule;
 137   DisplayCapsule = (EFI_DISPLAY_CAPSULE *)CapsuleHeader;
 138   Print(L"[UxCapusule]\n");
 139   Print(L"CapsuleHeader:\n");
 140   Print(L"  CapsuleGuid      - %g\n", &DisplayCapsule->CapsuleHeader.CapsuleGuid);
 141   Print(L"  HeaderSize       - 0x%x\n", DisplayCapsule->CapsuleHeader.HeaderSize);
 142   Print(L"  Flags            - 0x%x\n", DisplayCapsule->CapsuleHeader.Flags);
 143   Print(L"  CapsuleImageSize - 0x%x\n", DisplayCapsule->CapsuleHeader.CapsuleImageSize);
 144   Print(L"ImagePayload:\n");
 145   Print(L"  Version          - 0x%x\n", DisplayCapsule->ImagePayload.Version);
 146   Print(L"  Checksum         - 0x%x\n", DisplayCapsule->ImagePayload.Checksum);
 147   Print(L"  ImageType        - 0x%x\n", DisplayCapsule->ImagePayload.ImageType);
 148   Print(L"  Mode             - 0x%x\n", DisplayCapsule->ImagePayload.Mode);
 149   Print(L"  OffsetX          - 0x%x\n", DisplayCapsule->ImagePayload.OffsetX);
 150   Print(L"  OffsetY          - 0x%x\n", DisplayCapsule->ImagePayload.OffsetY);
 151 }
 152
 153
 154 /**
 155   Dump a non-nested FMP capsule.
 156
 157   @param[in]  CapsuleHeader  A pointer to CapsuleHeader
 158 **/
 159 VOID
 160 DumpFmpCapsule (
 161   IN EFI_CAPSULE_HEADER  *CapsuleHeader
 162   )
 163 {
 164   EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER        *FmpCapsuleHeader;
 165   UINT64                                        *ItemOffsetList;
 166   UINTN                                         Index;
 167   UINTN                                         Count;
 168   EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *FmpImageHeader;
 169
 170   Print(L"[FmpCapsule]\n");
 171   Print(L"CapsuleHeader:\n");
 172   Print(L"  CapsuleGuid      - %g\n", &CapsuleHeader->CapsuleGuid);
 173   Print(L"  HeaderSize       - 0x%x\n", CapsuleHeader->HeaderSize);
 174   Print(L"  Flags            - 0x%x\n", CapsuleHeader->Flags);
 175   Print(L"  CapsuleImageSize - 0x%x\n", CapsuleHeader->CapsuleImageSize);
 176
 177   FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
 178   ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
 179   Print(L"FmpHeader:\n");
 180   Print(L"  Version             - 0x%x\n", FmpCapsuleHeader->Version);
 181   Print(L"  EmbeddedDriverCount - 0x%x\n", FmpCapsuleHeader->EmbeddedDriverCount);
 182   Print(L"  PayloadItemCount    - 0x%x\n", FmpCapsuleHeader->PayloadItemCount);
 183   Count = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
 184   for (Index = 0; Index < Count; Index++) {
 185     Print(L"  Offset[%d]           - 0x%x\n", Index, ItemOffsetList[Index]);
 186   }
 187
 188   for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < Count; Index++) {
 189     Print(L"FmpPayload[%d] ImageHeader:\n", Index);
 190     FmpImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
 191     Print(L"  Version                - 0x%x\n", FmpImageHeader->Version);
 192     Print(L"  UpdateImageTypeId      - %g\n", &FmpImageHeader->UpdateImageTypeId);
 193     Print(L"  UpdateImageIndex       - 0x%x\n", FmpImageHeader->UpdateImageIndex);
 194     Print(L"  UpdateImageSize        - 0x%x\n", FmpImageHeader->UpdateImageSize);
 195     Print(L"  UpdateVendorCodeSize   - 0x%x\n", FmpImageHeader->UpdateVendorCodeSize);
 196     if (FmpImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {
 197       Print(L"  UpdateHardwareInstance - 0x%lx\n", FmpImageHeader->UpdateHardwareInstance);
 198     }
 199   }
 200 }
 201
 202 /**
 203   Return if there is a FMP header below capsule header.
 204
 205   @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER
 206
 207   @retval TRUE  There is a FMP header below capsule header.
 208   @retval FALSE There is not a FMP header below capsule header
 209 **/
 210 BOOLEAN
 211 IsNestedFmpCapsule (
 212   IN EFI_CAPSULE_HEADER         *CapsuleHeader
 213   )
 214 {
 215   EFI_STATUS                 Status;
 216   EFI_SYSTEM_RESOURCE_TABLE  *Esrt;
 217   EFI_SYSTEM_RESOURCE_ENTRY  *EsrtEntry;
 218   UINTN                      Index;
 219   BOOLEAN                    EsrtGuidFound;
 220   EFI_CAPSULE_HEADER         *NestedCapsuleHeader;
 221   UINTN                      NestedCapsuleSize;
 222
 223   //
 224   // Check ESRT
 225   //
 226   EsrtGuidFound = FALSE;
 227   Status = EfiGetSystemConfigurationTable(&gEfiSystemResourceTableGuid, (VOID **)&Esrt);
 228   if (!EFI_ERROR(Status)) {
 229     ASSERT (Esrt != NULL);
 230     EsrtEntry = (VOID *)(Esrt + 1);
 231     for (Index = 0; Index < Esrt->FwResourceCount; Index++, EsrtEntry++) {
 232       if (CompareGuid(&EsrtEntry->FwClass, &CapsuleHeader->CapsuleGuid)) {
 233         EsrtGuidFound = TRUE;
 234         break;
 235       }
 236     }
 237   }
 238
 239   if (!EsrtGuidFound) {
 240     return FALSE;
 241   }
 242
 243   //
 244   // Check nested capsule header
 245   // FMP GUID after ESRT one
 246   //
 247   NestedCapsuleHeader = (EFI_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
 248   NestedCapsuleSize = (UINTN)CapsuleHeader + CapsuleHeader->CapsuleImageSize- (UINTN)NestedCapsuleHeader;
 249   if (NestedCapsuleSize < sizeof(EFI_CAPSULE_HEADER)) {
 250     return FALSE;
 251   }
 252   if (!CompareGuid(&NestedCapsuleHeader->CapsuleGuid, &gEfiFmpCapsuleGuid)) {
 253     return FALSE;
 254   }
 255   return TRUE;
 256 }
 257
 258 /**
 259   Dump capsule information
 260
 261   @param[in] CapsuleName  The name of the capsule image.
 262
 263   @retval EFI_SUCCESS            The capsule information is dumped.
 264   @retval EFI_UNSUPPORTED        Input parameter is not valid.
 265 **/
 266 EFI_STATUS
 267 DumpCapsule (
 268   IN CHAR16                                        *CapsuleName
 269   )
 270 {
 271   VOID                                          *Buffer;
 272   UINTN                                         FileSize;
 273   EFI_CAPSULE_HEADER                            *CapsuleHeader;
 274   EFI_STATUS                                    Status;
 275
 276   Buffer = NULL;
 277   Status = ReadFileToBuffer(CapsuleName, &FileSize, &Buffer);
 278   if (EFI_ERROR(Status)) {
 279     Print(L"CapsuleApp: Capsule (%s) is not found.\n", CapsuleName);
 280     goto Done;
 281   }
 282   if (!IsValidCapsuleHeader (Buffer, FileSize)) {
 283     Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);
 284     Status = EFI_INVALID_PARAMETER;
 285     goto Done;
 286   }
 287
 288   CapsuleHeader = Buffer;
 289   if (CompareGuid(&CapsuleHeader->CapsuleGuid, &gWindowsUxCapsuleGuid)) {
 290     DumpUxCapsule(CapsuleHeader);
 291     Status = EFI_SUCCESS;
 292     goto Done;
 293   }
 294
 295   if (CompareGuid(&CapsuleHeader->CapsuleGuid, &gEfiFmpCapsuleGuid)) {
 296     DumpFmpCapsule(CapsuleHeader);
 297   }
 298   if (IsNestedFmpCapsule(CapsuleHeader)) {
 299     Print(L"[NestedCapusule]\n");
 300     Print(L"CapsuleHeader:\n");
 301     Print(L"  CapsuleGuid      - %g\n", &CapsuleHeader->CapsuleGuid);
 302     Print(L"  HeaderSize       - 0x%x\n", CapsuleHeader->HeaderSize);
 303     Print(L"  Flags            - 0x%x\n", CapsuleHeader->Flags);
 304     Print(L"  CapsuleImageSize - 0x%x\n", CapsuleHeader->CapsuleImageSize);
 305     DumpFmpCapsule((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize));
 306   }
 307
 308 Done:
 309   if (Buffer != NULL) {
 310     FreePool(Buffer);
 311   }
 312   return Status;
 313 }
 314
 315 /**
 316   Dump capsule status variable.
 317
 318   @retval EFI_SUCCESS            The capsule status variable is dumped.
 319   @retval EFI_UNSUPPORTED        Input parameter is not valid.
 320 **/
 321 EFI_STATUS
 322 DumpCapsuleStatusVariable (
 323   VOID
 324   )
 325 {
 326   EFI_STATUS                          Status;
 327   UINT32                              Index;
 328   CHAR16                              CapsuleVarName[20];
 329   CHAR16                              *TempVarName;
 330   EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResult;
 331   EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultFmp;
 332   UINTN                               CapsuleFileNameSize;
 333   CHAR16                              CapsuleIndexData[12];
 334   CHAR16                              *CapsuleIndex;
 335   CHAR16                              *CapsuleFileName;
 336   CHAR16                              *CapsuleTarget;
 337
 338   Status = GetVariable2(
 339              L"CapsuleMax",
 340              &gEfiCapsuleReportGuid,
 341              (VOID **)&CapsuleIndex,
 342              NULL
 343              );
 344   if (!EFI_ERROR(Status)) {
 345     ASSERT (CapsuleIndex != NULL);
 346     CopyMem(CapsuleIndexData, CapsuleIndex, 11 * sizeof(CHAR16));
 347     CapsuleIndexData[11] = 0;
 348     Print(L"CapsuleMax - %s\n", CapsuleIndexData);
 349     FreePool(CapsuleIndex);
 350   }
 351   Status = GetVariable2(
 352              L"CapsuleLast",
 353              &gEfiCapsuleReportGuid,
 354              (VOID **)&CapsuleIndex,
 355              NULL
 356              );
 357   if (!EFI_ERROR(Status)) {
 358     ASSERT (CapsuleIndex != NULL);
 359     CopyMem(CapsuleIndexData, CapsuleIndex, 11 * sizeof(CHAR16));
 360     CapsuleIndexData[11] = 0;
 361     Print(L"CapsuleLast - %s\n", CapsuleIndexData);
 362     FreePool(CapsuleIndex);
 363   }
 364
 365
 366   StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), L"Capsule");
 367   TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
 368   Index = 0;
 369
 370   while (TRUE) {
 371     UnicodeSPrint (TempVarName, 5 * sizeof(CHAR16), L"%04x", Index);
 372
 373     Status = GetVariable2 (
 374                CapsuleVarName,
 375                &gEfiCapsuleReportGuid,
 376                (VOID **) &CapsuleResult,
 377                NULL
 378                );
 379     if (Status == EFI_NOT_FOUND) {
 380       break;
 381     } else if (EFI_ERROR(Status)) {
 382       continue;
 383     }
 384     ASSERT (CapsuleResult != NULL);
 385
 386     //
 387     // display capsule process status
 388     //
 389     if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER)) {
 390       Print (L"CapsuleName: %s\n", CapsuleVarName);
 391       Print (L"  Capsule Guid: %g\n", &CapsuleResult->CapsuleGuid);
 392       Print (L"  Capsule ProcessedTime: %t\n", &CapsuleResult->CapsuleProcessed);
 393       Print (L"  Capsule Status: %r\n", CapsuleResult->CapsuleStatus);
 394     }
 395
 396     if (CompareGuid(&CapsuleResult->CapsuleGuid, &gEfiFmpCapsuleGuid)) {
 397       if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP) + sizeof(CHAR16) * 2) {
 398         CapsuleResultFmp = (EFI_CAPSULE_RESULT_VARIABLE_FMP *)(CapsuleResult + 1);
 399         Print(L"  Capsule FMP Version: 0x%x\n", CapsuleResultFmp->Version);
 400         Print(L"  Capsule FMP PayloadIndex: 0x%x\n", CapsuleResultFmp->PayloadIndex);
 401         Print(L"  Capsule FMP UpdateImageIndex: 0x%x\n", CapsuleResultFmp->UpdateImageIndex);
 402         Print(L"  Capsule FMP UpdateImageTypeId: %g\n", &CapsuleResultFmp->UpdateImageTypeId);
 403         CapsuleFileName = (CHAR16 *)(CapsuleResultFmp + 1);
 404         Print(L"  Capsule FMP CapsuleFileName: \"%s\"\n", CapsuleFileName);
 405         CapsuleFileNameSize = StrSize(CapsuleFileName);
 406         CapsuleTarget = (CHAR16 *)((UINTN)CapsuleFileName + CapsuleFileNameSize);
 407         Print(L"  Capsule FMP CapsuleTarget: \"%s\"\n", CapsuleTarget);
 408       }
 409     }
 410
 411     FreePool(CapsuleResult);
 412
 413     Index++;
 414     if (Index > 0xFFFF) {
 415       break;
 416     }
 417   }
 418
 419   return EFI_SUCCESS;
 420 }
 421
 422 CHAR8 *mFwTypeString[] = {
 423   "Unknown",
 424   "SystemFirmware",
 425   "DeviceFirmware",
 426   "UefiDriver",
 427 };
 428
 429 CHAR8 *mLastAttemptStatusString[] = {
 430   "Success",
 431   "Error: Unsuccessful",
 432   "Error: Insufficient Resources",
 433   "Error: Incorrect Version",
 434   "Error: Invalid Format",
 435   "Error: Auth Error",
 436   "Error: Power Event AC",
 437   "Error: Power Event Battery",
 438 };
 439
 440 /**
 441   Convert FwType to a string.
 442
 443   @param[in] FwType  FwType in ESRT
 444
 445   @return a string for FwType.
 446 **/
 447 CHAR8 *
 448 FwTypeToString (
 449   IN UINT32  FwType
 450   )
 451 {
 452   if (FwType < sizeof(mFwTypeString) / sizeof(mFwTypeString[0])) {
 453     return mFwTypeString[FwType];
 454   } else {
 455     return "Invalid";
 456   }
 457 }
 458
 459 /**
 460   Convert LastAttemptStatus to a string.
 461
 462   @param[in] LastAttemptStatus  LastAttemptStatus in FMP or ESRT
 463
 464   @return a string for LastAttemptStatus.
 465 **/
 466 CHAR8 *
 467 LastAttemptStatusToString (
 468   IN UINT32  LastAttemptStatus
 469   )
 470 {
 471   if (LastAttemptStatus < sizeof(mLastAttemptStatusString) / sizeof(mLastAttemptStatusString[0])) {
 472     return mLastAttemptStatusString[LastAttemptStatus];
 473   } else {
 474     return "Error: Unknown";
 475   }
 476 }
 477
 478 /**
 479   Dump ESRT entry.
 480
 481   @param[in] EsrtEntry  ESRT entry
 482 **/
 483 VOID
 484 DumpEsrtEntry (
 485   IN EFI_SYSTEM_RESOURCE_ENTRY  *EsrtEntry
 486   )
 487 {
 488   Print(L"  FwClass                  - %g\n", &EsrtEntry->FwClass);
 489   Print(L"  FwType                   - 0x%x (%a)\n", EsrtEntry->FwType, FwTypeToString(EsrtEntry->FwType));
 490   Print(L"  FwVersion                - 0x%x\n", EsrtEntry->FwVersion);
 491   Print(L"  LowestSupportedFwVersion - 0x%x\n", EsrtEntry->LowestSupportedFwVersion);
 492   Print(L"  CapsuleFlags             - 0x%x\n", EsrtEntry->CapsuleFlags);
 493   Print(L"  LastAttemptVersion       - 0x%x\n", EsrtEntry->LastAttemptVersion);
 494   Print(L"  LastAttemptStatus        - 0x%x (%a)\n", EsrtEntry->LastAttemptStatus, LastAttemptStatusToString(EsrtEntry->LastAttemptStatus));
 495 }
 496
 497 /**
 498   Dump ESRT table.
 499
 500   @param[in] Esrt  ESRT table
 501 **/
 502 VOID
 503 DumpEsrt (
 504   IN EFI_SYSTEM_RESOURCE_TABLE  *Esrt
 505   )
 506 {
 507   UINTN                      Index;
 508   EFI_SYSTEM_RESOURCE_ENTRY  *EsrtEntry;
 509
 510   if (Esrt == NULL) {
 511     return ;
 512   }
 513
 514   Print(L"EFI_SYSTEM_RESOURCE_TABLE:\n");
 515   Print(L"FwResourceCount    - 0x%x\n", Esrt->FwResourceCount);
 516   Print(L"FwResourceCountMax - 0x%x\n", Esrt->FwResourceCountMax);
 517   Print(L"FwResourceVersion  - 0x%lx\n", Esrt->FwResourceVersion);
 518
 519   EsrtEntry = (VOID *)(Esrt + 1);
 520   for (Index = 0; Index < Esrt->FwResourceCount; Index++) {
 521     Print(L"EFI_SYSTEM_RESOURCE_ENTRY (%d):\n", Index);
 522     DumpEsrtEntry(EsrtEntry);
 523     EsrtEntry++;
 524   }
 525 }
 526
 527 /**
 528   Dump ESRT info.
 529 **/
 530 VOID
 531 DumpEsrtData (
 532   VOID
 533   )
 534 {
 535   EFI_STATUS                 Status;
 536   EFI_SYSTEM_RESOURCE_TABLE  *Esrt;
 537
 538   Print(L"##############\n");
 539   Print(L"# ESRT TABLE #\n");
 540   Print(L"##############\n");
 541
 542   Status = EfiGetSystemConfigurationTable (&gEfiSystemResourceTableGuid, (VOID **)&Esrt);
 543   if (EFI_ERROR(Status)) {
 544     Print(L"ESRT - %r\n", Status);
 545     return;
 546   }
 547   DumpEsrt(Esrt);
 548   Print(L"\n");
 549 }
 550
 551
 552 /**
 553   Dump capsule information from CapsuleHeader
 554
 555   @param[in] CapsuleHeader       The CapsuleHeader of the capsule image.
 556
 557   @retval EFI_SUCCESS            The capsule information is dumped.
 558
 559 **/
 560 EFI_STATUS
 561 DumpCapsuleFromBuffer (
 562   IN EFI_CAPSULE_HEADER                         *CapsuleHeader
 563   )
 564 {
 565   if (CompareGuid (&CapsuleHeader->CapsuleGuid, &gWindowsUxCapsuleGuid)) {
 566     DumpUxCapsule (CapsuleHeader);
 567     return EFI_SUCCESS;
 568   }
 569
 570   if (CompareGuid (&CapsuleHeader->CapsuleGuid, &gEfiFmpCapsuleGuid)) {
 571     DumpFmpCapsule (CapsuleHeader);
 572   }
 573   if (IsNestedFmpCapsule (CapsuleHeader)) {
 574     Print (L"[NestedCapusule]\n");
 575     Print (L"CapsuleHeader:\n");
 576     Print (L"  CapsuleGuid      - %g\n", &CapsuleHeader->CapsuleGuid);
 577     Print (L"  HeaderSize       - 0x%x\n", CapsuleHeader->HeaderSize);
 578     Print (L"  Flags            - 0x%x\n", CapsuleHeader->Flags);
 579     Print (L"  CapsuleImageSize - 0x%x\n", CapsuleHeader->CapsuleImageSize);
 580     DumpFmpCapsule ((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize));
 581   }
 582
 583   return EFI_SUCCESS;
 584 }
 585
 586 /**
 587   This routine is called to upper case given unicode string.
 588
 589   @param[in]   Str              String to upper case
 590
 591   @retval upper cased string after process
 592
 593 **/
 594 STATIC
 595 CHAR16 *
 596 UpperCaseString (
 597   IN CHAR16 *Str
 598   )
 599 {
 600   CHAR16  *Cptr;
 601
 602   for (Cptr = Str; *Cptr != L'\0'; Cptr++) {
 603     if (L'a' <= *Cptr && *Cptr <= L'z') {
 604       *Cptr = *Cptr - L'a' + L'A';
 605     }
 606   }
 607
 608   return Str;
 609 }
 610
 611 /**
 612   This routine is used to return substring before period '.' or '\0'
 613   Caller should respsonsible of substr space allocation & free
 614
 615   @param[in]   Str              String to check
 616   @param[out]  SubStr           First part of string before period or '\0'
 617   @param[out]  SubStrLen        Length of first part of string
 618
 619 **/
 620 STATIC
 621 VOID
 622 GetSubStringBeforePeriod (
 623   IN  CHAR16 *Str,
 624   OUT CHAR16 *SubStr,
 625   OUT UINTN  *SubStrLen
 626   )
 627 {
 628   UINTN Index;
 629   for (Index = 0; Str[Index] != L'.' && Str[Index] != L'\0'; Index++) {
 630     SubStr[Index] = Str[Index];
 631   }
 632
 633   SubStr[Index] = L'\0';
 634   *SubStrLen = Index;
 635 }
 636
 637 /**
 638   This routine pad the string in tail with input character.
 639
 640   @param[in]   StrBuf            Str buffer to be padded, should be enough room for
 641   @param[in]   PadLen            Expected padding length
 642   @param[in]   Character         Character used to pad
 643
 644 **/
 645 STATIC
 646 VOID
 647 PadStrInTail (
 648   IN CHAR16   *StrBuf,
 649   IN UINTN    PadLen,
 650   IN CHAR16   Character
 651   )
 652 {
 653   UINTN Index;
 654
 655   for (Index = 0; StrBuf[Index] != L'\0'; Index++);
 656
 657   while(PadLen != 0) {
 658     StrBuf[Index] = Character;
 659     Index++;
 660     PadLen--;
 661   }
 662
 663   StrBuf[Index] = L'\0';
 664 }
 665
 666 /**
 667   This routine find the offset of the last period '.' of string. if No period exists
 668   function FileNameExtension is set to L'\0'
 669
 670   @param[in]   FileName           File name to split between last period
 671   @param[out]  FileNameFirst      First FileName before last period
 672   @param[out]  FileNameExtension  FileName after last period
 673
 674 **/
 675 STATIC
 676 VOID
 677 SplitFileNameExtension (
 678   IN  CHAR16  *FileName,
 679   OUT CHAR16  *FileNameFirst,
 680   OUT CHAR16  *FileNameExtension
 681   )
 682 {
 683   UINTN Index;
 684   UINTN StringLen;
 685
 686   StringLen = StrLen(FileName);
 687   for (Index = StringLen; Index > 0 && FileName[Index] != L'.'; Index--);
 688
 689   //
 690   // No period exists. No FileName Extension
 691   //
 692   if (Index == 0 && FileName[Index] != L'.') {
 693     FileNameExtension[0] = L'\0';
 694     Index = StringLen;
 695   } else {
 696     StrCpyS (FileNameExtension, MAX_FILE_NAME_LEN, &FileName[Index+1]);
 697   }
 698
 699   //
 700   // Copy First file name
 701   //
 702   StrnCpyS (FileNameFirst, MAX_FILE_NAME_LEN, FileName, Index);
 703   FileNameFirst[Index] = L'\0';
 704 }
 705
 706 /**
 707   The function is called by PerformQuickSort to sort file name in alphabet.
 708
 709   @param[in] Left            The pointer to first buffer.
 710   @param[in] Right           The pointer to second buffer.
 711
 712   @retval 0                  Buffer1 equal to Buffer2.
 713   @return <0                 Buffer1 is less than Buffer2.
 714   @return >0                 Buffer1 is greater than Buffer2.
 715
 716 **/
 717 INTN
 718 EFIAPI
 719 CompareFileNameInAlphabet (
 720   IN VOID                         *Left,
 721   IN VOID                         *Right
 722   )
 723 {
 724   EFI_FILE_INFO  *FileInfo1;
 725   EFI_FILE_INFO  *FileInfo2;
 726   CHAR16         FileName1[MAX_FILE_NAME_SIZE];
 727   CHAR16         FileExtension1[MAX_FILE_NAME_SIZE];
 728   CHAR16         FileName2[MAX_FILE_NAME_SIZE];
 729   CHAR16         FileExtension2[MAX_FILE_NAME_SIZE];
 730   CHAR16         TempSubStr1[MAX_FILE_NAME_SIZE];
 731   CHAR16         TempSubStr2[MAX_FILE_NAME_SIZE];
 732   UINTN          SubStrLen1;
 733   UINTN          SubStrLen2;
 734   INTN           SubStrCmpResult;
 735
 736   FileInfo1 = (EFI_FILE_INFO *) (*(UINTN *)Left);
 737   FileInfo2 = (EFI_FILE_INFO *) (*(UINTN *)Right);
 738
 739   SplitFileNameExtension (FileInfo1->FileName, FileName1, FileExtension1);
 740   SplitFileNameExtension (FileInfo2->FileName, FileName2, FileExtension2);
 741
 742   UpperCaseString (FileName1);
 743   UpperCaseString (FileName2);
 744
 745   GetSubStringBeforePeriod (FileName1, TempSubStr1, &SubStrLen1);
 746   GetSubStringBeforePeriod (FileName2, TempSubStr2, &SubStrLen2);
 747
 748   if (SubStrLen1 > SubStrLen2) {
 749     //
 750     // Substr in NewFileName is longer.  Pad tail with SPACE
 751     //
 752     PadStrInTail (TempSubStr2, SubStrLen1 - SubStrLen2, L' ');
 753   } else if (SubStrLen1 < SubStrLen2){
 754     //
 755     // Substr in ListedFileName is longer. Pad tail with SPACE
 756     //
 757     PadStrInTail (TempSubStr1, SubStrLen2 - SubStrLen1, L' ');
 758   }
 759
 760   SubStrCmpResult = StrnCmp (TempSubStr1, TempSubStr2, MAX_FILE_NAME_LEN);
 761   if (SubStrCmpResult != 0) {
 762     return SubStrCmpResult;
 763   }
 764
 765   UpperCaseString (FileExtension1);
 766   UpperCaseString (FileExtension2);
 767
 768   return StrnCmp (FileExtension1, FileExtension2, MAX_FILE_NAME_LEN);
 769 }
 770
 771 /**
 772   Dump capsule information from disk.
 773
 774   @param[in] Fs                  The device path of disk.
 775   @param[in] DumpCapsuleInfo     The flag to indicate whether to dump the capsule inforomation.
 776
 777   @retval EFI_SUCCESS            The capsule information is dumped.
 778
 779 **/
 780 EFI_STATUS
 781 DumpCapsuleFromDisk (
 782   IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL            *Fs,
 783   IN BOOLEAN                                    DumpCapsuleInfo
 784   )
 785 {
 786   EFI_STATUS                                    Status;
 787   EFI_FILE                                      *Root;
 788   EFI_FILE                                      *DirHandle;
 789   EFI_FILE                                      *FileHandle;
 790   UINTN                                         Index;
 791   UINTN                                         FileSize;
 792   VOID                                          *FileBuffer;
 793   EFI_FILE_INFO                                 **FileInfoBuffer;
 794   EFI_FILE_INFO                                 *FileInfo;
 795   UINTN                                         FileCount;
 796   BOOLEAN                                       NoFile;
 797
 798   DirHandle       = NULL;
 799   FileHandle      = NULL;
 800   Index           = 0;
 801   FileInfoBuffer  = NULL;
 802   FileInfo        = NULL;
 803   FileCount       = 0;
 804   NoFile          = FALSE;
 805
 806   Status = Fs->OpenVolume (Fs, &Root);
 807   if (EFI_ERROR (Status)) {
 808     Print (L"Cannot open volume. Status = %r\n", Status);
 809     goto Done;
 810   }
 811
 812   Status = Root->Open (Root, &DirHandle, EFI_CAPSULE_FILE_DIRECTORY, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE , 0);
 813   if (EFI_ERROR (Status)) {
 814     Print (L"Cannot open %s. Status = %r\n", EFI_CAPSULE_FILE_DIRECTORY, Status);
 815     goto Done;
 816   }
 817
 818   //
 819   // Get file count first
 820   //
 821   do {
 822     Status = FileHandleFindFirstFile (DirHandle, &FileInfo);
 823     if (EFI_ERROR (Status) || FileInfo == NULL) {
 824       Print (L"Get File Info Fail. Status = %r\n", Status);
 825       goto Done;
 826     }
 827
 828     if ((FileInfo->Attribute & (EFI_FILE_SYSTEM | EFI_FILE_ARCHIVE)) != 0) {
 829       FileCount++;
 830     }
 831
 832     Status = FileHandleFindNextFile (DirHandle, FileInfo, &NoFile);
 833     if (EFI_ERROR (Status)) {
 834       Print (L"Get Next File Fail. Status = %r\n", Status);
 835       goto Done;
 836     }
 837   } while (!NoFile);
 838
 839   if (FileCount == 0) {
 840     Print (L"Error: No capsule file found!\n");
 841     Status = EFI_NOT_FOUND;
 842     goto Done;
 843   }
 844
 845   FileInfoBuffer = AllocateZeroPool (sizeof (FileInfo) * FileCount);
 846   if (FileInfoBuffer == NULL) {
 847     Status = EFI_OUT_OF_RESOURCES;
 848     goto Done;
 849   }
 850   NoFile = FALSE;
 851
 852   //
 853   // Get all file info
 854   //
 855   do {
 856     Status = FileHandleFindFirstFile (DirHandle, &FileInfo);
 857     if (EFI_ERROR (Status) || FileInfo == NULL) {
 858       Print (L"Get File Info Fail. Status = %r\n", Status);
 859       goto Done;
 860     }
 861
 862     if ((FileInfo->Attribute & (EFI_FILE_SYSTEM | EFI_FILE_ARCHIVE)) != 0) {
 863       FileInfoBuffer[Index++] = AllocateCopyPool ((UINTN)FileInfo->Size, FileInfo);
 864     }
 865
 866     Status = FileHandleFindNextFile (DirHandle, FileInfo, &NoFile);
 867     if (EFI_ERROR (Status)) {
 868       Print (L"Get Next File Fail. Status = %r\n", Status);
 869       goto Done;
 870     }
 871   } while (!NoFile);
 872
 873   //
 874   // Sort FileInfoBuffer by alphabet order
 875   //
 876   PerformQuickSort (
 877     FileInfoBuffer,
 878     FileCount,
 879     sizeof (FileInfo),
 880     (SORT_COMPARE) CompareFileNameInAlphabet
 881     );
 882
 883   Print (L"The capsules will be performed by following order:\n");
 884
 885   for (Index = 0; Index < FileCount; Index++) {
 886     Print (L"  %d.%s\n", Index + 1, FileInfoBuffer[Index]->FileName);
 887   }
 888
 889   if (!DumpCapsuleInfo) {
 890     Status = EFI_SUCCESS;
 891     goto Done;
 892   }
 893
 894   Print(L"The infomation of the capsules:\n");
 895
 896   for (Index = 0; Index < FileCount; Index++) {
 897     FileHandle = NULL;
 898     Status = DirHandle->Open (DirHandle, &FileHandle, FileInfoBuffer[Index]->FileName, EFI_FILE_MODE_READ, 0);
 899     if (EFI_ERROR (Status)) {
 900       goto Done;
 901     }
 902
 903     Status = FileHandleGetSize (FileHandle, (UINT64 *) &FileSize);
 904     if (EFI_ERROR (Status)) {
 905       Print (L"Cannot read file %s. Status = %r\n", FileInfoBuffer[Index]->FileName, Status);
 906       FileHandleClose (FileHandle);
 907       goto Done;
 908     }
 909
 910     FileBuffer = AllocatePool (FileSize);
 911     if (FileBuffer == NULL) {
 912       Status = EFI_OUT_OF_RESOURCES;
 913       goto Done;
 914     }
 915
 916     Status = FileHandleRead (FileHandle, &FileSize, FileBuffer);
 917     if (EFI_ERROR (Status)) {
 918       Print (L"Cannot read file %s. Status = %r\n", FileInfoBuffer[Index]->FileName, Status);
 919       FileHandleClose (FileHandle);
 920       FreePool (FileBuffer);
 921       goto Done;
 922     }
 923
 924     Print (L"**************************\n");
 925     Print (L"  %d.%s:\n", Index + 1, FileInfoBuffer[Index]->FileName);
 926     Print (L"**************************\n");
 927     DumpCapsuleFromBuffer ((EFI_CAPSULE_HEADER *) FileBuffer);
 928     FileHandleClose (FileHandle);
 929     FreePool (FileBuffer);
 930   }
 931
 932 Done:
 933   if (FileInfoBuffer != NULL) {
 934     for (Index = 0; Index < FileCount; Index++) {
 935       if (FileInfoBuffer[Index] != NULL) {
 936         FreePool (FileInfoBuffer[Index]);
 937       }
 938     }
 939     FreePool (FileInfoBuffer);
 940   }
 941
 942   return Status;
 943 }
 944
 945 /**
 946   Dump capsule inforomation form Gather list.
 947
 948   @param[in]  BlockDescriptors The block descriptors for the capsule images
 949   @param[in]  DumpCapsuleInfo  The flag to indicate whether to dump the capsule inforomation.
 950
 951 **/
 952 VOID
 953 DumpBlockDescriptors (
 954   IN EFI_CAPSULE_BLOCK_DESCRIPTOR   *BlockDescriptors,
 955   IN BOOLEAN                        DumpCapsuleInfo
 956   )
 957 {
 958   EFI_CAPSULE_BLOCK_DESCRIPTOR      *TempBlockPtr;
 959
 960   TempBlockPtr = BlockDescriptors;
 961
 962   while (TRUE) {
 963     if (TempBlockPtr->Length != 0) {
 964       if (DumpCapsuleInfo) {
 965         Print(L"******************************************************\n");
 966       }
 967       Print(L"Capsule data starts at 0x%08x with size 0x%08x\n", TempBlockPtr->Union.DataBlock, TempBlockPtr->Length);
 968       if (DumpCapsuleInfo) {
 969         Print(L"******************************************************\n");
 970         DumpCapsuleFromBuffer ((EFI_CAPSULE_HEADER *) (UINTN) TempBlockPtr->Union.DataBlock);
 971       }
 972       TempBlockPtr += 1;
 973     } else {
 974       if (TempBlockPtr->Union.ContinuationPointer == (UINTN)NULL) {
 975         break;
 976       } else {
 977         TempBlockPtr = (EFI_CAPSULE_BLOCK_DESCRIPTOR *) (UINTN) TempBlockPtr->Union.ContinuationPointer;
 978       }
 979     }
 980   }
 981 }
 982
 983 /**
 984   Dump Provisioned Capsule.
 985
 986   @param[in]  DumpCapsuleInfo  The flag to indicate whether to dump the capsule inforomation.
 987
 988 **/
 989 VOID
 990 DumpProvisionedCapsule (
 991   IN BOOLEAN                      DumpCapsuleInfo
 992   )
 993 {
 994   EFI_STATUS                      Status;
 995   CHAR16                          CapsuleVarName[30];
 996   CHAR16                          *TempVarName;
 997   UINTN                           Index;
 998   EFI_PHYSICAL_ADDRESS            *CapsuleDataPtr64;
 999   UINT16                          *BootNext;
1000   CHAR16                          BootOptionName[20];
1001   EFI_BOOT_MANAGER_LOAD_OPTION    BootNextOptionEntry;
1002   EFI_DEVICE_PATH_PROTOCOL        *DevicePath;
1003   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Fs;
1004   EFI_SHELL_PROTOCOL              *ShellProtocol;
1005
1006   Index             = 0;
1007   CapsuleDataPtr64  = NULL;
1008   BootNext          = NULL;
1009
1010   ShellProtocol = GetShellProtocol ();
1011   if (ShellProtocol == NULL) {
1012     Print (L"Get Shell Protocol Fail\n");
1013     return ;
1014   }
1015
1016   //
1017   // Dump capsule provisioned on Memory
1018   //
1019   Print (L"#########################\n");
1020   Print (L"### Capsule on Memory ###\n");
1021   Print (L"#########################\n");
1022   StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CHAR16), EFI_CAPSULE_VARIABLE_NAME);
1023   TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
1024   while (TRUE) {
1025     if (Index > 0) {
1026       UnicodeValueToStringS (
1027         TempVarName,
1028         sizeof (CapsuleVarName) - ((UINTN)TempVarName - (UINTN)CapsuleVarName),
1029         0,
1030         Index,
1031         0
1032         );
1033     }
1034
1035     Status = GetVariable2 (
1036               CapsuleVarName,
1037               &gEfiCapsuleVendorGuid,
1038               (VOID **) &CapsuleDataPtr64,
1039               NULL
1040               );
1041     if (EFI_ERROR (Status) || CapsuleDataPtr64 == NULL) {
1042       if (Index == 0) {
1043         Print (L"No data.\n");
1044       }
1045       break;
1046     }
1047
1048     Index++;
1049     Print (L"Capsule Description at 0x%08x\n", *CapsuleDataPtr64);
1050     DumpBlockDescriptors ((EFI_CAPSULE_BLOCK_DESCRIPTOR*) (UINTN) *CapsuleDataPtr64, DumpCapsuleInfo);
1051   }
1052
1053   //
1054   // Dump capsule provisioned on Disk
1055   //
1056   Print (L"#########################\n");
1057   Print (L"### Capsule on Disk #####\n");
1058   Print (L"#########################\n");
1059   Status = GetVariable2 (
1060              L"BootNext",
1061              &gEfiGlobalVariableGuid,
1062              (VOID **) &BootNext,
1063              NULL
1064             );
1065   if (EFI_ERROR (Status) || BootNext == NULL) {
1066     Print (L"Get BootNext Variable Fail. Status = %r\n", Status);
1067   } else {
1068     UnicodeSPrint (BootOptionName, sizeof (BootOptionName), L"Boot%04x", *BootNext);
1069     Status = EfiBootManagerVariableToLoadOption (BootOptionName, &BootNextOptionEntry);
1070     if (!EFI_ERROR (Status)) {
1071       //
1072       // Display description and device path
1073       //
1074       GetEfiSysPartitionFromBootOptionFilePath (BootNextOptionEntry.FilePath, &DevicePath, &Fs);
1075       if(!EFI_ERROR (Status)) {
1076         Print (L"Capsules are provisioned on BootOption: %s\n", BootNextOptionEntry.Description);
1077         Print (L"    %s %s\n", ShellProtocol->GetMapFromDevicePath (&DevicePath), ConvertDevicePathToText(DevicePath, TRUE, TRUE));
1078         DumpCapsuleFromDisk (Fs, DumpCapsuleInfo);
1079       }
1080     }
1081   }
1082 }
1083
1084 /**
1085   Dump FMP information.
1086
1087   @param[in] ImageInfoSize       The size of ImageInfo, in bytes.
1088   @param[in] ImageInfo           A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1089   @param[in] DescriptorVersion   The version of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1090   @param[in] DescriptorCount     The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1091   @param[in] DescriptorSize      The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.
1092   @param[in] PackageVersion      The version of package.
1093   @param[in] PackageVersionName  The version name of package.
1094 **/
1095 VOID
1096 DumpFmpImageInfo (
1097   IN UINTN                           ImageInfoSize,
1098   IN EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,
1099   IN UINT32                          DescriptorVersion,
1100   IN UINT8                           DescriptorCount,
1101   IN UINTN                           DescriptorSize,
1102   IN UINT32                          PackageVersion,
1103   IN CHAR16                          *PackageVersionName
1104   )
1105 {
1106   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *CurrentImageInfo;
1107   UINTN                                         Index;
1108
1109   Print(L"  DescriptorVersion  - 0x%x\n", DescriptorVersion);
1110   Print(L"  DescriptorCount    - 0x%x\n", DescriptorCount);
1111   Print(L"  DescriptorSize     - 0x%x\n", DescriptorSize);
1112   Print(L"  PackageVersion     - 0x%x\n", PackageVersion);
1113   Print(L"  PackageVersionName - \"%s\"\n", PackageVersionName);
1114   CurrentImageInfo = ImageInfo;
1115   for (Index = 0; Index < DescriptorCount; Index++) {
1116     Print(L"  ImageDescriptor (%d)\n", Index);
1117     Print(L"    ImageIndex                  - 0x%x\n", CurrentImageInfo->ImageIndex);
1118     Print(L"    ImageTypeId                 - %g\n", &CurrentImageInfo->ImageTypeId);
1119     Print(L"    ImageId                     - 0x%lx\n", CurrentImageInfo->ImageId);
1120     Print(L"    ImageIdName                 - \"%s\"\n", CurrentImageInfo->ImageIdName);
1121     Print(L"    Version                     - 0x%x\n", CurrentImageInfo->Version);
1122     Print(L"    VersionName                 - \"%s\"\n", CurrentImageInfo->VersionName);
1123     Print(L"    Size                        - 0x%x\n", CurrentImageInfo->Size);
1124     Print(L"    AttributesSupported         - 0x%lx\n", CurrentImageInfo->AttributesSupported);
1125     Print(L"      IMAGE_UPDATABLE           - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1126     Print(L"      RESET_REQUIRED            - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1127     Print(L"      AUTHENTICATION_REQUIRED   - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1128     Print(L"      IN_USE                    - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_IN_USE);
1129     Print(L"      UEFI_IMAGE                - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_UEFI_IMAGE);
1130     Print(L"    AttributesSetting           - 0x%lx\n", CurrentImageInfo->AttributesSetting);
1131     Print(L"      IMAGE_UPDATABLE           - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1132     Print(L"      RESET_REQUIRED            - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1133     Print(L"      AUTHENTICATION_REQUIRED   - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1134     Print(L"      IN_USE                    - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_IN_USE);
1135     Print(L"      UEFI_IMAGE                - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE);
1136     Print(L"    Compatibilities             - 0x%lx\n", CurrentImageInfo->Compatibilities);
1137     Print(L"      COMPATIB_CHECK_SUPPORTED  - 0x%lx\n", CurrentImageInfo->Compatibilities & IMAGE_COMPATIBILITY_CHECK_SUPPORTED);
1138     if (DescriptorVersion > 1) {
1139       Print(L"    LowestSupportedImageVersion - 0x%x\n", CurrentImageInfo->LowestSupportedImageVersion);
1140       if (DescriptorVersion > 2) {
1141         Print(L"    LastAttemptVersion          - 0x%x\n", CurrentImageInfo->LastAttemptVersion);
1142         Print(L"    LastAttemptStatus           - 0x%x (%a)\n", CurrentImageInfo->LastAttemptStatus, LastAttemptStatusToString(CurrentImageInfo->LastAttemptStatus));
1143         Print(L"    HardwareInstance            - 0x%lx\n", CurrentImageInfo->HardwareInstance);
1144       }
1145     }
1146     //
1147     // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version
1148     //
1149     CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);
1150   }
1151 }
1152
1153 /**
1154   Dump FMP package information.
1155
1156   @param[in] PackageVersion             The version of package.
1157   @param[in] PackageVersionName         The version name of package.
1158   @param[in] PackageVersionNameMaxLen   The maximum length of PackageVersionName.
1159   @param[in] AttributesSupported        Package attributes that are supported by this device.
1160   @param[in] AttributesSetting          Package attributes.
1161 **/
1162 VOID
1163 DumpFmpPackageInfo (
1164   IN UINT32                           PackageVersion,
1165   IN CHAR16                           *PackageVersionName,
1166   IN UINT32                           PackageVersionNameMaxLen,
1167   IN UINT64                           AttributesSupported,
1168   IN UINT64                           AttributesSetting
1169   )
1170 {
1171   Print(L"  PackageVersion              - 0x%x\n", PackageVersion);
1172   Print(L"  PackageVersionName          - \"%s\"\n", PackageVersionName);
1173   Print(L"  PackageVersionNameMaxLen    - 0x%x\n", PackageVersionNameMaxLen);
1174   Print(L"  AttributesSupported         - 0x%lx\n", AttributesSupported);
1175   Print(L"    IMAGE_UPDATABLE           - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1176   Print(L"    RESET_REQUIRED            - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1177   Print(L"    AUTHENTICATION_REQUIRED   - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1178   Print(L"  AttributesSetting           - 0x%lx\n", AttributesSetting);
1179   Print(L"    IMAGE_UPDATABLE           - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1180   Print(L"    RESET_REQUIRED            - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1181   Print(L"    AUTHENTICATION_REQUIRED   - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1182 }
1183
1184 /**
1185   Dump FMP protocol info.
1186 **/
1187 VOID
1188 DumpFmpData (
1189   VOID
1190   )
1191 {
1192   EFI_STATUS                                    Status;
1193   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1194   EFI_HANDLE                                    *HandleBuffer;
1195   UINTN                                         NumberOfHandles;
1196   UINTN                                         Index;
1197   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
1198   UINTN                                         ImageInfoSize;
1199   UINT32                                        FmpImageInfoDescriptorVer;
1200   UINT8                                         FmpImageInfoCount;
1201   UINTN                                         DescriptorSize;
1202   UINT32                                        PackageVersion;
1203   CHAR16                                        *PackageVersionName;
1204   UINT32                                        PackageVersionNameMaxLen;
1205   UINT64                                        AttributesSupported;
1206   UINT64                                        AttributesSetting;
1207
1208   Print(L"############\n");
1209   Print(L"# FMP DATA #\n");
1210   Print(L"############\n");
1211   Status = gBS->LocateHandleBuffer (
1212                   ByProtocol,
1213                   &gEfiFirmwareManagementProtocolGuid,
1214                   NULL,
1215                   &NumberOfHandles,
1216                   &HandleBuffer
1217                   );
1218   if (EFI_ERROR(Status)) {
1219     Print(L"FMP protocol - %r\n", EFI_NOT_FOUND);
1220     return;
1221   }
1222
1223   for (Index = 0; Index < NumberOfHandles; Index++) {
1224     Status = gBS->HandleProtocol(
1225                     HandleBuffer[Index],
1226                     &gEfiFirmwareManagementProtocolGuid,
1227                     (VOID **)&Fmp
1228                     );
1229     if (EFI_ERROR(Status)) {
1230       continue;
1231     }
1232
1233     ImageInfoSize = 0;
1234     Status = Fmp->GetImageInfo (
1235                     Fmp,
1236                     &ImageInfoSize,
1237                     NULL,
1238                     NULL,
1239                     NULL,
1240                     NULL,
1241                     NULL,
1242                     NULL
1243                     );
1244     if (Status != EFI_BUFFER_TOO_SMALL) {
1245       continue;
1246     }
1247
1248     FmpImageInfoBuf = NULL;
1249     FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
1250     if (FmpImageInfoBuf == NULL) {
1251       Status = EFI_OUT_OF_RESOURCES;
1252       goto EXIT;
1253     }
1254
1255     PackageVersionName = NULL;
1256     Status = Fmp->GetImageInfo (
1257                     Fmp,
1258                     &ImageInfoSize,               // ImageInfoSize
1259                     FmpImageInfoBuf,              // ImageInfo
1260                     &FmpImageInfoDescriptorVer,   // DescriptorVersion
1261                     &FmpImageInfoCount,           // DescriptorCount
1262                     &DescriptorSize,              // DescriptorSize
1263                     &PackageVersion,              // PackageVersion
1264                     &PackageVersionName           // PackageVersionName
1265                     );
1266
1267     //
1268     // If FMP GetInformation interface failed, skip this resource
1269     //
1270     if (EFI_ERROR(Status)) {
1271       Print(L"FMP (%d) ImageInfo - %r\n", Index, Status);
1272       FreePool(FmpImageInfoBuf);
1273       continue;
1274     }
1275
1276     Print(L"FMP (%d) ImageInfo:\n", Index);
1277     DumpFmpImageInfo(
1278       ImageInfoSize,               // ImageInfoSize
1279       FmpImageInfoBuf,             // ImageInfo
1280       FmpImageInfoDescriptorVer,   // DescriptorVersion
1281       FmpImageInfoCount,           // DescriptorCount
1282       DescriptorSize,              // DescriptorSize
1283       PackageVersion,              // PackageVersion
1284       PackageVersionName           // PackageVersionName
1285       );
1286
1287     if (PackageVersionName != NULL) {
1288       FreePool(PackageVersionName);
1289     }
1290     FreePool(FmpImageInfoBuf);
1291
1292     //
1293     // Get package info
1294     //
1295     PackageVersionName = NULL;
1296     Status = Fmp->GetPackageInfo (
1297                     Fmp,
1298                     &PackageVersion,              // PackageVersion
1299                     &PackageVersionName,          // PackageVersionName
1300                     &PackageVersionNameMaxLen,    // PackageVersionNameMaxLen
1301                     &AttributesSupported,         // AttributesSupported
1302                     &AttributesSetting            // AttributesSetting
1303                     );
1304     if (EFI_ERROR(Status)) {
1305       Print(L"FMP (%d) PackageInfo - %r\n", Index, Status);
1306     } else {
1307       Print(L"FMP (%d) ImageInfo:\n", Index);
1308       DumpFmpPackageInfo(
1309         PackageVersion,              // PackageVersion
1310         PackageVersionName,          // PackageVersionName
1311         PackageVersionNameMaxLen,    // PackageVersionNameMaxLen
1312         AttributesSupported,         // AttributesSupported
1313         AttributesSetting            // AttributesSetting
1314         );
1315
1316       if (PackageVersionName != NULL) {
1317         FreePool(PackageVersionName);
1318       }
1319     }
1320   }
1321   Print(L"\n");
1322
1323 EXIT:
1324   FreePool(HandleBuffer);
1325 }
1326
1327 /**
1328   Check if the ImageInfo includes the ImageTypeId.
1329
1330   @param[in] ImageInfo           A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1331   @param[in] DescriptorCount     The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1332   @param[in] DescriptorSize      The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.
1333   @param[in] ImageTypeId         A unique GUID identifying the firmware image type.
1334
1335   @return TRUE  This ImageInfo includes the ImageTypeId
1336   @return FALSE This ImageInfo does not include the ImageTypeId
1337 **/
1338 BOOLEAN
1339 IsThisFmpImageInfo (
1340   IN EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,
1341   IN UINT8                           DescriptorCount,
1342   IN UINTN                           DescriptorSize,
1343   IN EFI_GUID                        *ImageTypeId
1344   )
1345 {
1346   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *CurrentImageInfo;
1347   UINTN                                         Index;
1348
1349   CurrentImageInfo = ImageInfo;
1350   for (Index = 0; Index < DescriptorCount; Index++) {
1351     if (CompareGuid (&CurrentImageInfo->ImageTypeId, ImageTypeId)) {
1352       return TRUE;
1353     }
1354     CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);
1355   }
1356   return FALSE;
1357 }
1358
1359 /**
1360   return the FMP whoes ImageInfo includes the ImageTypeId.
1361
1362   @param[in] ImageTypeId         A unique GUID identifying the firmware image type.
1363
1364   @return The FMP whoes ImageInfo includes the ImageTypeId
1365 **/
1366 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *
1367 FindFmpFromImageTypeId (
1368   IN EFI_GUID  *ImageTypeId
1369   )
1370 {
1371   EFI_STATUS                                    Status;
1372   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1373   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *TargetFmp;
1374   EFI_HANDLE                                    *HandleBuffer;
1375   UINTN                                         NumberOfHandles;
1376   UINTN                                         Index;
1377   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
1378   UINTN                                         ImageInfoSize;
1379   UINT32                                        FmpImageInfoDescriptorVer;
1380   UINT8                                         FmpImageInfoCount;
1381   UINTN                                         DescriptorSize;
1382   UINT32                                        PackageVersion;
1383   CHAR16                                        *PackageVersionName;
1384
1385   Status = gBS->LocateHandleBuffer (
1386                   ByProtocol,
1387                   &gEfiFirmwareManagementProtocolGuid,
1388                   NULL,
1389                   &NumberOfHandles,
1390                   &HandleBuffer
1391                   );
1392   if (EFI_ERROR(Status)) {
1393     Print(L"FMP protocol - %r\n", EFI_NOT_FOUND);
1394     return NULL;
1395   }
1396
1397   TargetFmp = NULL;
1398   for (Index = 0; Index < NumberOfHandles; Index++) {
1399     Status = gBS->HandleProtocol(
1400                     HandleBuffer[Index],
1401                     &gEfiFirmwareManagementProtocolGuid,
1402                     (VOID **)&Fmp
1403                     );
1404     if (EFI_ERROR(Status)) {
1405       continue;
1406     }
1407
1408     ImageInfoSize = 0;
1409     Status = Fmp->GetImageInfo (
1410                     Fmp,
1411                     &ImageInfoSize,
1412                     NULL,
1413                     NULL,
1414                     NULL,
1415                     NULL,
1416                     NULL,
1417                     NULL
1418                     );
1419     if (Status != EFI_BUFFER_TOO_SMALL) {
1420       continue;
1421     }
1422
1423     FmpImageInfoBuf = NULL;
1424     FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
1425     if (FmpImageInfoBuf == NULL) {
1426       FreePool(HandleBuffer);
1427       Print(L"Out of resource\n");
1428       return NULL;
1429     }
1430
1431     PackageVersionName = NULL;
1432     Status = Fmp->GetImageInfo (
1433                     Fmp,
1434                     &ImageInfoSize,               // ImageInfoSize
1435                     FmpImageInfoBuf,              // ImageInfo
1436                     &FmpImageInfoDescriptorVer,   // DescriptorVersion
1437                     &FmpImageInfoCount,           // DescriptorCount
1438                     &DescriptorSize,              // DescriptorSize
1439                     &PackageVersion,              // PackageVersion
1440                     &PackageVersionName           // PackageVersionName
1441                     );
1442
1443     //
1444     // If FMP GetInformation interface failed, skip this resource
1445     //
1446     if (EFI_ERROR(Status)) {
1447       FreePool(FmpImageInfoBuf);
1448       continue;
1449     }
1450
1451     if (PackageVersionName != NULL) {
1452       FreePool(PackageVersionName);
1453     }
1454
1455     if (IsThisFmpImageInfo (FmpImageInfoBuf, FmpImageInfoCount, DescriptorSize, ImageTypeId)) {
1456       TargetFmp = Fmp;
1457     }
1458     FreePool(FmpImageInfoBuf);
1459     if (TargetFmp != NULL) {
1460       break;
1461     }
1462   }
1463   FreePool(HandleBuffer);
1464   return TargetFmp;
1465 }
1466
1467 /**
1468   Dump FMP image data.
1469
1470   @param[in]  ImageTypeId   The ImageTypeId of the FMP image.
1471                             It is used to identify the FMP protocol.
1472   @param[in]  ImageIndex    The ImageIndex of the FMP image.
1473                             It is the input parameter for FMP->GetImage().
1474   @param[in]  ImageName     The file name to hold the output FMP image.
1475 **/
1476 VOID
1477 DumpFmpImage (
1478   IN EFI_GUID  *ImageTypeId,
1479   IN UINTN     ImageIndex,
1480   IN CHAR16    *ImageName
1481   )
1482 {
1483   EFI_STATUS                                    Status;
1484   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1485   VOID                                          *Image;
1486   UINTN                                         ImageSize;
1487
1488   Fmp = FindFmpFromImageTypeId (ImageTypeId);
1489   if (Fmp == NULL) {
1490     Print(L"No FMP include ImageTypeId %g\n", ImageTypeId);
1491     return ;
1492   }
1493
1494   if (ImageIndex > 0xFF) {
1495     Print(L"ImageIndex 0x%x too big\n", ImageIndex);
1496     return ;
1497   }
1498
1499   Image = Fmp;
1500   ImageSize = 0;
1501   Status = Fmp->GetImage (Fmp, (UINT8)ImageIndex, Image, &ImageSize);
1502   if (Status != EFI_BUFFER_TOO_SMALL) {
1503     Print(L"Fmp->GetImage - %r\n", Status);
1504     return ;
1505   }
1506
1507   Image = AllocatePool (ImageSize);
1508   if (Image == NULL) {
1509     Print(L"Allocate FmpImage 0x%x - %r\n", ImageSize, EFI_OUT_OF_RESOURCES);
1510     return ;
1511   }
1512
1513   Status = Fmp->GetImage (Fmp, (UINT8)ImageIndex, Image, &ImageSize);
1514   if (EFI_ERROR(Status)) {
1515     Print(L"Fmp->GetImage - %r\n", Status);
1516     return ;
1517   }
1518
1519   Status = WriteFileFromBuffer(ImageName, ImageSize, Image);
1520   Print(L"CapsuleApp: Dump %g ImageIndex (0x%x) to %s %r\n", ImageTypeId, ImageIndex, ImageName, Status);
1521
1522   FreePool (Image);
1523
1524   return ;
1525 }