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   FileCount  = 0;
 802   NoFile     = FALSE;
 803
 804   Status = Fs->OpenVolume (Fs, &Root);
 805   if (EFI_ERROR (Status)) {
 806     Print (L"Cannot open volume. Status = %r\n", Status);
 807     return EFI_NOT_FOUND;
 808   }
 809
 810   Status = Root->Open (Root, &DirHandle, EFI_CAPSULE_FILE_DIRECTORY, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE , 0);
 811   if (EFI_ERROR (Status)) {
 812     Print (L"Cannot open %s. Status = %r\n", EFI_CAPSULE_FILE_DIRECTORY, Status);
 813     return EFI_NOT_FOUND;
 814   }
 815
 816   //
 817   // Get file count first
 818   //
 819   for ( Status = FileHandleFindFirstFile (DirHandle, &FileInfo)
 820       ; !EFI_ERROR(Status) && !NoFile
 821       ; Status = FileHandleFindNextFile (DirHandle, FileInfo, &NoFile)
 822      ){
 823     if ((FileInfo->Attribute & (EFI_FILE_SYSTEM | EFI_FILE_ARCHIVE)) == 0) {
 824       continue;
 825     }
 826     FileCount++;
 827   }
 828
 829   if (FileCount == 0) {
 830     Print (L"Error: No capsule file found!\n");
 831     return EFI_NOT_FOUND;
 832   }
 833
 834   FileInfoBuffer = AllocatePool (sizeof(FileInfo) * FileCount);
 835   NoFile = FALSE;
 836
 837   //
 838   // Get all file info
 839   //
 840   for ( Status = FileHandleFindFirstFile (DirHandle, &FileInfo)
 841       ; !EFI_ERROR (Status) && !NoFile
 842       ; Status = FileHandleFindNextFile (DirHandle, FileInfo, &NoFile)
 843      ){
 844     if ((FileInfo->Attribute & (EFI_FILE_SYSTEM | EFI_FILE_ARCHIVE)) == 0) {
 845       continue;
 846     }
 847     FileInfoBuffer[Index++] = AllocateCopyPool ((UINTN)FileInfo->Size, FileInfo);
 848   }
 849
 850   //
 851   // Sort FileInfoBuffer by alphabet order
 852   //
 853   PerformQuickSort (
 854     FileInfoBuffer,
 855     FileCount,
 856     sizeof (FileInfo),
 857     (SORT_COMPARE) CompareFileNameInAlphabet
 858     );
 859
 860   Print (L"The capsules will be performed by following order:\n");
 861
 862   for (Index = 0; Index < FileCount; Index++) {
 863     Print (L"  %d.%s\n", Index + 1, FileInfoBuffer[Index]->FileName);
 864   }
 865
 866   if (!DumpCapsuleInfo) {
 867     return EFI_SUCCESS;
 868   }
 869
 870   Print(L"The infomation of the capsules:\n");
 871
 872   for (Index = 0; Index < FileCount; Index++) {
 873     FileHandle = NULL;
 874     Status = DirHandle->Open (DirHandle, &FileHandle, FileInfoBuffer[Index]->FileName, EFI_FILE_MODE_READ, 0);
 875     if (EFI_ERROR (Status)) {
 876       break;
 877     }
 878
 879     Status = FileHandleGetSize (FileHandle, (UINT64 *) &FileSize);
 880     if (EFI_ERROR (Status)) {
 881       Print (L"Cannot read file %s. Status = %r\n", FileInfoBuffer[Index]->FileName, Status);
 882       FileHandleClose (FileHandle);
 883       return Status;
 884     }
 885
 886     FileBuffer = AllocatePool (FileSize);
 887     if (FileBuffer == NULL) {
 888       return RETURN_OUT_OF_RESOURCES;
 889     }
 890
 891     Status = FileHandleRead (FileHandle, &FileSize, FileBuffer);
 892     if (EFI_ERROR (Status)) {
 893       Print (L"Cannot read file %s. Status = %r\n", FileInfoBuffer[Index]->FileName, Status);
 894       FreePool (FileBuffer);
 895       FileHandleClose (FileHandle);
 896       return Status;
 897     }
 898
 899     Print (L"**************************\n");
 900     Print (L"  %d.%s:\n", Index + 1, FileInfoBuffer[Index]->FileName);
 901     Print (L"**************************\n");
 902     DumpCapsuleFromBuffer ((EFI_CAPSULE_HEADER *) FileBuffer);
 903     FileHandleClose (FileHandle);
 904     FreePool (FileBuffer);
 905   }
 906
 907   return EFI_SUCCESS;
 908 }
 909
 910 /**
 911   Dump capsule inforomation form Gather list.
 912
 913   @param[in]  BlockDescriptors The block descriptors for the capsule images
 914   @param[in]  DumpCapsuleInfo  The flag to indicate whether to dump the capsule inforomation.
 915
 916 **/
 917 VOID
 918 DumpBlockDescriptors (
 919   IN EFI_CAPSULE_BLOCK_DESCRIPTOR   *BlockDescriptors,
 920   IN BOOLEAN                        DumpCapsuleInfo
 921   )
 922 {
 923   EFI_CAPSULE_BLOCK_DESCRIPTOR      *TempBlockPtr;
 924
 925   TempBlockPtr = BlockDescriptors;
 926
 927   while (TRUE) {
 928     if (TempBlockPtr->Length != 0) {
 929       if (DumpCapsuleInfo) {
 930         Print(L"******************************************************\n");
 931       }
 932       Print(L"Capsule data starts at 0x%08x with size 0x%08x\n", TempBlockPtr->Union.DataBlock, TempBlockPtr->Length);
 933       if (DumpCapsuleInfo) {
 934         Print(L"******************************************************\n");
 935         DumpCapsuleFromBuffer ((EFI_CAPSULE_HEADER *) (UINTN) TempBlockPtr->Union.DataBlock);
 936       }
 937       TempBlockPtr += 1;
 938     } else {
 939       if (TempBlockPtr->Union.ContinuationPointer == (UINTN)NULL) {
 940         break;
 941       } else {
 942         TempBlockPtr = (EFI_CAPSULE_BLOCK_DESCRIPTOR *) (UINTN) TempBlockPtr->Union.ContinuationPointer;
 943       }
 944     }
 945   }
 946 }
 947
 948 /**
 949   Dump Provisioned Capsule.
 950
 951   @param[in]  DumpCapsuleInfo  The flag to indicate whether to dump the capsule inforomation.
 952
 953 **/
 954 VOID
 955 DumpProvisionedCapsule (
 956   IN BOOLEAN                      DumpCapsuleInfo
 957   )
 958 {
 959   EFI_STATUS                      Status;
 960   CHAR16                          CapsuleVarName[30];
 961   CHAR16                          *TempVarName;
 962   UINTN                           Index;
 963   EFI_PHYSICAL_ADDRESS            *CapsuleDataPtr64;
 964   UINT16                          *BootNext;
 965   CHAR16                          BootOptionName[20];
 966   EFI_BOOT_MANAGER_LOAD_OPTION    BootNextOptionEntry;
 967   EFI_DEVICE_PATH_PROTOCOL        *DevicePath;
 968   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Fs;
 969   EFI_SHELL_PROTOCOL              *ShellProtocol;
 970
 971   ShellProtocol = GetShellProtocol ();
 972
 973   Index = 0;
 974
 975   //
 976   // Dump capsule provisioned on Memory
 977   //
 978   Print (L"#########################\n");
 979   Print (L"### Capsule on Memory ###\n");
 980   Print (L"#########################\n");
 981   StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CHAR16), EFI_CAPSULE_VARIABLE_NAME);
 982   TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
 983   while (TRUE) {
 984     if (Index > 0) {
 985       UnicodeValueToStringS (
 986         TempVarName,
 987         sizeof (CapsuleVarName) - ((UINTN)TempVarName - (UINTN)CapsuleVarName),
 988         0,
 989         Index,
 990         0
 991         );
 992     }
 993
 994     Status = GetVariable2 (
 995               CapsuleVarName,
 996               &gEfiCapsuleVendorGuid,
 997               (VOID **) &CapsuleDataPtr64,
 998               NULL
 999               );
1000     if (EFI_ERROR (Status)) {
1001       if (Index == 0) {
1002         Print (L"No data.\n");
1003       }
1004       break;
1005     } else {
1006       Index++;
1007       Print (L"Capsule Description at 0x%08x\n", *CapsuleDataPtr64);
1008       DumpBlockDescriptors ((EFI_CAPSULE_BLOCK_DESCRIPTOR*) (UINTN) *CapsuleDataPtr64, DumpCapsuleInfo);
1009     }
1010   }
1011
1012   //
1013   // Dump capsule provisioned on Disk
1014   //
1015   Print (L"#########################\n");
1016   Print (L"### Capsule on Disk #####\n");
1017   Print (L"#########################\n");
1018   Status = GetVariable2 (
1019              L"BootNext",
1020              &gEfiGlobalVariableGuid,
1021              (VOID **) &BootNext,
1022              NULL
1023             );
1024   if (!EFI_ERROR (Status)) {
1025     UnicodeSPrint (BootOptionName, sizeof (BootOptionName), L"Boot%04x", *BootNext);
1026     Status = EfiBootManagerVariableToLoadOption (BootOptionName, &BootNextOptionEntry);
1027     if (!EFI_ERROR (Status)) {
1028       //
1029       // Display description and device path
1030       //
1031       GetEfiSysPartitionFromBootOptionFilePath (BootNextOptionEntry.FilePath, &DevicePath, &Fs);
1032       if(!EFI_ERROR (Status)) {
1033         Print (L"Capsules are provisioned on BootOption: %s\n", BootNextOptionEntry.Description);
1034         Print (L"    %s %s\n", ShellProtocol->GetMapFromDevicePath (&DevicePath), ConvertDevicePathToText(DevicePath, TRUE, TRUE));
1035         DumpCapsuleFromDisk (Fs, DumpCapsuleInfo);
1036       }
1037     }
1038   }
1039 }
1040
1041 /**
1042   Dump FMP information.
1043
1044   @param[in] ImageInfoSize       The size of ImageInfo, in bytes.
1045   @param[in] ImageInfo           A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1046   @param[in] DescriptorVersion   The version of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1047   @param[in] DescriptorCount     The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1048   @param[in] DescriptorSize      The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.
1049   @param[in] PackageVersion      The version of package.
1050   @param[in] PackageVersionName  The version name of package.
1051 **/
1052 VOID
1053 DumpFmpImageInfo (
1054   IN UINTN                           ImageInfoSize,
1055   IN EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,
1056   IN UINT32                          DescriptorVersion,
1057   IN UINT8                           DescriptorCount,
1058   IN UINTN                           DescriptorSize,
1059   IN UINT32                          PackageVersion,
1060   IN CHAR16                          *PackageVersionName
1061   )
1062 {
1063   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *CurrentImageInfo;
1064   UINTN                                         Index;
1065
1066   Print(L"  DescriptorVersion  - 0x%x\n", DescriptorVersion);
1067   Print(L"  DescriptorCount    - 0x%x\n", DescriptorCount);
1068   Print(L"  DescriptorSize     - 0x%x\n", DescriptorSize);
1069   Print(L"  PackageVersion     - 0x%x\n", PackageVersion);
1070   Print(L"  PackageVersionName - \"%s\"\n", PackageVersionName);
1071   CurrentImageInfo = ImageInfo;
1072   for (Index = 0; Index < DescriptorCount; Index++) {
1073     Print(L"  ImageDescriptor (%d)\n", Index);
1074     Print(L"    ImageIndex                  - 0x%x\n", CurrentImageInfo->ImageIndex);
1075     Print(L"    ImageTypeId                 - %g\n", &CurrentImageInfo->ImageTypeId);
1076     Print(L"    ImageId                     - 0x%lx\n", CurrentImageInfo->ImageId);
1077     Print(L"    ImageIdName                 - \"%s\"\n", CurrentImageInfo->ImageIdName);
1078     Print(L"    Version                     - 0x%x\n", CurrentImageInfo->Version);
1079     Print(L"    VersionName                 - \"%s\"\n", CurrentImageInfo->VersionName);
1080     Print(L"    Size                        - 0x%x\n", CurrentImageInfo->Size);
1081     Print(L"    AttributesSupported         - 0x%lx\n", CurrentImageInfo->AttributesSupported);
1082     Print(L"      IMAGE_UPDATABLE           - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1083     Print(L"      RESET_REQUIRED            - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1084     Print(L"      AUTHENTICATION_REQUIRED   - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1085     Print(L"      IN_USE                    - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_IN_USE);
1086     Print(L"      UEFI_IMAGE                - 0x%lx\n", CurrentImageInfo->AttributesSupported & IMAGE_ATTRIBUTE_UEFI_IMAGE);
1087     Print(L"    AttributesSetting           - 0x%lx\n", CurrentImageInfo->AttributesSetting);
1088     Print(L"      IMAGE_UPDATABLE           - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1089     Print(L"      RESET_REQUIRED            - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1090     Print(L"      AUTHENTICATION_REQUIRED   - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1091     Print(L"      IN_USE                    - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_IN_USE);
1092     Print(L"      UEFI_IMAGE                - 0x%lx\n", CurrentImageInfo->AttributesSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE);
1093     Print(L"    Compatibilities             - 0x%lx\n", CurrentImageInfo->Compatibilities);
1094     Print(L"      COMPATIB_CHECK_SUPPORTED  - 0x%lx\n", CurrentImageInfo->Compatibilities & IMAGE_COMPATIBILITY_CHECK_SUPPORTED);
1095     if (DescriptorVersion > 1) {
1096       Print(L"    LowestSupportedImageVersion - 0x%x\n", CurrentImageInfo->LowestSupportedImageVersion);
1097       if (DescriptorVersion > 2) {
1098         Print(L"    LastAttemptVersion          - 0x%x\n", CurrentImageInfo->LastAttemptVersion);
1099         Print(L"    LastAttemptStatus           - 0x%x (%a)\n", CurrentImageInfo->LastAttemptStatus, LastAttemptStatusToString(CurrentImageInfo->LastAttemptStatus));
1100         Print(L"    HardwareInstance            - 0x%lx\n", CurrentImageInfo->HardwareInstance);
1101       }
1102     }
1103     //
1104     // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version
1105     //
1106     CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);
1107   }
1108 }
1109
1110 /**
1111   Dump FMP package information.
1112
1113   @param[in] PackageVersion             The version of package.
1114   @param[in] PackageVersionName         The version name of package.
1115   @param[in] PackageVersionNameMaxLen   The maximum length of PackageVersionName.
1116   @param[in] AttributesSupported        Package attributes that are supported by this device.
1117   @param[in] AttributesSetting          Package attributes.
1118 **/
1119 VOID
1120 DumpFmpPackageInfo (
1121   IN UINT32                           PackageVersion,
1122   IN CHAR16                           *PackageVersionName,
1123   IN UINT32                           PackageVersionNameMaxLen,
1124   IN UINT64                           AttributesSupported,
1125   IN UINT64                           AttributesSetting
1126   )
1127 {
1128   Print(L"  PackageVersion              - 0x%x\n", PackageVersion);
1129   Print(L"  PackageVersionName          - \"%s\"\n", PackageVersionName);
1130   Print(L"  PackageVersionNameMaxLen    - 0x%x\n", PackageVersionNameMaxLen);
1131   Print(L"  AttributesSupported         - 0x%lx\n", AttributesSupported);
1132   Print(L"    IMAGE_UPDATABLE           - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1133   Print(L"    RESET_REQUIRED            - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1134   Print(L"    AUTHENTICATION_REQUIRED   - 0x%lx\n", AttributesSupported & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1135   Print(L"  AttributesSetting           - 0x%lx\n", AttributesSetting);
1136   Print(L"    IMAGE_UPDATABLE           - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE);
1137   Print(L"    RESET_REQUIRED            - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED);
1138   Print(L"    AUTHENTICATION_REQUIRED   - 0x%lx\n", AttributesSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);
1139 }
1140
1141 /**
1142   Dump FMP protocol info.
1143 **/
1144 VOID
1145 DumpFmpData (
1146   VOID
1147   )
1148 {
1149   EFI_STATUS                                    Status;
1150   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1151   EFI_HANDLE                                    *HandleBuffer;
1152   UINTN                                         NumberOfHandles;
1153   UINTN                                         Index;
1154   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
1155   UINTN                                         ImageInfoSize;
1156   UINT32                                        FmpImageInfoDescriptorVer;
1157   UINT8                                         FmpImageInfoCount;
1158   UINTN                                         DescriptorSize;
1159   UINT32                                        PackageVersion;
1160   CHAR16                                        *PackageVersionName;
1161   UINT32                                        PackageVersionNameMaxLen;
1162   UINT64                                        AttributesSupported;
1163   UINT64                                        AttributesSetting;
1164
1165   Print(L"############\n");
1166   Print(L"# FMP DATA #\n");
1167   Print(L"############\n");
1168   Status = gBS->LocateHandleBuffer (
1169                   ByProtocol,
1170                   &gEfiFirmwareManagementProtocolGuid,
1171                   NULL,
1172                   &NumberOfHandles,
1173                   &HandleBuffer
1174                   );
1175   if (EFI_ERROR(Status)) {
1176     Print(L"FMP protocol - %r\n", EFI_NOT_FOUND);
1177     return;
1178   }
1179
1180   for (Index = 0; Index < NumberOfHandles; Index++) {
1181     Status = gBS->HandleProtocol(
1182                     HandleBuffer[Index],
1183                     &gEfiFirmwareManagementProtocolGuid,
1184                     (VOID **)&Fmp
1185                     );
1186     if (EFI_ERROR(Status)) {
1187       continue;
1188     }
1189
1190     ImageInfoSize = 0;
1191     Status = Fmp->GetImageInfo (
1192                     Fmp,
1193                     &ImageInfoSize,
1194                     NULL,
1195                     NULL,
1196                     NULL,
1197                     NULL,
1198                     NULL,
1199                     NULL
1200                     );
1201     if (Status != EFI_BUFFER_TOO_SMALL) {
1202       continue;
1203     }
1204
1205     FmpImageInfoBuf = NULL;
1206     FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
1207     if (FmpImageInfoBuf == NULL) {
1208       Status = EFI_OUT_OF_RESOURCES;
1209       goto EXIT;
1210     }
1211
1212     PackageVersionName = NULL;
1213     Status = Fmp->GetImageInfo (
1214                     Fmp,
1215                     &ImageInfoSize,               // ImageInfoSize
1216                     FmpImageInfoBuf,              // ImageInfo
1217                     &FmpImageInfoDescriptorVer,   // DescriptorVersion
1218                     &FmpImageInfoCount,           // DescriptorCount
1219                     &DescriptorSize,              // DescriptorSize
1220                     &PackageVersion,              // PackageVersion
1221                     &PackageVersionName           // PackageVersionName
1222                     );
1223
1224     //
1225     // If FMP GetInformation interface failed, skip this resource
1226     //
1227     if (EFI_ERROR(Status)) {
1228       Print(L"FMP (%d) ImageInfo - %r\n", Index, Status);
1229       FreePool(FmpImageInfoBuf);
1230       continue;
1231     }
1232
1233     Print(L"FMP (%d) ImageInfo:\n", Index);
1234     DumpFmpImageInfo(
1235       ImageInfoSize,               // ImageInfoSize
1236       FmpImageInfoBuf,             // ImageInfo
1237       FmpImageInfoDescriptorVer,   // DescriptorVersion
1238       FmpImageInfoCount,           // DescriptorCount
1239       DescriptorSize,              // DescriptorSize
1240       PackageVersion,              // PackageVersion
1241       PackageVersionName           // PackageVersionName
1242       );
1243
1244     if (PackageVersionName != NULL) {
1245       FreePool(PackageVersionName);
1246     }
1247     FreePool(FmpImageInfoBuf);
1248
1249     //
1250     // Get package info
1251     //
1252     PackageVersionName = NULL;
1253     Status = Fmp->GetPackageInfo (
1254                     Fmp,
1255                     &PackageVersion,              // PackageVersion
1256                     &PackageVersionName,          // PackageVersionName
1257                     &PackageVersionNameMaxLen,    // PackageVersionNameMaxLen
1258                     &AttributesSupported,         // AttributesSupported
1259                     &AttributesSetting            // AttributesSetting
1260                     );
1261     if (EFI_ERROR(Status)) {
1262       Print(L"FMP (%d) PackageInfo - %r\n", Index, Status);
1263     } else {
1264       Print(L"FMP (%d) ImageInfo:\n", Index);
1265       DumpFmpPackageInfo(
1266         PackageVersion,              // PackageVersion
1267         PackageVersionName,          // PackageVersionName
1268         PackageVersionNameMaxLen,    // PackageVersionNameMaxLen
1269         AttributesSupported,         // AttributesSupported
1270         AttributesSetting            // AttributesSetting
1271         );
1272
1273       if (PackageVersionName != NULL) {
1274         FreePool(PackageVersionName);
1275       }
1276     }
1277   }
1278   Print(L"\n");
1279
1280 EXIT:
1281   FreePool(HandleBuffer);
1282 }
1283
1284 /**
1285   Check if the ImageInfo includes the ImageTypeId.
1286
1287   @param[in] ImageInfo           A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1288   @param[in] DescriptorCount     The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.
1289   @param[in] DescriptorSize      The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.
1290   @param[in] ImageTypeId         A unique GUID identifying the firmware image type.
1291
1292   @return TRUE  This ImageInfo includes the ImageTypeId
1293   @return FALSE This ImageInfo does not include the ImageTypeId
1294 **/
1295 BOOLEAN
1296 IsThisFmpImageInfo (
1297   IN EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,
1298   IN UINT8                           DescriptorCount,
1299   IN UINTN                           DescriptorSize,
1300   IN EFI_GUID                        *ImageTypeId
1301   )
1302 {
1303   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *CurrentImageInfo;
1304   UINTN                                         Index;
1305
1306   CurrentImageInfo = ImageInfo;
1307   for (Index = 0; Index < DescriptorCount; Index++) {
1308     if (CompareGuid (&CurrentImageInfo->ImageTypeId, ImageTypeId)) {
1309       return TRUE;
1310     }
1311     CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);
1312   }
1313   return FALSE;
1314 }
1315
1316 /**
1317   return the FMP whoes ImageInfo includes the ImageTypeId.
1318
1319   @param[in] ImageTypeId         A unique GUID identifying the firmware image type.
1320
1321   @return The FMP whoes ImageInfo includes the ImageTypeId
1322 **/
1323 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *
1324 FindFmpFromImageTypeId (
1325   IN EFI_GUID  *ImageTypeId
1326   )
1327 {
1328   EFI_STATUS                                    Status;
1329   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1330   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *TargetFmp;
1331   EFI_HANDLE                                    *HandleBuffer;
1332   UINTN                                         NumberOfHandles;
1333   UINTN                                         Index;
1334   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
1335   UINTN                                         ImageInfoSize;
1336   UINT32                                        FmpImageInfoDescriptorVer;
1337   UINT8                                         FmpImageInfoCount;
1338   UINTN                                         DescriptorSize;
1339   UINT32                                        PackageVersion;
1340   CHAR16                                        *PackageVersionName;
1341
1342   Status = gBS->LocateHandleBuffer (
1343                   ByProtocol,
1344                   &gEfiFirmwareManagementProtocolGuid,
1345                   NULL,
1346                   &NumberOfHandles,
1347                   &HandleBuffer
1348                   );
1349   if (EFI_ERROR(Status)) {
1350     Print(L"FMP protocol - %r\n", EFI_NOT_FOUND);
1351     return NULL;
1352   }
1353
1354   TargetFmp = NULL;
1355   for (Index = 0; Index < NumberOfHandles; Index++) {
1356     Status = gBS->HandleProtocol(
1357                     HandleBuffer[Index],
1358                     &gEfiFirmwareManagementProtocolGuid,
1359                     (VOID **)&Fmp
1360                     );
1361     if (EFI_ERROR(Status)) {
1362       continue;
1363     }
1364
1365     ImageInfoSize = 0;
1366     Status = Fmp->GetImageInfo (
1367                     Fmp,
1368                     &ImageInfoSize,
1369                     NULL,
1370                     NULL,
1371                     NULL,
1372                     NULL,
1373                     NULL,
1374                     NULL
1375                     );
1376     if (Status != EFI_BUFFER_TOO_SMALL) {
1377       continue;
1378     }
1379
1380     FmpImageInfoBuf = NULL;
1381     FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
1382     if (FmpImageInfoBuf == NULL) {
1383       FreePool(HandleBuffer);
1384       Print(L"Out of resource\n");
1385       return NULL;
1386     }
1387
1388     PackageVersionName = NULL;
1389     Status = Fmp->GetImageInfo (
1390                     Fmp,
1391                     &ImageInfoSize,               // ImageInfoSize
1392                     FmpImageInfoBuf,              // ImageInfo
1393                     &FmpImageInfoDescriptorVer,   // DescriptorVersion
1394                     &FmpImageInfoCount,           // DescriptorCount
1395                     &DescriptorSize,              // DescriptorSize
1396                     &PackageVersion,              // PackageVersion
1397                     &PackageVersionName           // PackageVersionName
1398                     );
1399
1400     //
1401     // If FMP GetInformation interface failed, skip this resource
1402     //
1403     if (EFI_ERROR(Status)) {
1404       FreePool(FmpImageInfoBuf);
1405       continue;
1406     }
1407
1408     if (PackageVersionName != NULL) {
1409       FreePool(PackageVersionName);
1410     }
1411
1412     if (IsThisFmpImageInfo (FmpImageInfoBuf, FmpImageInfoCount, DescriptorSize, ImageTypeId)) {
1413       TargetFmp = Fmp;
1414     }
1415     FreePool(FmpImageInfoBuf);
1416     if (TargetFmp != NULL) {
1417       break;
1418     }
1419   }
1420   FreePool(HandleBuffer);
1421   return TargetFmp;
1422 }
1423
1424 /**
1425   Dump FMP image data.
1426
1427   @param[in]  ImageTypeId   The ImageTypeId of the FMP image.
1428                             It is used to identify the FMP protocol.
1429   @param[in]  ImageIndex    The ImageIndex of the FMP image.
1430                             It is the input parameter for FMP->GetImage().
1431   @param[in]  ImageName     The file name to hold the output FMP image.
1432 **/
1433 VOID
1434 DumpFmpImage (
1435   IN EFI_GUID  *ImageTypeId,
1436   IN UINTN     ImageIndex,
1437   IN CHAR16    *ImageName
1438   )
1439 {
1440   EFI_STATUS                                    Status;
1441   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
1442   VOID                                          *Image;
1443   UINTN                                         ImageSize;
1444
1445   Fmp = FindFmpFromImageTypeId (ImageTypeId);
1446   if (Fmp == NULL) {
1447     Print(L"No FMP include ImageTypeId %g\n", ImageTypeId);
1448     return ;
1449   }
1450
1451   if (ImageIndex > 0xFF) {
1452     Print(L"ImageIndex 0x%x too big\n", ImageIndex);
1453     return ;
1454   }
1455
1456   Image = Fmp;
1457   ImageSize = 0;
1458   Status = Fmp->GetImage (Fmp, (UINT8)ImageIndex, Image, &ImageSize);
1459   if (Status != EFI_BUFFER_TOO_SMALL) {
1460     Print(L"Fmp->GetImage - %r\n", Status);
1461     return ;
1462   }
1463
1464   Image = AllocatePool (ImageSize);
1465   if (Image == NULL) {
1466     Print(L"Allocate FmpImage 0x%x - %r\n", ImageSize, EFI_OUT_OF_RESOURCES);
1467     return ;
1468   }
1469
1470   Status = Fmp->GetImage (Fmp, (UINT8)ImageIndex, Image, &ImageSize);
1471   if (EFI_ERROR(Status)) {
1472     Print(L"Fmp->GetImage - %r\n", Status);
1473     return ;
1474   }
1475
1476   Status = WriteFileFromBuffer(ImageName, ImageSize, Image);
1477   Print(L"CapsuleApp: Dump %g ImageIndex (0x%x) to %s %r\n", ImageTypeId, ImageIndex, ImageName, Status);
1478
1479   FreePool (Image);
1480
1481   return ;
1482 }