ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c

   1 /** @file
   2   Provides interface to advanced shell functionality for parsing both handle and protocol database.
   3
   4   Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
   5   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
   6   (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "UefiHandleParsingLib.h"
  18 #include "IndustryStandard/Acpi10.h"
  19 #include "IndustryStandard/Pci.h"
  20 #include <PiDxe.h>
  21 #include <Protocol/FirmwareVolume2.h>
  22
  23 EFI_HANDLE        mHandleParsingHiiHandle = NULL;
  24 HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};
  25 GUID_INFO_BLOCK   *mGuidList;
  26 UINTN             mGuidListCount;
  27
  28 /**
  29   Function to find the file name associated with a LoadedImageProtocol.
  30
  31   @param[in] LoadedImage     An instance of LoadedImageProtocol.
  32
  33   @retval                    A string representation of the file name associated
  34                              with LoadedImage, or NULL if no name can be found.
  35 **/
  36 CHAR16*
  37 FindLoadedImageFileName (
  38   IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage
  39   )
  40 {
  41   EFI_GUID                       *NameGuid;
  42   EFI_STATUS                     Status;
  43   EFI_FIRMWARE_VOLUME2_PROTOCOL  *Fv;
  44   VOID                           *Buffer;
  45   UINTN                          BufferSize;
  46   UINT32                         AuthenticationStatus;
  47
  48   if ((LoadedImage == NULL) || (LoadedImage->FilePath == NULL)) {
  49     return NULL;
  50   }
  51
  52   NameGuid = EfiGetNameGuidFromFwVolDevicePathNode((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)LoadedImage->FilePath);
  53
  54   if (NameGuid == NULL) {
  55     return NULL;
  56   }
  57
  58   //
  59   // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.
  60   //
  61   Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**) &Fv);
  62
  63   //
  64   // FirmwareVolume2Protocol is PI, and is not required to be available.
  65   //
  66   if (EFI_ERROR (Status)) {
  67     return NULL;
  68   }
  69
  70   //
  71   // Read the user interface section of the image.
  72   //
  73   Buffer = NULL;
  74   Status = Fv->ReadSection(Fv, NameGuid, EFI_SECTION_USER_INTERFACE, 0, &Buffer, &BufferSize, &AuthenticationStatus);
  75
  76   if (EFI_ERROR (Status)) {
  77     return NULL;
  78   }
  79
  80   //
  81   // ReadSection returns just the section data, without any section header. For
  82   // a user interface section, the only data is the file name.
  83   //
  84   return Buffer;
  85 }
  86
  87 /**
  88   Function to translate the EFI_MEMORY_TYPE into a string.
  89
  90   @param[in] Memory     The memory type.
  91
  92   @retval               A string representation of the type allocated from BS Pool.
  93 **/
  94 CHAR16*
  95 ConvertMemoryType (
  96   IN CONST EFI_MEMORY_TYPE Memory
  97   )
  98 {
  99   CHAR16 *RetVal;
 100   RetVal = NULL;
 101
 102   switch (Memory) {
 103   case EfiReservedMemoryType:       StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0);        break;
 104   case EfiLoaderCode:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0);                break;
 105   case EfiLoaderData:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0);                break;
 106   case EfiBootServicesCode:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0);          break;
 107   case EfiBootServicesData:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0);          break;
 108   case EfiRuntimeServicesCode:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0);       break;
 109   case EfiRuntimeServicesData:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0);       break;
 110   case EfiConventionalMemory:       StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0);        break;
 111   case EfiUnusableMemory:           StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0);            break;
 112   case EfiACPIReclaimMemory:        StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0);         break;
 113   case EfiACPIMemoryNVS:            StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0);             break;
 114   case EfiMemoryMappedIO:           StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0);            break;
 115   case EfiMemoryMappedIOPortSpace:  StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0);   break;
 116   case EfiPalCode:                  StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0);                   break;
 117   case EfiMaxMemoryType:            StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0);             break;
 118   default: ASSERT(FALSE);
 119   }
 120   return (RetVal);
 121 }
 122
 123 /**
 124   Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
 125
 126   @param[in] Fmt     The format type.
 127
 128   @retval               A string representation of the type allocated from BS Pool.
 129 **/
 130 CHAR16*
 131 ConvertPixelFormat (
 132   IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
 133   )
 134 {
 135   CHAR16 *RetVal;
 136   RetVal = NULL;
 137
 138   switch (Fmt) {
 139   case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0);  break;
 140   case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0);  break;
 141   case PixelBitMask:                          StrnCatGrow(&RetVal, NULL, L"PixelBitMask", 0);                           break;
 142   case PixelBltOnly:                          StrnCatGrow(&RetVal, NULL, L"PixelBltOnly", 0);                           break;
 143   case PixelFormatMax:                        StrnCatGrow(&RetVal, NULL, L"PixelFormatMax", 0);                         break;
 144   default: ASSERT(FALSE);
 145   }
 146   return (RetVal);
 147 }
 148
 149 /**
 150   Constructor for the library.
 151
 152   @param[in] ImageHandle    Ignored.
 153   @param[in] SystemTable    Ignored.
 154
 155   @retval EFI_SUCCESS   The operation was successful.
 156 **/
 157 EFI_STATUS
 158 EFIAPI
 159 HandleParsingLibConstructor (
 160   IN EFI_HANDLE        ImageHandle,
 161   IN EFI_SYSTEM_TABLE  *SystemTable
 162   )
 163 {
 164   mGuidListCount = 0;
 165   mGuidList      = NULL;
 166
 167   //
 168   // Do nothing with mHandleParsingHiiHandle.  Initialize HII as needed.
 169   //
 170   return (EFI_SUCCESS);
 171 }
 172
 173 /**
 174   Initialization function for HII packages.
 175
 176 **/
 177 VOID
 178 HandleParsingHiiInit (VOID)
 179 {
 180   if (mHandleParsingHiiHandle == NULL) {
 181     mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);
 182     ASSERT (mHandleParsingHiiHandle != NULL);
 183   }
 184 }
 185
 186 /**
 187   Destructor for the library.  free any resources.
 188
 189   @param[in] ImageHandle    Ignored.
 190   @param[in] SystemTable    Ignored.
 191
 192   @retval EFI_SUCCESS   The operation was successful.
 193 **/
 194 EFI_STATUS
 195 EFIAPI
 196 HandleParsingLibDestructor (
 197   IN EFI_HANDLE        ImageHandle,
 198   IN EFI_SYSTEM_TABLE  *SystemTable
 199   )
 200 {
 201   UINTN                 LoopCount;
 202
 203   for (LoopCount = 0; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++) {
 204     SHELL_FREE_NON_NULL(mGuidList[LoopCount].GuidId);
 205   }
 206
 207   SHELL_FREE_NON_NULL(mGuidList);
 208   if (mHandleParsingHiiHandle != NULL) {
 209     HiiRemovePackages(mHandleParsingHiiHandle);
 210   }
 211   return (EFI_SUCCESS);
 212 }
 213
 214 /**
 215   Function to dump information about LoadedImage.
 216
 217   This will allocate the return buffer from boot services pool.
 218
 219   @param[in] TheHandle      The handle that has LoadedImage installed.
 220   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 221
 222   @retval A poitner to a string containing the information.
 223 **/
 224 CHAR16*
 225 EFIAPI
 226 LoadedImageProtocolDumpInformation(
 227   IN CONST EFI_HANDLE TheHandle,
 228   IN CONST BOOLEAN    Verbose
 229   )
 230 {
 231   EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;
 232   EFI_STATUS                        Status;
 233   CHAR16                            *RetVal;
 234   CHAR16                            *Temp;
 235   CHAR16                            *FileName;
 236   CHAR8                             *PdbFileName;
 237   CHAR16                            *FilePath;
 238   CHAR16                            *CodeType;
 239   CHAR16                            *DataType;
 240
 241   Status = gBS->OpenProtocol (
 242                 TheHandle,
 243                 &gEfiLoadedImageProtocolGuid,
 244                 (VOID**)&LoadedImage,
 245                 gImageHandle,
 246                 NULL,
 247                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 248                );
 249
 250   if (EFI_ERROR (Status)) {
 251     return NULL;
 252   }
 253
 254   FileName = FindLoadedImageFileName(LoadedImage);
 255   FilePath = ConvertDevicePathToText(LoadedImage->FilePath, TRUE, TRUE);
 256   if (!Verbose) {
 257     if (FileName == NULL) {
 258       FileName = FilePath;
 259     } else {
 260       SHELL_FREE_NON_NULL(FilePath);
 261     }
 262     RetVal = CatSPrint(NULL, FileName);
 263     SHELL_FREE_NON_NULL(FileName);
 264     return RetVal;
 265   }
 266
 267   HandleParsingHiiInit();
 268   RetVal = NULL;
 269   if (FileName != NULL) {
 270     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_NAME), NULL);
 271
 272     if (Temp != NULL) {
 273       RetVal = CatSPrint(NULL, Temp, FileName);
 274     }
 275
 276     SHELL_FREE_NON_NULL(Temp);
 277     SHELL_FREE_NON_NULL(FileName);
 278   }
 279
 280   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);
 281   if (Temp == NULL) {
 282     return NULL;
 283   }
 284   PdbFileName = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase);
 285   DataType = ConvertMemoryType(LoadedImage->ImageDataType);
 286   CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);
 287
 288   RetVal = CatSPrint(
 289              RetVal,
 290              Temp,
 291              LoadedImage->Revision,
 292              LoadedImage->ParentHandle,
 293              LoadedImage->SystemTable,
 294              LoadedImage->DeviceHandle,
 295              FilePath,
 296              PdbFileName,
 297              LoadedImage->LoadOptionsSize,
 298              LoadedImage->LoadOptions,
 299              LoadedImage->ImageBase,
 300              LoadedImage->ImageSize,
 301              CodeType,
 302              DataType,
 303              LoadedImage->Unload
 304              );
 305
 306
 307   SHELL_FREE_NON_NULL(Temp);
 308   SHELL_FREE_NON_NULL(FilePath);
 309   SHELL_FREE_NON_NULL(CodeType);
 310   SHELL_FREE_NON_NULL(DataType);
 311
 312   return RetVal;
 313 }
 314
 315 /**
 316   Function to dump information about GOP.
 317
 318   This will allocate the return buffer from boot services pool.
 319
 320   @param[in] TheHandle      The handle that has LoadedImage installed.
 321   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 322
 323   @retval A poitner to a string containing the information.
 324 **/
 325 CHAR16*
 326 EFIAPI
 327 GraphicsOutputProtocolDumpInformation(
 328   IN CONST EFI_HANDLE TheHandle,
 329   IN CONST BOOLEAN    Verbose
 330   )
 331 {
 332   EFI_GRAPHICS_OUTPUT_PROTOCOL          *GraphicsOutput;
 333   EFI_STATUS                            Status;
 334   CHAR16                                *RetVal;
 335   CHAR16                                *Temp;
 336   CHAR16                                *Fmt;
 337   CHAR16                                *TempRetVal;
 338   UINTN                                 GopInfoSize;
 339   UINT32                                Mode;
 340   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *GopInfo;
 341
 342   if (!Verbose) {
 343     return (CatSPrint(NULL, L"GraphicsOutput"));
 344   }
 345
 346   HandleParsingHiiInit();
 347
 348   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);
 349   if (Temp == NULL) {
 350     return NULL;
 351   }
 352
 353   Status = gBS->OpenProtocol (
 354                 TheHandle,
 355                 &gEfiGraphicsOutputProtocolGuid,
 356                 (VOID**)&GraphicsOutput,
 357                 gImageHandle,
 358                 NULL,
 359                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 360                );
 361
 362   if (EFI_ERROR (Status)) {
 363     SHELL_FREE_NON_NULL (Temp);
 364     return NULL;
 365   }
 366
 367   Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);
 368
 369   RetVal = CatSPrint(
 370              NULL,
 371              Temp,
 372              GraphicsOutput->Mode->MaxMode,
 373              GraphicsOutput->Mode->Mode,
 374              GraphicsOutput->Mode->FrameBufferBase,
 375              (UINT64)GraphicsOutput->Mode->FrameBufferSize,
 376              (UINT64)GraphicsOutput->Mode->SizeOfInfo,
 377              GraphicsOutput->Mode->Info->Version,
 378              GraphicsOutput->Mode->Info->HorizontalResolution,
 379              GraphicsOutput->Mode->Info->VerticalResolution,
 380              Fmt,
 381              GraphicsOutput->Mode->Info->PixelsPerScanLine,
 382              GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.RedMask,
 383              GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.GreenMask,
 384              GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask
 385              );
 386
 387   SHELL_FREE_NON_NULL (Temp);
 388
 389   Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_MAIN), NULL);
 390   if (Temp == NULL) {
 391     SHELL_FREE_NON_NULL (RetVal);
 392     goto EXIT;
 393   }
 394
 395   TempRetVal = CatSPrint (RetVal, Temp);
 396   SHELL_FREE_NON_NULL (RetVal);
 397   if (TempRetVal == NULL) {
 398     goto EXIT;
 399   }
 400   RetVal = TempRetVal;
 401   SHELL_FREE_NON_NULL (Temp);
 402
 403   Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY), NULL);
 404   if (Temp == NULL) {
 405     SHELL_FREE_NON_NULL (RetVal);
 406     goto EXIT;
 407   }
 408
 409
 410   for (Mode = 0; Mode < GraphicsOutput->Mode->MaxMode; Mode++) {
 411     Status = GraphicsOutput->QueryMode (
 412                                GraphicsOutput,
 413                                Mode,
 414                                &GopInfoSize,
 415                                &GopInfo
 416                                );
 417     if (EFI_ERROR (Status)) {
 418       continue;
 419     }
 420
 421     TempRetVal = CatSPrint (
 422                    RetVal,
 423                    Temp,
 424                    Mode,
 425                    GopInfo->HorizontalResolution,
 426                    GopInfo->VerticalResolution
 427                    );
 428
 429     SHELL_FREE_NON_NULL (GopInfo);
 430     SHELL_FREE_NON_NULL (RetVal);
 431     RetVal = TempRetVal;
 432   }
 433
 434
 435 EXIT:
 436   SHELL_FREE_NON_NULL(Temp);
 437   SHELL_FREE_NON_NULL(Fmt);
 438
 439   return RetVal;
 440 }
 441
 442 /**
 443   Function to dump information about EDID Discovered Protocol.
 444
 445   This will allocate the return buffer from boot services pool.
 446
 447   @param[in] TheHandle      The handle that has LoadedImage installed.
 448   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 449
 450   @retval A pointer to a string containing the information.
 451 **/
 452 CHAR16*
 453 EFIAPI
 454 EdidDiscoveredProtocolDumpInformation (
 455   IN CONST EFI_HANDLE TheHandle,
 456   IN CONST BOOLEAN    Verbose
 457   )
 458 {
 459   EFI_EDID_DISCOVERED_PROTOCOL          *EdidDiscovered;
 460   EFI_STATUS                            Status;
 461   CHAR16                                *RetVal;
 462   CHAR16                                *Temp;
 463   CHAR16                                *TempRetVal;
 464
 465   if (!Verbose) {
 466     return (CatSPrint (NULL, L"EDIDDiscovered"));
 467   }
 468
 469   Status = gBS->OpenProtocol (
 470                   TheHandle,
 471                   &gEfiEdidDiscoveredProtocolGuid,
 472                   (VOID**)&EdidDiscovered,
 473                   NULL,
 474                   NULL,
 475                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 476                   );
 477
 478   if (EFI_ERROR (Status)) {
 479     return NULL;
 480   }
 481
 482   Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN), NULL);
 483   if (Temp == NULL) {
 484     return NULL;
 485   }
 486
 487   RetVal = CatSPrint (NULL, Temp, EdidDiscovered->SizeOfEdid);
 488   SHELL_FREE_NON_NULL (Temp);
 489
 490   if (EdidDiscovered->SizeOfEdid != 0) {
 491     Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_DATA), NULL);
 492     if (Temp == NULL) {
 493       SHELL_FREE_NON_NULL (RetVal);
 494       return NULL;
 495     }
 496     TempRetVal = CatSPrint (RetVal, Temp);
 497     SHELL_FREE_NON_NULL (RetVal);
 498     RetVal = TempRetVal;
 499
 500     TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidDiscovered->SizeOfEdid, EdidDiscovered->Edid);
 501     RetVal = TempRetVal;
 502   }
 503   return RetVal;
 504 }
 505
 506 /**
 507   Function to dump information about EDID Active Protocol.
 508
 509   This will allocate the return buffer from boot services pool.
 510
 511   @param[in] TheHandle      The handle that has LoadedImage installed.
 512   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 513
 514   @retval A pointer to a string containing the information.
 515 **/
 516 CHAR16*
 517 EFIAPI
 518 EdidActiveProtocolDumpInformation (
 519   IN CONST EFI_HANDLE TheHandle,
 520   IN CONST BOOLEAN    Verbose
 521   )
 522 {
 523   EFI_EDID_ACTIVE_PROTOCOL  *EdidActive;
 524   EFI_STATUS                Status;
 525   CHAR16                    *RetVal;
 526   CHAR16                    *Temp;
 527   CHAR16                    *TempRetVal;
 528
 529   if (!Verbose) {
 530     return (CatSPrint (NULL, L"EDIDActive"));
 531   }
 532
 533   Status = gBS->OpenProtocol (
 534                   TheHandle,
 535                   &gEfiEdidActiveProtocolGuid,
 536                   (VOID**)&EdidActive,
 537                   NULL,
 538                   NULL,
 539                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 540                   );
 541
 542   if (EFI_ERROR (Status)) {
 543     return NULL;
 544   }
 545
 546   Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_MAIN), NULL);
 547   if (Temp == NULL) {
 548     return NULL;
 549   }
 550
 551   RetVal = CatSPrint (NULL, Temp, EdidActive->SizeOfEdid);
 552   SHELL_FREE_NON_NULL (Temp);
 553
 554   if (EdidActive->SizeOfEdid != 0) {
 555     Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_DATA), NULL);
 556     if (Temp == NULL) {
 557       SHELL_FREE_NON_NULL (RetVal);
 558       return NULL;
 559     }
 560     TempRetVal = CatSPrint (RetVal, Temp);
 561     SHELL_FREE_NON_NULL (RetVal);
 562     RetVal = TempRetVal;
 563
 564     TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidActive->SizeOfEdid, EdidActive->Edid);
 565     RetVal = TempRetVal;
 566   }
 567   return RetVal;
 568 }
 569
 570 /**
 571   Function to dump information about PciRootBridgeIo.
 572
 573   This will allocate the return buffer from boot services pool.
 574
 575   @param[in] TheHandle      The handle that has PciRootBridgeIo installed.
 576   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 577
 578   @retval A poitner to a string containing the information.
 579 **/
 580 CHAR16*
 581 EFIAPI
 582 PciRootBridgeIoDumpInformation(
 583   IN CONST EFI_HANDLE TheHandle,
 584   IN CONST BOOLEAN    Verbose
 585   )
 586 {
 587   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   *PciRootBridgeIo;
 588   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;
 589   UINT64                            Supports;
 590   UINT64                            Attributes;
 591   CHAR16                            *Temp;
 592   CHAR16                            *Temp2;
 593   CHAR16                            *RetVal;
 594   EFI_STATUS                        Status;
 595
 596   RetVal  = NULL;
 597
 598   if (!Verbose) {
 599     return (CatSPrint(NULL, L"PciRootBridgeIo"));
 600   }
 601
 602   HandleParsingHiiInit();
 603
 604   Status = gBS->HandleProtocol(
 605     TheHandle,
 606     &gEfiPciRootBridgeIoProtocolGuid,
 607     (VOID**)&PciRootBridgeIo);
 608
 609   if (EFI_ERROR(Status)) {
 610     return NULL;
 611   }
 612
 613   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_PH), NULL);
 614   if (Temp == NULL) {
 615     return NULL;
 616   }
 617   Temp2 = CatSPrint(NULL, Temp, PciRootBridgeIo->ParentHandle);
 618   FreePool(Temp);
 619   RetVal = Temp2;
 620   Temp2 = NULL;
 621
 622   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);
 623   if (Temp == NULL) {
 624     SHELL_FREE_NON_NULL(RetVal);
 625     return NULL;
 626   }
 627   Temp2 = CatSPrint(RetVal, Temp, PciRootBridgeIo->SegmentNumber);
 628   FreePool(Temp);
 629   FreePool(RetVal);
 630   RetVal = Temp2;
 631   Temp2 = NULL;
 632
 633   Supports   = 0;
 634   Attributes = 0;
 635   Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);
 636   if (!EFI_ERROR(Status)) {
 637     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_ATT), NULL);
 638     if (Temp == NULL) {
 639       SHELL_FREE_NON_NULL(RetVal);
 640       return NULL;
 641     }
 642     Temp2 = CatSPrint(RetVal, Temp, Attributes);
 643     FreePool(Temp);
 644     FreePool(RetVal);
 645     RetVal = Temp2;
 646     Temp2 = NULL;
 647
 648     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);
 649     if (Temp == NULL) {
 650       SHELL_FREE_NON_NULL(RetVal);
 651       return NULL;
 652     }
 653     Temp2 = CatSPrint(RetVal, Temp, Supports);
 654     FreePool(Temp);
 655     FreePool(RetVal);
 656     RetVal = Temp2;
 657     Temp2 = NULL;
 658   }
 659
 660   Configuration   = NULL;
 661   Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);
 662   if (!EFI_ERROR(Status) && Configuration != NULL) {
 663     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_TITLE), NULL);
 664     if (Temp == NULL) {
 665       SHELL_FREE_NON_NULL(RetVal);
 666       return NULL;
 667     }
 668     Temp2 = CatSPrint(RetVal, Temp, Supports);
 669     FreePool(Temp);
 670     FreePool(RetVal);
 671     RetVal = Temp2;
 672     Temp2 = NULL;
 673     while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {
 674       Temp = NULL;
 675       switch (Configuration->ResType) {
 676       case ACPI_ADDRESS_SPACE_TYPE_MEM:
 677         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_MEM), NULL);
 678         break;
 679       case ACPI_ADDRESS_SPACE_TYPE_IO:
 680         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_IO), NULL);
 681         break;
 682       case ACPI_ADDRESS_SPACE_TYPE_BUS:
 683         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_BUS), NULL);
 684         break;
 685       }
 686       if (Temp != NULL) {
 687         Temp2 = CatSPrint(RetVal, L"%s", Temp);
 688         FreePool(Temp);
 689         FreePool(RetVal);
 690         RetVal = Temp2;
 691         Temp2 = NULL;
 692       }
 693
 694       Temp2 = CatSPrint(RetVal,
 695         L"\r\n%%H%02x    %016lx  %016lx  %02x%%N",
 696         Configuration->SpecificFlag,
 697         Configuration->AddrRangeMin,
 698         Configuration->AddrRangeMax,
 699         Configuration->AddrSpaceGranularity
 700         );
 701       FreePool(RetVal);
 702       RetVal = Temp2;
 703       Temp2 = NULL;
 704       Configuration++;
 705     }
 706   }
 707   return (RetVal);
 708 }
 709
 710 /**
 711   Function to dump information about SimpleTextOut.
 712
 713   This will allocate the return buffer from boot services pool.
 714
 715   @param[in] TheHandle      The handle that has SimpleTextOut installed.
 716   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 717
 718   @retval A poitner to a string containing the information.
 719 **/
 720 CHAR16*
 721 EFIAPI
 722 TxtOutProtocolDumpInformation(
 723   IN CONST EFI_HANDLE TheHandle,
 724   IN CONST BOOLEAN    Verbose
 725   )
 726 {
 727   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Dev;
 728   INTN                            Index;
 729   UINTN                           Col;
 730   UINTN                           Row;
 731   EFI_STATUS                      Status;
 732   CHAR16                          *RetVal;
 733   UINTN                           Size;
 734   CHAR16                          *Temp;
 735   UINTN                           NewSize;
 736
 737   if (!Verbose) {
 738     return (NULL);
 739   }
 740
 741   HandleParsingHiiInit();
 742
 743   RetVal  = NULL;
 744   Size    = 0;
 745
 746   Status = gBS->HandleProtocol(
 747     TheHandle,
 748     &gEfiSimpleTextOutProtocolGuid,
 749     (VOID**)&Dev);
 750
 751   ASSERT_EFI_ERROR(Status);
 752   ASSERT (Dev != NULL && Dev->Mode != NULL);
 753
 754   Size = (Dev->Mode->MaxMode + 1) * 80;
 755   RetVal = AllocateZeroPool(Size);
 756
 757   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER), NULL);
 758   if (Temp != NULL) {
 759     UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);
 760     FreePool(Temp);
 761   }
 762
 763   //
 764   // Dump TextOut Info
 765   //
 766   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE), NULL);
 767   for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {
 768     Status = Dev->QueryMode (Dev, Index, &Col, &Row);
 769     NewSize = Size - StrSize(RetVal);
 770     UnicodeSPrint(
 771       RetVal + StrLen(RetVal),
 772       NewSize,
 773       Temp == NULL?L"":Temp,
 774       Index == Dev->Mode->Mode ? L'*' : L' ',
 775       Index,
 776       !EFI_ERROR(Status)?(INTN)Col:-1,
 777       !EFI_ERROR(Status)?(INTN)Row:-1
 778      );
 779   }
 780   FreePool(Temp);
 781   return (RetVal);
 782 }
 783
 784 STATIC CONST UINTN VersionStringSize = 60;
 785
 786 /**
 787   Function to dump information about EfiDriverSupportedEfiVersion protocol.
 788
 789   This will allocate the return buffer from boot services pool.
 790
 791   @param[in] TheHandle      The handle that has the protocol installed.
 792   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 793
 794   @retval A poitner to a string containing the information.
 795 **/
 796 CHAR16*
 797 EFIAPI
 798 DriverEfiVersionProtocolDumpInformation(
 799   IN CONST EFI_HANDLE TheHandle,
 800   IN CONST BOOLEAN    Verbose
 801   )
 802 {
 803   EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
 804   EFI_STATUS                                Status;
 805   CHAR16                                    *RetVal;
 806
 807   Status = gBS->HandleProtocol(
 808     TheHandle,
 809     &gEfiDriverSupportedEfiVersionProtocolGuid,
 810     (VOID**)&DriverEfiVersion);
 811
 812   ASSERT_EFI_ERROR(Status);
 813
 814   RetVal = AllocateZeroPool(VersionStringSize);
 815   if (RetVal != NULL) {
 816     UnicodeSPrint (RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);
 817   }
 818   return (RetVal);
 819 }
 820 /**
 821   Function to convert device path to string.
 822
 823   This will allocate the return buffer from boot services pool.
 824
 825   @param[in] DevPath        Pointer to device path instance.
 826   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 827   @param[in] Length         Maximum allowed text length of the device path.
 828
 829   @retval A pointer to a string containing the information.
 830 **/
 831 CHAR16*
 832 ConvertDevicePathToShortText(
 833   IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,
 834   IN CONST BOOLEAN                  Verbose,
 835   IN CONST UINTN                    Length
 836   )
 837 {
 838   CHAR16                            *Temp;
 839   CHAR16                            *Temp2;
 840   UINTN                             Size;
 841
 842   //
 843   // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
 844   //
 845   Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);
 846   if (!Verbose && Temp != NULL && StrLen(Temp) > Length) {
 847     Temp2 = NULL;
 848     Size  = 0;
 849     Temp2 = StrnCatGrow(&Temp2, &Size, L"..", 0);
 850     Temp2 = StrnCatGrow(&Temp2, &Size, Temp+(StrLen(Temp) - (Length - 2)), 0);
 851     FreePool(Temp);
 852     Temp = Temp2;
 853   }
 854   return (Temp);
 855 }
 856
 857 /**
 858   Function to dump protocol information.
 859
 860   This will allocate the return buffer from boot services pool.
 861
 862   @param[in] TheHandle      The handle that has the protocol installed.
 863   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 864   @param[in] Protocol       The protocol is needed to dump.
 865
 866   @retval A pointer to a string containing the information.
 867 **/
 868 STATIC CHAR16*
 869 EFIAPI
 870 DevicePathProtocolDumpInformationEx (
 871   IN CONST EFI_HANDLE   TheHandle,
 872   IN CONST BOOLEAN      Verbose,
 873   IN       EFI_GUID     *Protocol
 874 )
 875 {
 876   EFI_DEVICE_PATH_PROTOCOL          *DevPath;
 877   CHAR16                            *DevPathStr;
 878   CHAR16                            *DevPathStrTemp;
 879   UINTN                             Size;
 880   EFI_STATUS                        Status;
 881   DevPathStr     = NULL;
 882   DevPathStrTemp = NULL;
 883   Status = gBS->OpenProtocol(TheHandle, Protocol, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 884   if (!EFI_ERROR(Status)) {
 885     DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);
 886     if (Verbose) {
 887       Size = StrSize(DevPathStr) + sizeof(CHAR16) * 2;
 888       DevPathStrTemp = AllocateZeroPool (Size);
 889       if (DevPathStrTemp != NULL) {
 890         StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), L"  ", 2);
 891         StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), DevPathStr, StrLen (DevPathStr));
 892       }
 893       FreePool (DevPathStr);
 894       DevPathStr = DevPathStrTemp;
 895     }
 896     gBS->CloseProtocol(TheHandle, Protocol, gImageHandle, NULL);
 897   }
 898   return DevPathStr;
 899 }
 900
 901 /**
 902   Function to dump information about DevicePath protocol.
 903
 904   This will allocate the return buffer from boot services pool.
 905
 906   @param[in] TheHandle      The handle that has the protocol installed.
 907   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 908
 909   @retval A pointer to a string containing the information.
 910 **/
 911 CHAR16*
 912 EFIAPI
 913 DevicePathProtocolDumpInformation(
 914   IN CONST EFI_HANDLE TheHandle,
 915   IN CONST BOOLEAN    Verbose
 916   )
 917 {
 918   return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);
 919 }
 920
 921 /**
 922   Function to dump information about LoadedImageDevicePath protocol.
 923
 924   This will allocate the return buffer from boot services pool.
 925
 926   @param[in] TheHandle      The handle that has the protocol installed.
 927   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 928
 929   @retval A pointer to a string containing the information.
 930 **/
 931 CHAR16*
 932 EFIAPI
 933 LoadedImageDevicePathProtocolDumpInformation(
 934   IN CONST EFI_HANDLE TheHandle,
 935   IN CONST BOOLEAN    Verbose
 936   )
 937 {
 938   return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);
 939 }
 940
 941 /**
 942   Function to dump information about BusSpecificDriverOverride protocol.
 943
 944   This will allocate the return buffer from boot services pool.
 945
 946   @param[in] TheHandle      The handle that has the protocol installed.
 947   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 948
 949   @retval A pointer to a string containing the information.
 950 **/
 951 CHAR16*
 952 EFIAPI
 953 BusSpecificDriverOverrideProtocolDumpInformation (
 954   IN CONST EFI_HANDLE TheHandle,
 955   IN CONST BOOLEAN    Verbose
 956   )
 957 {
 958   EFI_STATUS                                Status;
 959   CHAR16                                    *GetString;
 960   CHAR16                                    *RetVal;
 961   CHAR16                                    *TempRetVal;
 962   EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
 963   EFI_LOADED_IMAGE_PROTOCOL                 *LoadedImage;
 964   EFI_HANDLE                                ImageHandle;
 965   UINTN                                     Size;
 966
 967   if (!Verbose) {
 968     return NULL;
 969   }
 970   Size        = 0;
 971   GetString   = NULL;
 972   RetVal      = NULL;
 973   TempRetVal  = NULL;
 974   ImageHandle = 0;
 975
 976   Status = gBS->OpenProtocol (
 977                   TheHandle,
 978                   &gEfiBusSpecificDriverOverrideProtocolGuid,
 979                   (VOID**)&BusSpecificDriverOverride,
 980                   gImageHandle,
 981                   NULL,
 982                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 983                   );
 984   if (EFI_ERROR (Status)) {
 985     return NULL;
 986   }
 987   HandleParsingHiiInit ();
 988   GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BSDO_DUMP_MAIN), NULL);
 989   if (GetString == NULL) {
 990     return NULL;
 991   }
 992   do {
 993     Status = BusSpecificDriverOverride->GetDriver (
 994                                           BusSpecificDriverOverride,
 995                                           &ImageHandle
 996                                           );
 997     if (!EFI_ERROR (Status)) {
 998       Status = gBS->HandleProtocol (
 999                       ImageHandle,
1000                       &gEfiLoadedImageProtocolGuid,
1001                       (VOID **) &LoadedImage
1002                       );
1003       if(!EFI_ERROR (Status)) {
1004         TempRetVal = CatSPrint (
1005                        TempRetVal,
1006                        GetString,
1007                        ConvertHandleToHandleIndex (ImageHandle),
1008                        ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE)
1009                        );
1010         StrnCatGrow (&RetVal, &Size, TempRetVal, 0);
1011         SHELL_FREE_NON_NULL (TempRetVal);
1012       }
1013     }
1014   } while (!EFI_ERROR (Status));
1015
1016   SHELL_FREE_NON_NULL (GetString);
1017   return RetVal;
1018 }
1019
1020 /**
1021   Function to dump information about BlockIo protocol.
1022
1023   This will allocate the return buffer from boot services pool.
1024
1025   @param[in] TheHandle      The handle that has the protocol installed.
1026   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1027
1028   @retval A pointer to a string containing the information.
1029 **/
1030 CHAR16*
1031 EFIAPI
1032 BlockIoProtocolDumpInformation (
1033   IN CONST EFI_HANDLE TheHandle,
1034   IN CONST BOOLEAN    Verbose
1035   )
1036 {
1037   EFI_STATUS            Status;
1038   EFI_BLOCK_IO_PROTOCOL *BlockIo;
1039   EFI_BLOCK_IO_MEDIA    *BlockMedia;
1040   CHAR16                *GetString;
1041   CHAR16                *RetVal;
1042
1043   if (!Verbose) {
1044     return NULL;
1045   }
1046   GetString   = NULL;
1047   RetVal = NULL;
1048
1049   Status = gBS->OpenProtocol (
1050                 TheHandle,
1051                 &gEfiBlockIoProtocolGuid,
1052                 (VOID**)&BlockIo,
1053                 gImageHandle,
1054                 NULL,
1055                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1056                 );
1057   if (EFI_ERROR (Status)) {
1058     return NULL;
1059   }
1060   BlockMedia = BlockIo->Media;
1061   //
1062   // Per spec:
1063   //   The function (ReadBlocks) must return EFI_NO_MEDIA or
1064   //   EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1065   //   for changes in media state.
1066   //
1067   BlockIo->ReadBlocks (
1068              BlockIo,
1069              BlockIo->Media->MediaId,
1070              0,
1071              0,
1072              NULL
1073              );
1074
1075   HandleParsingHiiInit ();
1076   GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BLOCKIO_INFO), NULL);
1077   if (GetString == NULL) {
1078     return NULL;
1079   }
1080   RetVal = CatSPrint (
1081             RetVal,
1082             GetString,
1083             BlockMedia->RemovableMedia ? L"Removable " : L"Fixed ",
1084             BlockMedia->MediaPresent ? L"" : L"not-present ",
1085             BlockMedia->MediaId,
1086             BlockMedia->BlockSize,
1087             BlockMedia->LastBlock,
1088             MultU64x32 (BlockMedia->LastBlock + 1, BlockMedia->BlockSize),
1089             BlockMedia->LogicalPartition ? L"partition" : L"raw",
1090             BlockMedia->ReadOnly ? L"ro" : L"rw",
1091             BlockMedia->WriteCaching ? L"cached" : L"!cached"
1092             );
1093
1094   SHELL_FREE_NON_NULL (GetString);
1095   return RetVal;
1096 }
1097
1098 /**
1099   Function to dump information about DebugSupport Protocol.
1100
1101   @param[in] TheHandle      The handle that has the protocol installed.
1102   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1103
1104   @retval A pointer to a string containing the information.
1105 **/
1106 CHAR16*
1107 EFIAPI
1108 DebugSupportProtocolDumpInformation (
1109   IN CONST EFI_HANDLE TheHandle,
1110   IN CONST BOOLEAN    Verbose
1111   )
1112 {
1113   EFI_STATUS                  Status;
1114   EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupport;
1115   CHAR16                      *GetString;
1116   CHAR16                      *RetVal;
1117
1118   if (!Verbose) {
1119     return NULL;
1120   }
1121   GetString = NULL;
1122   RetVal = NULL;
1123   Status = gBS->OpenProtocol (
1124                 TheHandle,
1125                 &gEfiDebugSupportProtocolGuid,
1126                 (VOID**)&DebugSupport,
1127                 gImageHandle,
1128                 NULL,
1129                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1130                 );
1131   if (EFI_ERROR (Status)) {
1132     return NULL;
1133   }
1134   HandleParsingHiiInit ();
1135   GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_INFO), NULL);
1136   if (GetString == NULL) {
1137     return NULL;
1138   }
1139   //
1140   // Dump Debug support info
1141   //
1142   switch (DebugSupport->Isa) {
1143   case (IsaIa32):
1144     RetVal = CatSPrint (RetVal, GetString, L"IA-32");
1145     break;
1146   case (IsaIpf):
1147     RetVal = CatSPrint (RetVal, GetString, L"IPF");
1148     break;
1149   case (IsaEbc):
1150     RetVal = CatSPrint (RetVal, GetString, L"EBC");
1151     break;
1152   default:
1153     SHELL_FREE_NON_NULL (GetString);
1154     GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN), NULL);
1155     RetVal = GetString != NULL ? CatSPrint (RetVal, GetString, DebugSupport->Isa) : NULL;
1156     break;
1157   }
1158
1159   SHELL_FREE_NON_NULL (GetString);
1160   return RetVal;
1161 }
1162
1163 /**
1164   Function to dump information about PciIoProtocol.
1165
1166   This will allocate the return buffer from boot services pool.
1167
1168   @param[in] TheHandle      The handle that has PciRootBridgeIo installed.
1169   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1170
1171   @retval A poitner to a string containing the information.
1172 **/
1173 CHAR16*
1174 EFIAPI
1175 PciIoProtocolDumpInformation (
1176   IN CONST EFI_HANDLE TheHandle,
1177   IN CONST BOOLEAN    Verbose
1178   )
1179 {
1180   EFI_STATUS              Status;
1181   EFI_PCI_IO_PROTOCOL     *PciIo;
1182   PCI_TYPE00              Pci;
1183   UINTN                   Segment;
1184   UINTN                   Bus;
1185   UINTN                   Device;
1186   UINTN                   Function;
1187   UINTN                   Index;
1188   CHAR16                  *GetString;
1189   CHAR16                  *TempRetVal;
1190   CHAR16                  *RetVal;
1191
1192   if (!Verbose) {
1193     return (NULL);
1194   }
1195   RetVal = NULL;
1196   GetString   = NULL;
1197   TempRetVal  = NULL;
1198   Status = gBS->OpenProtocol (
1199                   TheHandle,
1200                   &gEfiPciIoProtocolGuid,
1201                   (VOID**)&PciIo,
1202                   gImageHandle,
1203                   NULL,
1204                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1205                   );
1206
1207   if (EFI_ERROR(Status)) {
1208     return NULL;
1209   }
1210   PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
1211   PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);
1212   HandleParsingHiiInit ();
1213   GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIIO_DUMP_MAIN), NULL);
1214   if (GetString == NULL) {
1215     return NULL;
1216   }
1217   RetVal = CatSPrint (
1218             NULL,
1219             GetString,
1220             Segment,
1221             Bus,
1222             Device,
1223             Function,
1224             PciIo->RomSize,
1225             PciIo->RomImage,
1226             Pci.Hdr.VendorId,
1227             Pci.Hdr.DeviceId,
1228             Pci.Hdr.ClassCode[0],
1229             Pci.Hdr.ClassCode[1],
1230             Pci.Hdr.ClassCode[2]
1231             );
1232   for (Index = 0; Index < sizeof (Pci); Index ++) {
1233     if ((Index % 0x10) == 0) {
1234       TempRetVal = CatSPrint (RetVal, L"\r\n       %02x", *((UINT8 *) (&Pci) + Index));
1235     } else {
1236       TempRetVal = CatSPrint (RetVal, L"%02x", *((UINT8 *) (&Pci) + Index));
1237     }
1238     FreePool (RetVal);
1239     RetVal = TempRetVal;
1240     TempRetVal = NULL;
1241   }
1242
1243   FreePool(GetString);
1244   return RetVal;
1245 }
1246
1247 /**
1248   Function to dump information about UsbIoProtocol.
1249
1250   This will allocate the return buffer from boot services pool.
1251
1252   @param[in] TheHandle      The handle that has PciRootBridgeIo installed.
1253   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1254
1255   @retval A poitner to a string containing the information.
1256 **/
1257 CHAR16*
1258 EFIAPI
1259 UsbIoProtocolDumpInformation (
1260   IN CONST EFI_HANDLE TheHandle,
1261   IN CONST BOOLEAN    Verbose
1262   )
1263 {
1264   EFI_STATUS                    Status;
1265   EFI_USB_IO_PROTOCOL           *UsbIo;
1266   EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDesc;
1267   CHAR16                        *GetString;
1268   CHAR16                        *RetVal;
1269
1270   if (!Verbose) {
1271     return (NULL);
1272   }
1273   RetVal = NULL;
1274   GetString = NULL;
1275   Status = gBS->OpenProtocol (
1276                   TheHandle,
1277                   &gEfiUsbIoProtocolGuid,
1278                   (VOID**)&UsbIo,
1279                   gImageHandle,
1280                   NULL,
1281                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1282                   );
1283
1284   if (EFI_ERROR(Status)) {
1285     return NULL;
1286   }
1287   UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);
1288   HandleParsingHiiInit ();
1289   GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_USBIO_DUMP_MAIN), NULL);
1290   if (GetString == NULL) {
1291     return NULL;
1292   }
1293   RetVal = CatSPrint (
1294             NULL,
1295             GetString,
1296             InterfaceDesc.InterfaceNumber,
1297             InterfaceDesc.InterfaceClass,
1298             InterfaceDesc.InterfaceSubClass,
1299             InterfaceDesc.InterfaceProtocol
1300             );
1301
1302   FreePool (GetString);
1303   return RetVal;
1304 }
1305
1306 /**
1307   Function to dump information about EfiAdapterInformation Protocol.
1308
1309   @param[in] TheHandle      The handle that has the protocol installed.
1310   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1311
1312   @retval A pointer to a string containing the information.
1313 **/
1314 CHAR16*
1315 EFIAPI
1316 AdapterInformationDumpInformation (
1317   IN CONST EFI_HANDLE TheHandle,
1318   IN CONST BOOLEAN    Verbose
1319   )
1320 {
1321   EFI_STATUS                        Status;
1322   EFI_ADAPTER_INFORMATION_PROTOCOL  *EfiAdptrInfoProtocol;
1323   UINTN                             InfoTypesBufferCount;
1324   UINTN                             GuidIndex;
1325   EFI_GUID                          *InfoTypesBuffer;
1326   CHAR16                            *GuidStr;
1327   CHAR16                            *TempStr;
1328   CHAR16                            *RetVal;
1329   CHAR16                            *TempRetVal;
1330   VOID                              *InformationBlock;
1331   UINTN                             InformationBlockSize;
1332
1333   if (!Verbose) {
1334     return (CatSPrint(NULL, L"AdapterInfo"));
1335   }
1336
1337   InfoTypesBuffer   = NULL;
1338   InformationBlock  = NULL;
1339
1340
1341   Status = gBS->OpenProtocol (
1342                   (EFI_HANDLE) (TheHandle),
1343                   &gEfiAdapterInformationProtocolGuid,
1344                   (VOID **) &EfiAdptrInfoProtocol,
1345                   NULL,
1346                   NULL,
1347                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1348                   );
1349
1350   if (EFI_ERROR (Status)) {
1351     return NULL;
1352   }
1353
1354   //
1355   // Get a list of supported information types for this instance of the protocol.
1356   //
1357   Status = EfiAdptrInfoProtocol->GetSupportedTypes (
1358                                    EfiAdptrInfoProtocol,
1359                                    &InfoTypesBuffer,
1360                                    &InfoTypesBufferCount
1361                                    );
1362   RetVal = NULL;
1363   if (EFI_ERROR (Status)) {
1364     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED), NULL);
1365     if (TempStr != NULL) {
1366       RetVal = CatSPrint (NULL, TempStr, Status);
1367     } else {
1368       goto ERROR_EXIT;
1369     }
1370   } else {
1371     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SUPP_TYPE_HEADER), NULL);
1372     if (TempStr == NULL) {
1373       goto ERROR_EXIT;
1374     }
1375     RetVal = CatSPrint (NULL, TempStr);
1376     SHELL_FREE_NON_NULL (TempStr);
1377
1378     for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {
1379       TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);
1380       if (TempStr == NULL) {
1381         goto ERROR_EXIT;
1382       }
1383       TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);
1384       SHELL_FREE_NON_NULL (RetVal);
1385       RetVal = TempRetVal;
1386       SHELL_FREE_NON_NULL (TempStr);
1387
1388       TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);
1389       if (TempStr == NULL) {
1390         goto ERROR_EXIT;
1391       }
1392
1393       if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {
1394         TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");
1395         SHELL_FREE_NON_NULL (RetVal);
1396         RetVal = TempRetVal;
1397       } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {
1398         TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");
1399         SHELL_FREE_NON_NULL (RetVal);
1400         RetVal = TempRetVal;
1401       } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {
1402         TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");
1403         SHELL_FREE_NON_NULL (RetVal);
1404         RetVal = TempRetVal;
1405       } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {
1406         TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");
1407         SHELL_FREE_NON_NULL (RetVal);
1408         RetVal = TempRetVal;
1409       } else {
1410
1411         GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);
1412         if (GuidStr == NULL) {
1413           TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");
1414           SHELL_FREE_NON_NULL (RetVal);
1415           RetVal = TempRetVal;
1416
1417           SHELL_FREE_NON_NULL (TempStr);
1418           SHELL_FREE_NON_NULL(GuidStr);
1419           //
1420           // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
1421           //
1422           continue;
1423         } else {
1424           TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);
1425           SHELL_FREE_NON_NULL (RetVal);
1426           RetVal = TempRetVal;
1427           SHELL_FREE_NON_NULL(GuidStr);
1428         }
1429       }
1430
1431       SHELL_FREE_NON_NULL (TempStr);
1432
1433       Status = EfiAdptrInfoProtocol->GetInformation (
1434                                        EfiAdptrInfoProtocol,
1435                                        &InfoTypesBuffer[GuidIndex],
1436                                        &InformationBlock,
1437                                        &InformationBlockSize
1438                                        );
1439
1440       if (EFI_ERROR (Status)) {
1441         TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);
1442         if (TempStr == NULL) {
1443           goto ERROR_EXIT;
1444         }
1445         TempRetVal = CatSPrint (RetVal, TempStr, Status);
1446         SHELL_FREE_NON_NULL (RetVal);
1447         RetVal = TempRetVal;
1448       } else {
1449         if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {
1450           TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);
1451           if (TempStr == NULL) {
1452             goto ERROR_EXIT;
1453           }
1454           TempRetVal = CatSPrint (
1455                          RetVal,
1456                          TempStr,
1457                          ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,
1458                          ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState
1459                          );
1460           SHELL_FREE_NON_NULL (RetVal);
1461           RetVal = TempRetVal;
1462         } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {
1463           TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);
1464           if (TempStr == NULL) {
1465             goto ERROR_EXIT;
1466           }
1467           TempRetVal = CatSPrint (
1468                          RetVal,
1469                          TempStr,
1470                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,
1471                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,
1472                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,
1473                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,
1474                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,
1475                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,
1476                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,
1477                          ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot
1478                          );
1479           SHELL_FREE_NON_NULL (RetVal);
1480           RetVal = TempRetVal;
1481         } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {
1482           TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);
1483           if (TempStr == NULL) {
1484             goto ERROR_EXIT;
1485           }
1486           TempRetVal = CatSPrint (
1487                          RetVal,
1488                          TempStr,
1489                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],
1490                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],
1491                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],
1492                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],
1493                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],
1494                          ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]
1495                          );
1496           SHELL_FREE_NON_NULL (RetVal);
1497           RetVal = TempRetVal;
1498         } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {
1499           TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNDI_IPV6_INFO), NULL);
1500           if (TempStr == NULL) {
1501             goto ERROR_EXIT;
1502           }
1503
1504           TempRetVal = CatSPrint (
1505                          RetVal,
1506                          TempStr,
1507                          ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support
1508                          );
1509           SHELL_FREE_NON_NULL (RetVal);
1510           RetVal = TempRetVal;
1511         } else {
1512           TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);
1513           if (TempStr == NULL) {
1514             goto ERROR_EXIT;
1515           }
1516           TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);
1517           SHELL_FREE_NON_NULL (RetVal);
1518           RetVal = TempRetVal;
1519         }
1520       }
1521       SHELL_FREE_NON_NULL (TempStr);
1522       SHELL_FREE_NON_NULL (InformationBlock);
1523     }
1524   }
1525
1526   SHELL_FREE_NON_NULL (InfoTypesBuffer);
1527   return RetVal;
1528
1529 ERROR_EXIT:
1530   SHELL_FREE_NON_NULL (RetVal);
1531   SHELL_FREE_NON_NULL (InfoTypesBuffer);
1532   SHELL_FREE_NON_NULL (InformationBlock);
1533   return NULL;
1534 }
1535
1536 /**
1537   Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
1538
1539   @param[in] TheHandle      The handle that has the protocol installed.
1540   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1541
1542   @retval A pointer to a string containing the information.
1543 **/
1544 CHAR16*
1545 EFIAPI
1546 FirmwareManagementDumpInformation (
1547   IN CONST EFI_HANDLE TheHandle,
1548   IN CONST BOOLEAN    Verbose
1549   )
1550 {
1551   EFI_STATUS                          Status;
1552   EFI_FIRMWARE_MANAGEMENT_PROTOCOL    *EfiFwMgmtProtocol;
1553   EFI_FIRMWARE_IMAGE_DESCRIPTOR       *ImageInfo;
1554   EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1    *ImageInfoV1;
1555   EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2    *ImageInfoV2;
1556   UINT64                              AttributeSetting;
1557   UINTN                               ImageInfoSize;
1558   UINTN                               DescriptorSize;
1559   UINT32                              DescriptorVersion;
1560   UINT32                              PackageVersion;
1561   UINT8                               DescriptorCount;
1562   UINT8                               Index;
1563   UINT8                               Index1;
1564   UINT8                               ImageCount;
1565   CHAR16                              *PackageVersionName;
1566   CHAR16                              *TempStr;
1567   CHAR16                              *RetVal;
1568   CHAR16                              *TempRetVal;
1569   CHAR16                              *AttributeSettingStr;
1570   BOOLEAN                             Found;
1571   BOOLEAN                             AttributeSupported;
1572
1573   //
1574   // Initialize local variables
1575   //
1576   ImageCount             = 0;
1577   ImageInfoSize          = 1;
1578   AttributeSetting       = 0;
1579   Found                  = FALSE;
1580   AttributeSupported     = FALSE;
1581   ImageInfo              = NULL;
1582   ImageInfoV1            = NULL;
1583   ImageInfoV2            = NULL;
1584   PackageVersionName     = NULL;
1585   RetVal                 = NULL;
1586   TempRetVal             = NULL;
1587   TempStr                = NULL;
1588   AttributeSettingStr    = NULL;
1589
1590   if (!Verbose) {
1591     return (CatSPrint(NULL, L"FirmwareManagement"));
1592   }
1593
1594   Status = gBS->OpenProtocol (
1595                   (EFI_HANDLE) (TheHandle),
1596                   &gEfiFirmwareManagementProtocolGuid,
1597                   (VOID **) &EfiFwMgmtProtocol,
1598                   NULL,
1599                   NULL,
1600                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1601                   );
1602
1603   if (EFI_ERROR (Status)) {
1604     return NULL;
1605   }
1606
1607   Status = EfiFwMgmtProtocol->GetImageInfo (
1608                                 EfiFwMgmtProtocol,
1609                                 &ImageInfoSize,
1610                                 ImageInfo,
1611                                 &DescriptorVersion,
1612                                 &DescriptorCount,
1613                                 &DescriptorSize,
1614                                 &PackageVersion,
1615                                 &PackageVersionName
1616                                 );
1617
1618   if (Status == EFI_BUFFER_TOO_SMALL) {
1619     ImageInfo = AllocateZeroPool (ImageInfoSize);
1620
1621     if (ImageInfo == NULL) {
1622       Status = EFI_OUT_OF_RESOURCES;
1623     } else {
1624       Status = EfiFwMgmtProtocol->GetImageInfo (
1625                                     EfiFwMgmtProtocol,
1626                                     &ImageInfoSize,
1627                                     ImageInfo,
1628                                     &DescriptorVersion,
1629                                     &DescriptorCount,
1630                                     &DescriptorSize,
1631                                     &PackageVersion,
1632                                     &PackageVersionName
1633                                     );
1634     }
1635   }
1636
1637   if (EFI_ERROR (Status)) {
1638     goto ERROR_EXIT;
1639   }
1640
1641   //
1642   // Decode Image Descriptor data only if its version is supported
1643   //
1644   if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {
1645
1646     if (ImageInfo == NULL) {
1647       goto ERROR_EXIT;
1648     }
1649
1650     ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;
1651     ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;
1652
1653     //
1654     // Set ImageInfoSize in return buffer
1655     //
1656     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE), NULL);
1657     if (TempStr == NULL) {
1658       goto ERROR_EXIT;
1659     }
1660     RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);
1661     SHELL_FREE_NON_NULL (TempStr);
1662
1663     //
1664     // Set DescriptorVersion in return buffer
1665     //
1666     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION), NULL);
1667     if (TempStr == NULL) {
1668       goto ERROR_EXIT;
1669     }
1670     TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);
1671     SHELL_FREE_NON_NULL (RetVal);
1672     RetVal = TempRetVal;
1673     SHELL_FREE_NON_NULL (TempStr);
1674
1675     //
1676     // Set DescriptorCount in return buffer
1677     //
1678     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT), NULL);
1679     if (TempStr == NULL) {
1680       goto ERROR_EXIT;
1681     }
1682     TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);
1683     SHELL_FREE_NON_NULL (RetVal);
1684     RetVal = TempRetVal;
1685     SHELL_FREE_NON_NULL (TempStr);
1686
1687
1688     //
1689     // Set DescriptorSize in return buffer
1690     //
1691     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE), NULL);
1692     if (TempStr == NULL) {
1693       goto ERROR_EXIT;
1694     }
1695     TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);
1696     SHELL_FREE_NON_NULL (RetVal);
1697     RetVal = TempRetVal;
1698     SHELL_FREE_NON_NULL (TempStr);
1699
1700     //
1701     // Set PackageVersion in return buffer
1702     //
1703     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION), NULL);
1704     if (TempStr == NULL) {
1705       goto ERROR_EXIT;
1706     }
1707     TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);
1708     SHELL_FREE_NON_NULL (RetVal);
1709     RetVal = TempRetVal;
1710     SHELL_FREE_NON_NULL (TempStr);
1711
1712     //
1713     // Set PackageVersionName in return buffer
1714     //
1715     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME), NULL);
1716     if (TempStr == NULL) {
1717       goto ERROR_EXIT;
1718     }
1719     TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);
1720     SHELL_FREE_NON_NULL (RetVal);
1721     RetVal = TempRetVal;
1722     SHELL_FREE_NON_NULL (TempStr);
1723
1724     for (Index = 0; Index < DescriptorCount; Index++) {
1725       //
1726       // First check if Attribute is supported
1727       // and generate a string for AttributeSetting field
1728       //
1729       SHELL_FREE_NON_NULL (AttributeSettingStr);
1730       AttributeSupported = FALSE;
1731       AttributeSetting   = 0;
1732       if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1733         if (ImageInfoV1[Index].AttributesSupported != 0x0) {
1734           AttributeSupported = TRUE;
1735           AttributeSetting   = ImageInfoV1[Index].AttributesSetting;
1736         }
1737       } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1738         if (ImageInfoV2[Index].AttributesSupported != 0x0) {
1739           AttributeSupported = TRUE;
1740           AttributeSetting   = ImageInfoV2[Index].AttributesSetting;
1741         }
1742       } else {
1743         if (ImageInfo[Index].AttributesSupported != 0x0) {
1744           AttributeSupported = TRUE;
1745           AttributeSetting   = ImageInfo[Index].AttributesSetting;
1746         }
1747       }
1748
1749       if (!AttributeSupported) {
1750         AttributeSettingStr = CatSPrint (NULL, L"None");
1751       } else {
1752         AttributeSettingStr = CatSPrint (NULL, L"(");
1753
1754         if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {
1755           TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1756           SHELL_FREE_NON_NULL (AttributeSettingStr);
1757           AttributeSettingStr = TempRetVal;
1758         }
1759         if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {
1760           TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1761           SHELL_FREE_NON_NULL (AttributeSettingStr);
1762           AttributeSettingStr = TempRetVal;
1763         }
1764         if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {
1765           TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1766           SHELL_FREE_NON_NULL (AttributeSettingStr);
1767           AttributeSettingStr = TempRetVal;
1768         }
1769         if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {
1770           TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");
1771           SHELL_FREE_NON_NULL (AttributeSettingStr);
1772           AttributeSettingStr = TempRetVal;
1773         }
1774         if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {
1775           TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1776           SHELL_FREE_NON_NULL (AttributeSettingStr);
1777           AttributeSettingStr = TempRetVal;
1778         }
1779         TempRetVal = CatSPrint (AttributeSettingStr, L" )");
1780         SHELL_FREE_NON_NULL (AttributeSettingStr);
1781         AttributeSettingStr = TempRetVal;
1782       }
1783
1784       if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1785         if (ImageInfoV1[Index].ImageIndex != 0x0) {
1786           ImageCount++;
1787         }
1788
1789         TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);
1790         if (TempStr == NULL) {
1791           goto ERROR_EXIT;
1792         }
1793         TempRetVal = CatSPrint (
1794                        RetVal,
1795                        TempStr,
1796                        Index,
1797                        ImageInfoV1[Index].ImageIndex,
1798                        &ImageInfoV1[Index].ImageTypeId,
1799                        ImageInfoV1[Index].ImageId,
1800                        ImageInfoV1[Index].ImageIdName,
1801                        ImageInfoV1[Index].Version,
1802                        ImageInfoV1[Index].VersionName,
1803                        ImageInfoV1[Index].Size,
1804                        ImageInfoV1[Index].AttributesSupported,
1805                        AttributeSettingStr,
1806                        ImageInfoV1[Index].Compatibilities
1807                        );
1808         SHELL_FREE_NON_NULL (RetVal);
1809         RetVal = TempRetVal;
1810         SHELL_FREE_NON_NULL (TempStr);
1811       } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1812         if (ImageInfoV2[Index].ImageIndex != 0x0) {
1813           ImageCount++;
1814         }
1815
1816         TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);
1817         if (TempStr == NULL) {
1818           goto ERROR_EXIT;
1819         }
1820         TempRetVal = CatSPrint (
1821                        RetVal,
1822                        TempStr,
1823                        Index,
1824                        ImageInfoV2[Index].ImageIndex,
1825                        &ImageInfoV2[Index].ImageTypeId,
1826                        ImageInfoV2[Index].ImageId,
1827                        ImageInfoV2[Index].ImageIdName,
1828                        ImageInfoV2[Index].Version,
1829                        ImageInfoV2[Index].VersionName,
1830                        ImageInfoV2[Index].Size,
1831                        ImageInfoV2[Index].AttributesSupported,
1832                        AttributeSettingStr,
1833                        ImageInfoV2[Index].Compatibilities,
1834                        ImageInfoV2[Index].LowestSupportedImageVersion
1835                        );
1836         SHELL_FREE_NON_NULL (RetVal);
1837         RetVal = TempRetVal;
1838         SHELL_FREE_NON_NULL (TempStr);
1839       } else {
1840         if (ImageInfo[Index].ImageIndex != 0x0) {
1841           ImageCount++;
1842         }
1843
1844         TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);
1845         if (TempStr == NULL) {
1846           goto ERROR_EXIT;
1847         }
1848         TempRetVal = CatSPrint (
1849                        RetVal,
1850                        TempStr,
1851                        Index,
1852                        ImageInfo[Index].ImageIndex,
1853                        &ImageInfo[Index].ImageTypeId,
1854                        ImageInfo[Index].ImageId,
1855                        ImageInfo[Index].ImageIdName,
1856                        ImageInfo[Index].Version,
1857                        ImageInfo[Index].VersionName,
1858                        ImageInfo[Index].Size,
1859                        ImageInfo[Index].AttributesSupported,
1860                        AttributeSettingStr,
1861                        ImageInfo[Index].Compatibilities,
1862                        ImageInfo[Index].LowestSupportedImageVersion,
1863                        ImageInfo[Index].LastAttemptVersion,
1864                        ImageInfo[Index].LastAttemptStatus,
1865                        ImageInfo[Index].HardwareInstance
1866                        );
1867         SHELL_FREE_NON_NULL (RetVal);
1868         RetVal = TempRetVal;
1869         SHELL_FREE_NON_NULL (TempStr);
1870       }
1871     }
1872   }
1873
1874   if (ImageCount > 0) {
1875     for (Index=0; Index<DescriptorCount; Index++) {
1876       for (Index1=Index+1; Index1<DescriptorCount; Index1++) {
1877         if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1878           if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {
1879             Found = TRUE;
1880             //
1881             // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1882             //
1883             goto ENDLOOP;
1884           }
1885         } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1886           if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {
1887             Found = TRUE;
1888             //
1889             // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1890             //
1891             goto ENDLOOP;
1892           }
1893         } else {
1894           if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {
1895             Found = TRUE;
1896             //
1897             // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1898             //
1899             goto ENDLOOP;
1900           }
1901         }
1902       }
1903     }
1904   }
1905
1906 ENDLOOP:
1907   //
1908   // Check if ImageId with duplicate value was found
1909   //
1910   if (Found) {
1911     TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE), NULL);
1912     if (TempStr == NULL) {
1913       goto ERROR_EXIT;
1914     }
1915     TempRetVal = CatSPrint (RetVal, TempStr);
1916     SHELL_FREE_NON_NULL (RetVal);
1917     RetVal = TempRetVal;
1918     SHELL_FREE_NON_NULL (TempStr);
1919   }
1920
1921   SHELL_FREE_NON_NULL (ImageInfo);
1922   SHELL_FREE_NON_NULL (PackageVersionName);
1923   SHELL_FREE_NON_NULL (AttributeSettingStr);
1924
1925   return RetVal;
1926
1927 ERROR_EXIT:
1928   SHELL_FREE_NON_NULL (RetVal);
1929   SHELL_FREE_NON_NULL (ImageInfo);
1930   SHELL_FREE_NON_NULL (PackageVersionName);
1931   SHELL_FREE_NON_NULL (AttributeSettingStr);
1932
1933   return NULL;
1934 }
1935
1936 /**
1937   Function to dump information about Partition Information protocol.
1938
1939   This will allocate the return buffer from boot services pool.
1940
1941   @param[in] TheHandle      The handle that has the protocol installed.
1942   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
1943
1944   @retval A pointer to a string containing the information.
1945 **/
1946 CHAR16*
1947 EFIAPI
1948 PartitionInfoProtocolDumpInformation (
1949   IN CONST EFI_HANDLE TheHandle,
1950   IN CONST BOOLEAN    Verbose
1951   )
1952 {
1953   EFI_STATUS                      Status;
1954   EFI_PARTITION_INFO_PROTOCOL     *PartitionInfo;
1955   CHAR16                          *PartitionType;
1956   CHAR16                          *EfiSystemPartition;
1957   CHAR16                          *RetVal;
1958
1959   if (!Verbose) {
1960     return NULL;
1961   }
1962
1963   Status = gBS->OpenProtocol (
1964                 TheHandle,
1965                 &gEfiPartitionInfoProtocolGuid,
1966                 (VOID**)&PartitionInfo,
1967                 gImageHandle,
1968                 NULL,
1969                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1970                 );
1971   if (EFI_ERROR (Status)) {
1972     return NULL;
1973   }
1974
1975   HandleParsingHiiInit ();
1976
1977   switch (PartitionInfo->Type) {
1978   case PARTITION_TYPE_OTHER:
1979     PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_OTHER), NULL);
1980     break;
1981   case PARTITION_TYPE_MBR:
1982     PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_MBR), NULL);
1983     break;
1984   case PARTITION_TYPE_GPT:
1985     PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_GPT), NULL);
1986     break;
1987   default:
1988     PartitionType = NULL;
1989     break;
1990   }
1991   if (PartitionType == NULL) {
1992     return NULL;
1993   }
1994
1995   if (PartitionInfo->System == 1) {
1996     EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_EFI_SYS_PART), NULL);
1997   } else {
1998     EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_NOT_EFI_SYS_PART), NULL);
1999   }
2000   if (EfiSystemPartition == NULL) {
2001     SHELL_FREE_NON_NULL (PartitionType);
2002     return NULL;
2003   }
2004
2005   RetVal = CatSPrint (
2006              NULL,
2007              L"%s\r\n%s",
2008              PartitionType,
2009              EfiSystemPartition
2010              );
2011
2012   SHELL_FREE_NON_NULL (EfiSystemPartition);
2013   SHELL_FREE_NON_NULL (PartitionType);
2014   return RetVal;
2015 }
2016
2017 //
2018 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
2019 //
2020 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
2021   { \
2022     0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2023   }
2024
2025 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
2026   { \
2027     0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2028   }
2029
2030 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
2031   { \
2032     0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2033   }
2034 STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;
2035 STATIC CONST EFI_GUID WinNtIoProtocolGuid    = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;
2036 STATIC CONST EFI_GUID WinNtSerialPortGuid    = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;
2037
2038 //
2039 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
2040 //
2041 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
2042   { \
2043   0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
2044   }
2045 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
2046   { \
2047   0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
2048   }
2049 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;
2050 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;
2051
2052
2053 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {
2054   {STRING_TOKEN(STR_WINNT_THUNK),           (EFI_GUID*)&WinNtThunkProtocolGuid,               NULL},
2055   {STRING_TOKEN(STR_WINNT_DRIVER_IO),       (EFI_GUID*)&WinNtIoProtocolGuid,                  NULL},
2056   {STRING_TOKEN(STR_WINNT_SERIAL_PORT),     (EFI_GUID*)&WinNtSerialPortGuid,                  NULL},
2057   {0,                                       NULL,                                             NULL},
2058 };
2059
2060 STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
2061   {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     LoadedImageProtocolDumpInformation},
2062   {STRING_TOKEN(STR_DEVICE_PATH),           &gEfiDevicePathProtocolGuid,                      DevicePathProtocolDumpInformation},
2063   {STRING_TOKEN(STR_IMAGE_PATH),            &gEfiLoadedImageDevicePathProtocolGuid,           LoadedImageDevicePathProtocolDumpInformation},
2064   {STRING_TOKEN(STR_DEVICE_PATH_UTIL),      &gEfiDevicePathUtilitiesProtocolGuid,             NULL},
2065   {STRING_TOKEN(STR_DEVICE_PATH_TXT),       &gEfiDevicePathToTextProtocolGuid,                NULL},
2066   {STRING_TOKEN(STR_DEVICE_PATH_FTXT),      &gEfiDevicePathFromTextProtocolGuid,              NULL},
2067   {STRING_TOKEN(STR_DEVICE_PATH_PC),        &gEfiPcAnsiGuid,                                  NULL},
2068   {STRING_TOKEN(STR_DEVICE_PATH_VT100),     &gEfiVT100Guid,                                   NULL},
2069   {STRING_TOKEN(STR_DEVICE_PATH_VT100P),    &gEfiVT100PlusGuid,                               NULL},
2070   {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8),    &gEfiVTUTF8Guid,                                  NULL},
2071   {STRING_TOKEN(STR_DRIVER_BINDING),        &gEfiDriverBindingProtocolGuid,                   NULL},
2072   {STRING_TOKEN(STR_PLATFORM_OVERRIDE),     &gEfiPlatformDriverOverrideProtocolGuid,          NULL},
2073   {STRING_TOKEN(STR_BUS_OVERRIDE),          &gEfiBusSpecificDriverOverrideProtocolGuid,       BusSpecificDriverOverrideProtocolDumpInformation},
2074   {STRING_TOKEN(STR_DRIVER_DIAG),           &gEfiDriverDiagnosticsProtocolGuid,               NULL},
2075   {STRING_TOKEN(STR_DRIVER_DIAG2),          &gEfiDriverDiagnostics2ProtocolGuid,              NULL},
2076   {STRING_TOKEN(STR_DRIVER_CN),             &gEfiComponentNameProtocolGuid,                   NULL},
2077   {STRING_TOKEN(STR_DRIVER_CN2),            &gEfiComponentName2ProtocolGuid,                  NULL},
2078   {STRING_TOKEN(STR_PLAT_DRV_CFG),          &gEfiPlatformToDriverConfigurationProtocolGuid,   NULL},
2079   {STRING_TOKEN(STR_DRIVER_VERSION),        &gEfiDriverSupportedEfiVersionProtocolGuid,       DriverEfiVersionProtocolDumpInformation},
2080   {STRING_TOKEN(STR_TXT_IN),                &gEfiSimpleTextInProtocolGuid,                    NULL},
2081   {STRING_TOKEN(STR_TXT_IN_EX),             &gEfiSimpleTextInputExProtocolGuid,               NULL},
2082   {STRING_TOKEN(STR_TXT_OUT),               &gEfiSimpleTextOutProtocolGuid,                   TxtOutProtocolDumpInformation},
2083   {STRING_TOKEN(STR_SIM_POINTER),           &gEfiSimplePointerProtocolGuid,                   NULL},
2084   {STRING_TOKEN(STR_ABS_POINTER),           &gEfiAbsolutePointerProtocolGuid,                 NULL},
2085   {STRING_TOKEN(STR_SERIAL_IO),             &gEfiSerialIoProtocolGuid,                        NULL},
2086   {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  GraphicsOutputProtocolDumpInformation},
2087   {STRING_TOKEN(STR_EDID_DISCOVERED),       &gEfiEdidDiscoveredProtocolGuid,                  EdidDiscoveredProtocolDumpInformation},
2088   {STRING_TOKEN(STR_EDID_ACTIVE),           &gEfiEdidActiveProtocolGuid,                      EdidActiveProtocolDumpInformation},
2089   {STRING_TOKEN(STR_EDID_OVERRIDE),         &gEfiEdidOverrideProtocolGuid,                    NULL},
2090   {STRING_TOKEN(STR_CON_IN),                &gEfiConsoleInDeviceGuid,                         NULL},
2091   {STRING_TOKEN(STR_CON_OUT),               &gEfiConsoleOutDeviceGuid,                        NULL},
2092   {STRING_TOKEN(STR_STD_ERR),               &gEfiStandardErrorDeviceGuid,                     NULL},
2093   {STRING_TOKEN(STR_LOAD_FILE),             &gEfiLoadFileProtocolGuid,                        NULL},
2094   {STRING_TOKEN(STR_LOAD_FILE2),            &gEfiLoadFile2ProtocolGuid,                       NULL},
2095   {STRING_TOKEN(STR_SIMPLE_FILE_SYS),       &gEfiSimpleFileSystemProtocolGuid,                NULL},
2096   {STRING_TOKEN(STR_TAPE_IO),               &gEfiTapeIoProtocolGuid,                          NULL},
2097   {STRING_TOKEN(STR_DISK_IO),               &gEfiDiskIoProtocolGuid,                          NULL},
2098   {STRING_TOKEN(STR_BLK_IO),                &gEfiBlockIoProtocolGuid,                         BlockIoProtocolDumpInformation},
2099   {STRING_TOKEN(STR_UC),                    &gEfiUnicodeCollationProtocolGuid,                NULL},
2100   {STRING_TOKEN(STR_UC2),                   &gEfiUnicodeCollation2ProtocolGuid,               NULL},
2101   {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 PciRootBridgeIoDumpInformation},
2102   {STRING_TOKEN(STR_PCI_IO),                &gEfiPciIoProtocolGuid,                           PciIoProtocolDumpInformation},
2103   {STRING_TOKEN(STR_SCSI_PT),               &gEfiScsiPassThruProtocolGuid,                    NULL},
2104   {STRING_TOKEN(STR_SCSI_IO),               &gEfiScsiIoProtocolGuid,                          NULL},
2105   {STRING_TOKEN(STR_SCSI_PT_EXT),           &gEfiExtScsiPassThruProtocolGuid,                 NULL},
2106   {STRING_TOKEN(STR_ISCSI),                 &gEfiIScsiInitiatorNameProtocolGuid,              NULL},
2107   {STRING_TOKEN(STR_USB_IO),                &gEfiUsbIoProtocolGuid,                           UsbIoProtocolDumpInformation},
2108   {STRING_TOKEN(STR_USB_HC),                &gEfiUsbHcProtocolGuid,                           NULL},
2109   {STRING_TOKEN(STR_USB_HC2),               &gEfiUsb2HcProtocolGuid,                          NULL},
2110   {STRING_TOKEN(STR_DEBUG_SUPPORT),         &gEfiDebugSupportProtocolGuid,                    DebugSupportProtocolDumpInformation},
2111   {STRING_TOKEN(STR_DEBUG_PORT),            &gEfiDebugPortProtocolGuid,                       NULL},
2112   {STRING_TOKEN(STR_DECOMPRESS),            &gEfiDecompressProtocolGuid,                      NULL},
2113   {STRING_TOKEN(STR_ACPI_TABLE),            &gEfiAcpiTableProtocolGuid,                       NULL},
2114   {STRING_TOKEN(STR_EBC_INTERPRETER),       &gEfiEbcProtocolGuid,                             NULL},
2115   {STRING_TOKEN(STR_SNP),                   &gEfiSimpleNetworkProtocolGuid,                   NULL},
2116   {STRING_TOKEN(STR_NII),                   &gEfiNetworkInterfaceIdentifierProtocolGuid,      NULL},
2117   {STRING_TOKEN(STR_NII_31),                &gEfiNetworkInterfaceIdentifierProtocolGuid_31,   NULL},
2118   {STRING_TOKEN(STR_PXE_BC),                &gEfiPxeBaseCodeProtocolGuid,                     NULL},
2119   {STRING_TOKEN(STR_PXE_CB),                &gEfiPxeBaseCodeCallbackProtocolGuid,             NULL},
2120   {STRING_TOKEN(STR_BIS),                   &gEfiBisProtocolGuid,                             NULL},
2121   {STRING_TOKEN(STR_MNP_SB),                &gEfiManagedNetworkServiceBindingProtocolGuid,    NULL},
2122   {STRING_TOKEN(STR_MNP),                   &gEfiManagedNetworkProtocolGuid,                  NULL},
2123   {STRING_TOKEN(STR_ARP_SB),                &gEfiArpServiceBindingProtocolGuid,               NULL},
2124   {STRING_TOKEN(STR_ARP),                   &gEfiArpProtocolGuid,                             NULL},
2125   {STRING_TOKEN(STR_DHCPV4_SB),             &gEfiDhcp4ServiceBindingProtocolGuid,             NULL},
2126   {STRING_TOKEN(STR_DHCPV4),                &gEfiDhcp4ProtocolGuid,                           NULL},
2127   {STRING_TOKEN(STR_TCPV4_SB),              &gEfiTcp4ServiceBindingProtocolGuid,              NULL},
2128   {STRING_TOKEN(STR_TCPV4),                 &gEfiTcp4ProtocolGuid,                            NULL},
2129   {STRING_TOKEN(STR_IPV4_SB),               &gEfiIp4ServiceBindingProtocolGuid,               NULL},
2130   {STRING_TOKEN(STR_IPV4),                  &gEfiIp4ProtocolGuid,                             NULL},
2131   {STRING_TOKEN(STR_IPV4_CFG),              &gEfiIp4ConfigProtocolGuid,                       NULL},
2132   {STRING_TOKEN(STR_IPV4_CFG2),             &gEfiIp4Config2ProtocolGuid,                      NULL},
2133   {STRING_TOKEN(STR_UDPV4_SB),              &gEfiUdp4ServiceBindingProtocolGuid,              NULL},
2134   {STRING_TOKEN(STR_UDPV4),                 &gEfiUdp4ProtocolGuid,                            NULL},
2135   {STRING_TOKEN(STR_MTFTPV4_SB),            &gEfiMtftp4ServiceBindingProtocolGuid,            NULL},
2136   {STRING_TOKEN(STR_MTFTPV4),               &gEfiMtftp4ProtocolGuid,                          NULL},
2137   {STRING_TOKEN(STR_AUTH_INFO),             &gEfiAuthenticationInfoProtocolGuid,              NULL},
2138   {STRING_TOKEN(STR_HASH_SB),               &gEfiHashServiceBindingProtocolGuid,              NULL},
2139   {STRING_TOKEN(STR_HASH),                  &gEfiHashProtocolGuid,                            NULL},
2140   {STRING_TOKEN(STR_HII_FONT),              &gEfiHiiFontProtocolGuid,                         NULL},
2141   {STRING_TOKEN(STR_HII_STRING),            &gEfiHiiStringProtocolGuid,                       NULL},
2142   {STRING_TOKEN(STR_HII_IMAGE),             &gEfiHiiImageProtocolGuid,                        NULL},
2143   {STRING_TOKEN(STR_HII_DATABASE),          &gEfiHiiDatabaseProtocolGuid,                     NULL},
2144   {STRING_TOKEN(STR_HII_CONFIG_ROUT),       &gEfiHiiConfigRoutingProtocolGuid,                NULL},
2145   {STRING_TOKEN(STR_HII_CONFIG_ACC),        &gEfiHiiConfigAccessProtocolGuid,                 NULL},
2146   {STRING_TOKEN(STR_HII_FORM_BROWSER2),     &gEfiFormBrowser2ProtocolGuid,                    NULL},
2147   {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE),   &gEfiDriverFamilyOverrideProtocolGuid,            NULL},
2148   {STRING_TOKEN(STR_PCD),                   &gPcdProtocolGuid,                                NULL},
2149   {STRING_TOKEN(STR_TCG),                   &gEfiTcgProtocolGuid,                             NULL},
2150   {STRING_TOKEN(STR_HII_PACKAGE_LIST),      &gEfiHiiPackageListProtocolGuid,                  NULL},
2151
2152 //
2153 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
2154 //
2155   {STRING_TOKEN(STR_SHELL_INTERFACE),       &gEfiShellInterfaceGuid,                          NULL},
2156   {STRING_TOKEN(STR_SHELL_ENV2),            &gEfiShellEnvironment2Guid,                       NULL},
2157   {STRING_TOKEN(STR_SHELL_ENV),             &gEfiShellEnvironment2Guid,                       NULL},
2158   {STRING_TOKEN(STR_DEVICE_IO),             &gEfiDeviceIoProtocolGuid,                        NULL},
2159   {STRING_TOKEN(STR_UGA_DRAW),              &gEfiUgaDrawProtocolGuid,                         NULL},
2160   {STRING_TOKEN(STR_UGA_IO),                &gEfiUgaIoProtocolGuid,                           NULL},
2161   {STRING_TOKEN(STR_ESP),                   &gEfiPartTypeSystemPartGuid,                      NULL},
2162   {STRING_TOKEN(STR_GPT_NBR),               &gEfiPartTypeLegacyMbrGuid,                       NULL},
2163   {STRING_TOKEN(STR_DRIVER_CONFIG),         &gEfiDriverConfigurationProtocolGuid,             NULL},
2164   {STRING_TOKEN(STR_DRIVER_CONFIG2),        &gEfiDriverConfiguration2ProtocolGuid,            NULL},
2165
2166 //
2167 // these are using local (non-global) definitions to reduce package dependancy.
2168 //
2169   {STRING_TOKEN(STR_ISA_IO),                (EFI_GUID*)&EfiIsaIoProtocolGuid,                 NULL},
2170   {STRING_TOKEN(STR_ISA_ACPI),              (EFI_GUID*)&EfiIsaAcpiProtocolGuid,               NULL},
2171
2172 //
2173 // the ones under this are GUID identified structs, not protocols
2174 //
2175   {STRING_TOKEN(STR_FILE_INFO),             &gEfiFileInfoGuid,                                NULL},
2176   {STRING_TOKEN(STR_FILE_SYS_INFO),         &gEfiFileSystemInfoGuid,                          NULL},
2177
2178 //
2179 // the ones under this are misc GUIDS.
2180 //
2181   {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE),   &gEfiGlobalVariableGuid,                          NULL},
2182
2183 //
2184 // UEFI 2.2
2185 //
2186   {STRING_TOKEN(STR_IP6_SB),                &gEfiIp6ServiceBindingProtocolGuid,               NULL},
2187   {STRING_TOKEN(STR_IP6),                   &gEfiIp6ProtocolGuid,                             NULL},
2188   {STRING_TOKEN(STR_IP6_CONFIG),            &gEfiIp6ConfigProtocolGuid,                       NULL},
2189   {STRING_TOKEN(STR_MTFTP6_SB),             &gEfiMtftp6ServiceBindingProtocolGuid,            NULL},
2190   {STRING_TOKEN(STR_MTFTP6),                &gEfiMtftp6ProtocolGuid,                          NULL},
2191   {STRING_TOKEN(STR_DHCP6_SB),              &gEfiDhcp6ServiceBindingProtocolGuid,             NULL},
2192   {STRING_TOKEN(STR_DHCP6),                 &gEfiDhcp6ProtocolGuid,                           NULL},
2193   {STRING_TOKEN(STR_UDP6_SB),               &gEfiUdp6ServiceBindingProtocolGuid,              NULL},
2194   {STRING_TOKEN(STR_UDP6),                  &gEfiUdp6ProtocolGuid,                            NULL},
2195   {STRING_TOKEN(STR_TCP6_SB),               &gEfiTcp6ServiceBindingProtocolGuid,              NULL},
2196   {STRING_TOKEN(STR_TCP6),                  &gEfiTcp6ProtocolGuid,                            NULL},
2197   {STRING_TOKEN(STR_VLAN_CONFIG),           &gEfiVlanConfigProtocolGuid,                      NULL},
2198   {STRING_TOKEN(STR_EAP),                   &gEfiEapProtocolGuid,                             NULL},
2199   {STRING_TOKEN(STR_EAP_MGMT),              &gEfiEapManagementProtocolGuid,                   NULL},
2200   {STRING_TOKEN(STR_FTP4_SB),               &gEfiFtp4ServiceBindingProtocolGuid,              NULL},
2201   {STRING_TOKEN(STR_FTP4),                  &gEfiFtp4ProtocolGuid,                            NULL},
2202   {STRING_TOKEN(STR_IP_SEC_CONFIG),         &gEfiIpSecConfigProtocolGuid,                     NULL},
2203   {STRING_TOKEN(STR_DH),                    &gEfiDriverHealthProtocolGuid,                    NULL},
2204   {STRING_TOKEN(STR_DEF_IMG_LOAD),          &gEfiDeferredImageLoadProtocolGuid,               NULL},
2205   {STRING_TOKEN(STR_USER_CRED),             &gEfiUserCredentialProtocolGuid,                  NULL},
2206   {STRING_TOKEN(STR_USER_MNGR),             &gEfiUserManagerProtocolGuid,                     NULL},
2207   {STRING_TOKEN(STR_ATA_PASS_THRU),         &gEfiAtaPassThruProtocolGuid,                     NULL},
2208
2209 //
2210 // UEFI 2.3
2211 //
2212   {STRING_TOKEN(STR_FW_MGMT),               &gEfiFirmwareManagementProtocolGuid,              FirmwareManagementDumpInformation},
2213   {STRING_TOKEN(STR_IP_SEC),                &gEfiIpSecProtocolGuid,                           NULL},
2214   {STRING_TOKEN(STR_IP_SEC2),               &gEfiIpSec2ProtocolGuid,                          NULL},
2215
2216 //
2217 // UEFI 2.3.1
2218 //
2219   {STRING_TOKEN(STR_KMS),                   &gEfiKmsProtocolGuid,                             NULL},
2220   {STRING_TOKEN(STR_BLK_IO2),               &gEfiBlockIo2ProtocolGuid,                        NULL},
2221   {STRING_TOKEN(STR_SSC),                   &gEfiStorageSecurityCommandProtocolGuid,          NULL},
2222   {STRING_TOKEN(STR_UCRED2),                &gEfiUserCredential2ProtocolGuid,                 NULL},
2223
2224 //
2225 // UEFI 2.4
2226 //
2227   {STRING_TOKEN(STR_DISK_IO2),              &gEfiDiskIo2ProtocolGuid,                         NULL},
2228   {STRING_TOKEN(STR_ADAPTER_INFO),          &gEfiAdapterInformationProtocolGuid,              AdapterInformationDumpInformation},
2229
2230 //
2231 // UEFI2.5
2232 //
2233   {STRING_TOKEN(STR_TLS_SB),                &gEfiTlsServiceBindingProtocolGuid,              NULL},
2234   {STRING_TOKEN(STR_TLS),                   &gEfiTlsProtocolGuid,                            NULL},
2235   {STRING_TOKEN(STR_TLS_CONFIG),            &gEfiTlsConfigurationProtocolGuid,               NULL},
2236   {STRING_TOKEN(STR_SUPPLICANT_SB),         &gEfiSupplicantServiceBindingProtocolGuid,       NULL},
2237   {STRING_TOKEN(STR_SUPPLICANT),            &gEfiSupplicantProtocolGuid,                     NULL},
2238
2239 //
2240 // UEFI2.6
2241 //
2242   {STRING_TOKEN(STR_WIFI2),                 &gEfiWiFi2ProtocolGuid,                          NULL},
2243   {STRING_TOKEN(STR_RAMDISK),               &gEfiRamDiskProtocolGuid,                        NULL},
2244   {STRING_TOKEN(STR_HII_ID),                &gEfiHiiImageDecoderProtocolGuid,                NULL},
2245   {STRING_TOKEN(STR_HII_IE),                &gEfiHiiImageExProtocolGuid,                     NULL},
2246   {STRING_TOKEN(STR_SD_MPT),                &gEfiSdMmcPassThruProtocolGuid,                  NULL},
2247   {STRING_TOKEN(STR_ERASE_BLOCK),           &gEfiEraseBlockProtocolGuid,                     NULL},
2248
2249 //
2250 // UEFI2.7
2251 //
2252   {STRING_TOKEN(STR_BLUETOOTH_ATTR),        &gEfiBluetoothAttributeProtocolGuid,               NULL},
2253   {STRING_TOKEN(STR_BLUETOOTH_ATTR_SB),     &gEfiBluetoothAttributeServiceBindingProtocolGuid, NULL},
2254   {STRING_TOKEN(STR_BLUETOOTH_LE_CONFIG),   &gEfiBluetoothLeConfigProtocolGuid,                NULL},
2255   {STRING_TOKEN(STR_UFS_DEV_CONFIG),        &gEfiUfsDeviceConfigProtocolGuid,                  NULL},
2256   {STRING_TOKEN(STR_HTTP_BOOT_CALL),        &gEfiHttpBootCallbackProtocolGuid,                 NULL},
2257   {STRING_TOKEN(STR_RESET_NOTI),            &gEfiResetNotificationProtocolGuid,                NULL},
2258   {STRING_TOKEN(STR_PARTITION_INFO),        &gEfiPartitionInfoProtocolGuid,                    PartitionInfoProtocolDumpInformation},
2259   {STRING_TOKEN(STR_HII_POPUP),             &gEfiHiiPopupProtocolGuid,                         NULL},
2260
2261 //
2262 // PI Spec ones
2263 //
2264   {STRING_TOKEN(STR_IDE_CONT_INIT),         &gEfiIdeControllerInitProtocolGuid,               NULL},
2265   {STRING_TOKEN(STR_DISK_INFO),             &gEfiDiskInfoProtocolGuid,                        NULL},
2266
2267 //
2268 // PI Spec 1.0
2269 //
2270   {STRING_TOKEN(STR_BDS_ARCH),              &gEfiBdsArchProtocolGuid,                         NULL},
2271   {STRING_TOKEN(STR_CPU_ARCH),              &gEfiCpuArchProtocolGuid,                         NULL},
2272   {STRING_TOKEN(STR_MET_ARCH),              &gEfiMetronomeArchProtocolGuid,                   NULL},
2273   {STRING_TOKEN(STR_MON_ARCH),              &gEfiMonotonicCounterArchProtocolGuid,            NULL},
2274   {STRING_TOKEN(STR_RTC_ARCH),              &gEfiRealTimeClockArchProtocolGuid,               NULL},
2275   {STRING_TOKEN(STR_RESET_ARCH),            &gEfiResetArchProtocolGuid,                       NULL},
2276   {STRING_TOKEN(STR_RT_ARCH),               &gEfiRuntimeArchProtocolGuid,                     NULL},
2277   {STRING_TOKEN(STR_SEC_ARCH),              &gEfiSecurityArchProtocolGuid,                    NULL},
2278   {STRING_TOKEN(STR_TIMER_ARCH),            &gEfiTimerArchProtocolGuid,                       NULL},
2279   {STRING_TOKEN(STR_VAR_ARCH),              &gEfiVariableWriteArchProtocolGuid,               NULL},
2280   {STRING_TOKEN(STR_V_ARCH),                &gEfiVariableArchProtocolGuid,                    NULL},
2281   {STRING_TOKEN(STR_SECP),                  &gEfiSecurityPolicyProtocolGuid,                  NULL},
2282   {STRING_TOKEN(STR_WDT_ARCH),              &gEfiWatchdogTimerArchProtocolGuid,               NULL},
2283   {STRING_TOKEN(STR_SCR),                   &gEfiStatusCodeRuntimeProtocolGuid,               NULL},
2284   {STRING_TOKEN(STR_SMB_HC),                &gEfiSmbusHcProtocolGuid,                         NULL},
2285   {STRING_TOKEN(STR_FV_2),                  &gEfiFirmwareVolume2ProtocolGuid,                 NULL},
2286   {STRING_TOKEN(STR_FV_BLOCK),              &gEfiFirmwareVolumeBlockProtocolGuid,             NULL},
2287   {STRING_TOKEN(STR_CAP_ARCH),              &gEfiCapsuleArchProtocolGuid,                     NULL},
2288   {STRING_TOKEN(STR_MP_SERVICE),            &gEfiMpServiceProtocolGuid,                       NULL},
2289   {STRING_TOKEN(STR_HBRAP),                 &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},
2290   {STRING_TOKEN(STR_PCIP),                  &gEfiPciPlatformProtocolGuid,                     NULL},
2291   {STRING_TOKEN(STR_PCIO),                  &gEfiPciOverrideProtocolGuid,                     NULL},
2292   {STRING_TOKEN(STR_PCIE),                  &gEfiPciEnumerationCompleteProtocolGuid,          NULL},
2293   {STRING_TOKEN(STR_IPCID),                 &gEfiIncompatiblePciDeviceSupportProtocolGuid,    NULL},
2294   {STRING_TOKEN(STR_PCIHPI),                &gEfiPciHotPlugInitProtocolGuid,                  NULL},
2295   {STRING_TOKEN(STR_PCIHPR),                &gEfiPciHotPlugRequestProtocolGuid,               NULL},
2296   {STRING_TOKEN(STR_SMBIOS),                &gEfiSmbiosProtocolGuid,                          NULL},
2297   {STRING_TOKEN(STR_S3_SAVE),               &gEfiS3SaveStateProtocolGuid,                     NULL},
2298   {STRING_TOKEN(STR_S3_S_SMM),              &gEfiS3SmmSaveStateProtocolGuid,                  NULL},
2299   {STRING_TOKEN(STR_RSC),                   &gEfiRscHandlerProtocolGuid,                      NULL},
2300   {STRING_TOKEN(STR_S_RSC),                 &gEfiSmmRscHandlerProtocolGuid,                   NULL},
2301   {STRING_TOKEN(STR_ACPI_SDT),              &gEfiAcpiSdtProtocolGuid,                         NULL},
2302   {STRING_TOKEN(STR_SIO),                   &gEfiSioProtocolGuid,                             NULL},
2303   {STRING_TOKEN(STR_S_CPU2),                &gEfiSmmCpuIo2ProtocolGuid,                       NULL},
2304   {STRING_TOKEN(STR_S_BASE2),               &gEfiSmmBase2ProtocolGuid,                        NULL},
2305   {STRING_TOKEN(STR_S_ACC_2),               &gEfiSmmAccess2ProtocolGuid,                      NULL},
2306   {STRING_TOKEN(STR_S_CON_2),               &gEfiSmmControl2ProtocolGuid,                     NULL},
2307   {STRING_TOKEN(STR_S_CONFIG),              &gEfiSmmConfigurationProtocolGuid,                NULL},
2308   {STRING_TOKEN(STR_S_RTL),                 &gEfiSmmReadyToLockProtocolGuid,                  NULL},
2309   {STRING_TOKEN(STR_DS_RTL),                &gEfiDxeSmmReadyToLockProtocolGuid,               NULL},
2310   {STRING_TOKEN(STR_S_COMM),                &gEfiSmmCommunicationProtocolGuid,                NULL},
2311   {STRING_TOKEN(STR_S_STAT),                &gEfiSmmStatusCodeProtocolGuid,                   NULL},
2312   {STRING_TOKEN(STR_S_CPU),                 &gEfiSmmCpuProtocolGuid,                          NULL},
2313   {STRING_TOKEN(STR_S_PCIRBIO),             &gEfiSmmPciRootBridgeIoProtocolGuid,              NULL},
2314   {STRING_TOKEN(STR_S_SWD),                 &gEfiSmmSwDispatch2ProtocolGuid,                  NULL},
2315   {STRING_TOKEN(STR_S_SXD),                 &gEfiSmmSxDispatch2ProtocolGuid,                  NULL},
2316   {STRING_TOKEN(STR_S_PTD2),                &gEfiSmmPeriodicTimerDispatch2ProtocolGuid,       NULL},
2317   {STRING_TOKEN(STR_S_UD2),                 &gEfiSmmUsbDispatch2ProtocolGuid,                 NULL},
2318   {STRING_TOKEN(STR_S_GD2),                 &gEfiSmmGpiDispatch2ProtocolGuid,                 NULL},
2319   {STRING_TOKEN(STR_S_SBD2),                &gEfiSmmStandbyButtonDispatch2ProtocolGuid,       NULL},
2320   {STRING_TOKEN(STR_S_PBD2),                &gEfiSmmPowerButtonDispatch2ProtocolGuid,         NULL},
2321   {STRING_TOKEN(STR_S_ITD2),                &gEfiSmmIoTrapDispatch2ProtocolGuid,              NULL},
2322   {STRING_TOKEN(STR_PCD),                   &gEfiPcdProtocolGuid,                             NULL},
2323   {STRING_TOKEN(STR_FVB2),                  &gEfiFirmwareVolumeBlock2ProtocolGuid,            NULL},
2324   {STRING_TOKEN(STR_CPUIO2),                &gEfiCpuIo2ProtocolGuid,                          NULL},
2325   {STRING_TOKEN(STR_LEGACY_R2),             &gEfiLegacyRegion2ProtocolGuid,                   NULL},
2326   {STRING_TOKEN(STR_SAL_MIP),               &gEfiSalMcaInitPmiProtocolGuid,                   NULL},
2327   {STRING_TOKEN(STR_ES_BS),                 &gEfiExtendedSalBootServiceProtocolGuid,          NULL},
2328   {STRING_TOKEN(STR_ES_BIO),                &gEfiExtendedSalBaseIoServicesProtocolGuid,       NULL},
2329   {STRING_TOKEN(STR_ES_STALL),              &gEfiExtendedSalStallServicesProtocolGuid,        NULL},
2330   {STRING_TOKEN(STR_ES_RTC),                &gEfiExtendedSalRtcServicesProtocolGuid,          NULL},
2331   {STRING_TOKEN(STR_ES_VS),                 &gEfiExtendedSalVariableServicesProtocolGuid,     NULL},
2332   {STRING_TOKEN(STR_ES_MTC),                &gEfiExtendedSalMtcServicesProtocolGuid,          NULL},
2333   {STRING_TOKEN(STR_ES_RESET),              &gEfiExtendedSalResetServicesProtocolGuid,        NULL},
2334   {STRING_TOKEN(STR_ES_SC),                 &gEfiExtendedSalStatusCodeServicesProtocolGuid,   NULL},
2335   {STRING_TOKEN(STR_ES_FBS),                &gEfiExtendedSalFvBlockServicesProtocolGuid,      NULL},
2336   {STRING_TOKEN(STR_ES_MP),                 &gEfiExtendedSalMpServicesProtocolGuid,           NULL},
2337   {STRING_TOKEN(STR_ES_PAL),                &gEfiExtendedSalPalServicesProtocolGuid,          NULL},
2338   {STRING_TOKEN(STR_ES_BASE),               &gEfiExtendedSalBaseServicesProtocolGuid,         NULL},
2339   {STRING_TOKEN(STR_ES_MCA),                &gEfiExtendedSalMcaServicesProtocolGuid,          NULL},
2340   {STRING_TOKEN(STR_ES_PCI),                &gEfiExtendedSalPciServicesProtocolGuid,          NULL},
2341   {STRING_TOKEN(STR_ES_CACHE),              &gEfiExtendedSalCacheServicesProtocolGuid,        NULL},
2342   {STRING_TOKEN(STR_ES_MCA_LOG),            &gEfiExtendedSalMcaLogServicesProtocolGuid,       NULL},
2343   {STRING_TOKEN(STR_S2ARCH),                &gEfiSecurity2ArchProtocolGuid,                   NULL},
2344   {STRING_TOKEN(STR_EODXE),                 &gEfiSmmEndOfDxeProtocolGuid,                     NULL},
2345   {STRING_TOKEN(STR_ISAHC),                 &gEfiIsaHcProtocolGuid,                           NULL},
2346   {STRING_TOKEN(STR_ISAHC_B),               &gEfiIsaHcServiceBindingProtocolGuid,             NULL},
2347   {STRING_TOKEN(STR_SIO_C),                 &gEfiSioControlProtocolGuid,                      NULL},
2348   {STRING_TOKEN(STR_GET_PCD),               &gEfiGetPcdInfoProtocolGuid,                      NULL},
2349   {STRING_TOKEN(STR_I2C_M),                 &gEfiI2cMasterProtocolGuid,                       NULL},
2350   {STRING_TOKEN(STR_I2CIO),                 &gEfiI2cIoProtocolGuid,                           NULL},
2351   {STRING_TOKEN(STR_I2CEN),                 &gEfiI2cEnumerateProtocolGuid,                    NULL},
2352   {STRING_TOKEN(STR_I2C_H),                 &gEfiI2cHostProtocolGuid,                         NULL},
2353   {STRING_TOKEN(STR_I2C_BCM),               &gEfiI2cBusConfigurationManagementProtocolGuid,   NULL},
2354   {STRING_TOKEN(STR_TREE),                  &gEfiTrEEProtocolGuid,                            NULL},
2355   {STRING_TOKEN(STR_TCG2),                  &gEfiTcg2ProtocolGuid,                            NULL},
2356   {STRING_TOKEN(STR_TIMESTAMP),             &gEfiTimestampProtocolGuid,                       NULL},
2357   {STRING_TOKEN(STR_RNG),                   &gEfiRngProtocolGuid,                             NULL},
2358   {STRING_TOKEN(STR_NVMEPT),                &gEfiNvmExpressPassThruProtocolGuid,              NULL},
2359   {STRING_TOKEN(STR_H2_SB),                 &gEfiHash2ServiceBindingProtocolGuid,             NULL},
2360   {STRING_TOKEN(STR_HASH2),                 &gEfiHash2ProtocolGuid,                           NULL},
2361   {STRING_TOKEN(STR_BIO_C),                 &gEfiBlockIoCryptoProtocolGuid,                   NULL},
2362   {STRING_TOKEN(STR_SCR),                   &gEfiSmartCardReaderProtocolGuid,                 NULL},
2363   {STRING_TOKEN(STR_SCE),                   &gEfiSmartCardEdgeProtocolGuid,                   NULL},
2364   {STRING_TOKEN(STR_USB_FIO),               &gEfiUsbFunctionIoProtocolGuid,                   NULL},
2365   {STRING_TOKEN(STR_BC_HC),                 &gEfiBluetoothHcProtocolGuid,                     NULL},
2366   {STRING_TOKEN(STR_BC_IO_SB),              &gEfiBluetoothIoServiceBindingProtocolGuid,       NULL},
2367   {STRING_TOKEN(STR_BC_IO),                 &gEfiBluetoothIoProtocolGuid,                     NULL},
2368   {STRING_TOKEN(STR_BC_C),                  &gEfiBluetoothConfigProtocolGuid,                 NULL},
2369   {STRING_TOKEN(STR_REG_EXP),               &gEfiRegularExpressionProtocolGuid,               NULL},
2370   {STRING_TOKEN(STR_B_MGR_P),               &gEfiBootManagerPolicyProtocolGuid,               NULL},
2371   {STRING_TOKEN(STR_CKH),                   &gEfiConfigKeywordHandlerProtocolGuid,            NULL},
2372   {STRING_TOKEN(STR_WIFI),                  &gEfiWiFiProtocolGuid,                            NULL},
2373   {STRING_TOKEN(STR_EAP_M),                 &gEfiEapManagement2ProtocolGuid,                  NULL},
2374   {STRING_TOKEN(STR_EAP_C),                 &gEfiEapConfigurationProtocolGuid,                NULL},
2375   {STRING_TOKEN(STR_PKCS7),                 &gEfiPkcs7VerifyProtocolGuid,                     NULL},
2376   {STRING_TOKEN(STR_NET_DNS4_SB),           &gEfiDns4ServiceBindingProtocolGuid,              NULL},
2377   {STRING_TOKEN(STR_NET_DNS4),              &gEfiDns4ProtocolGuid,                            NULL},
2378   {STRING_TOKEN(STR_NET_DNS6_SB),           &gEfiDns6ServiceBindingProtocolGuid,              NULL},
2379   {STRING_TOKEN(STR_NET_DNS6),              &gEfiDns6ProtocolGuid,                            NULL},
2380   {STRING_TOKEN(STR_NET_HTTP_SB),           &gEfiHttpServiceBindingProtocolGuid,              NULL},
2381   {STRING_TOKEN(STR_NET_HTTP),              &gEfiHttpProtocolGuid,                            NULL},
2382   {STRING_TOKEN(STR_NET_HTTP_U),            &gEfiHttpUtilitiesProtocolGuid,                   NULL},
2383   {STRING_TOKEN(STR_REST),                  &gEfiRestProtocolGuid,                            NULL},
2384
2385 //
2386 // PI 1.5
2387 //
2388   {STRING_TOKEN(STR_MM_EOD),                &gEfiMmEndOfDxeProtocolGuid,                      NULL},
2389   {STRING_TOKEN(STR_MM_ITD),                &gEfiMmIoTrapDispatchProtocolGuid,                NULL},
2390   {STRING_TOKEN(STR_MM_PBD),                &gEfiMmPowerButtonDispatchProtocolGuid,           NULL},
2391   {STRING_TOKEN(STR_MM_SBD),                &gEfiMmStandbyButtonDispatchProtocolGuid,         NULL},
2392   {STRING_TOKEN(STR_MM_GD),                 &gEfiMmGpiDispatchProtocolGuid,                   NULL},
2393   {STRING_TOKEN(STR_MM_UD),                 &gEfiMmUsbDispatchProtocolGuid,                   NULL},
2394   {STRING_TOKEN(STR_MM_PTD),                &gEfiMmPeriodicTimerDispatchProtocolGuid,         NULL},
2395   {STRING_TOKEN(STR_MM_SXD),                &gEfiMmSxDispatchProtocolGuid,                    NULL},
2396   {STRING_TOKEN(STR_MM_SWD),                &gEfiMmSwDispatchProtocolGuid,                    NULL},
2397   {STRING_TOKEN(STR_MM_PRBI),               &gEfiMmPciRootBridgeIoProtocolGuid,               NULL},
2398   {STRING_TOKEN(STR_MM_CPU),                &gEfiMmCpuProtocolGuid,                           NULL},
2399   {STRING_TOKEN(STR_MM_STACODE),            &gEfiMmStatusCodeProtocolGuid,                    NULL},
2400   {STRING_TOKEN(STR_DXEMM_RTL),             &gEfiDxeMmReadyToLockProtocolGuid,                NULL},
2401   {STRING_TOKEN(STR_MM_CONFIG),             &gEfiMmConfigurationProtocolGuid,                 NULL},
2402   {STRING_TOKEN(STR_MM_RTL),                &gEfiMmReadyToLockProtocolGuid,                   NULL},
2403   {STRING_TOKEN(STR_MM_CONTROL),            &gEfiMmControlProtocolGuid,                       NULL},
2404   {STRING_TOKEN(STR_MM_ACCESS),             &gEfiMmAccessProtocolGuid,                        NULL},
2405   {STRING_TOKEN(STR_MM_BASE),               &gEfiMmBaseProtocolGuid,                          NULL},
2406   {STRING_TOKEN(STR_MM_CPUIO),              &gEfiMmCpuIoProtocolGuid,                         NULL},
2407   {STRING_TOKEN(STR_MM_RH),                 &gEfiMmRscHandlerProtocolGuid,                    NULL},
2408   {STRING_TOKEN(STR_MM_COM),                &gEfiMmCommunicationProtocolGuid,                 NULL},
2409
2410 //
2411 // UEFI Shell Spec 2.0
2412 //
2413   {STRING_TOKEN(STR_SHELL_PARAMETERS),      &gEfiShellParametersProtocolGuid,                 NULL},
2414   {STRING_TOKEN(STR_SHELL),                 &gEfiShellProtocolGuid,                           NULL},
2415
2416 //
2417 // UEFI Shell Spec 2.1
2418 //
2419   {STRING_TOKEN(STR_SHELL_DYNAMIC),         &gEfiShellDynamicCommandProtocolGuid,             NULL},
2420
2421 //
2422 // Misc
2423 //
2424   {STRING_TOKEN(STR_PCDINFOPROT),           &gGetPcdInfoProtocolGuid,                         NULL},
2425
2426 //
2427 // terminator
2428 //
2429   {0,                                       NULL,                                             NULL},
2430 };
2431
2432 /**
2433   Function to get the node for a protocol or struct from it's GUID.
2434
2435   if Guid is NULL, then ASSERT.
2436
2437   @param[in] Guid               The GUID to look for the name of.
2438
2439   @return                       The node.
2440 **/
2441 CONST GUID_INFO_BLOCK *
2442 InternalShellGetNodeFromGuid(
2443   IN CONST EFI_GUID* Guid
2444   )
2445 {
2446   CONST GUID_INFO_BLOCK *ListWalker;
2447   UINTN                 LoopCount;
2448
2449   ASSERT(Guid != NULL);
2450
2451   for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {
2452     if (CompareGuid(ListWalker->GuidId, Guid)) {
2453       return (ListWalker);
2454     }
2455   }
2456
2457   if (PcdGetBool(PcdShellIncludeNtGuids)) {
2458     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
2459       if (CompareGuid(ListWalker->GuidId, Guid)) {
2460         return (ListWalker);
2461       }
2462     }
2463   }
2464   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
2465     if (CompareGuid(ListWalker->GuidId, Guid)) {
2466       return (ListWalker);
2467     }
2468   }
2469   return (NULL);
2470 }
2471
2472 /**
2473 Function to add a new GUID/Name mapping.
2474
2475 @param[in] Guid       The Guid
2476 @param[in] NameID     The STRING id of the HII string to use
2477 @param[in] DumpFunc   The pointer to the dump function
2478
2479
2480 @retval EFI_SUCCESS           The operation was sucessful
2481 @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
2482 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
2483 **/
2484 EFI_STATUS
2485 InsertNewGuidNameMapping(
2486   IN CONST EFI_GUID           *Guid,
2487   IN CONST EFI_STRING_ID      NameID,
2488   IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
2489   )
2490 {
2491   ASSERT(Guid   != NULL);
2492   ASSERT(NameID != 0);
2493
2494   mGuidList = ReallocatePool(mGuidListCount * sizeof(GUID_INFO_BLOCK), mGuidListCount+1 * sizeof(GUID_INFO_BLOCK), mGuidList);
2495   if (mGuidList == NULL) {
2496     mGuidListCount = 0;
2497     return (EFI_OUT_OF_RESOURCES);
2498   }
2499   mGuidListCount++;
2500
2501   mGuidList[mGuidListCount - 1].GuidId   = AllocateCopyPool(sizeof(EFI_GUID), Guid);
2502   mGuidList[mGuidListCount - 1].StringId = NameID;
2503   mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;
2504
2505   if (mGuidList[mGuidListCount - 1].GuidId == NULL) {
2506     return (EFI_OUT_OF_RESOURCES);
2507   }
2508
2509   return (EFI_SUCCESS);
2510 }
2511
2512 /**
2513   Function to add a new GUID/Name mapping.
2514
2515   This cannot overwrite an existing mapping.
2516
2517   @param[in] Guid       The Guid
2518   @param[in] TheName    The Guid's name
2519   @param[in] Lang       RFC4646 language code list or NULL
2520
2521   @retval EFI_SUCCESS           The operation was sucessful
2522   @retval EFI_ACCESS_DENIED     There was a duplicate
2523   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
2524   @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
2525 **/
2526 EFI_STATUS
2527 EFIAPI
2528 AddNewGuidNameMapping(
2529   IN CONST EFI_GUID *Guid,
2530   IN CONST CHAR16   *TheName,
2531   IN CONST CHAR8    *Lang OPTIONAL
2532   )
2533 {
2534   EFI_STRING_ID         NameID;
2535
2536   HandleParsingHiiInit();
2537
2538   if (Guid == NULL || TheName == NULL){
2539     return (EFI_INVALID_PARAMETER);
2540   }
2541
2542   if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {
2543     return (EFI_ACCESS_DENIED);
2544   }
2545
2546   NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);
2547   if (NameID == 0) {
2548     return (EFI_OUT_OF_RESOURCES);
2549   }
2550
2551   return (InsertNewGuidNameMapping(Guid, NameID, NULL));
2552 }
2553
2554 /**
2555   Function to get the name of a protocol or struct from it's GUID.
2556
2557   if Guid is NULL, then ASSERT.
2558
2559   @param[in] Guid               The GUID to look for the name of.
2560   @param[in] Lang               The language to use.
2561
2562   @return                       pointer to string of the name.  The caller
2563                                 is responsible to free this memory.
2564 **/
2565 CHAR16*
2566 EFIAPI
2567 GetStringNameFromGuid(
2568   IN CONST EFI_GUID *Guid,
2569   IN CONST CHAR8    *Lang OPTIONAL
2570   )
2571 {
2572   CONST GUID_INFO_BLOCK *Id;
2573
2574   HandleParsingHiiInit();
2575
2576   Id = InternalShellGetNodeFromGuid(Guid);
2577   if (Id == NULL) {
2578     return NULL;
2579   }
2580   return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);
2581 }
2582
2583 /**
2584   Function to dump protocol information from a handle.
2585
2586   This function will return a allocated string buffer containing the
2587   information.  The caller is responsible for freeing the memory.
2588
2589   If Guid is NULL, ASSERT().
2590   If TheHandle is NULL, ASSERT().
2591
2592   @param[in] TheHandle      The handle to dump information from.
2593   @param[in] Guid           The GUID of the protocol to dump.
2594   @param[in] Verbose        TRUE for extra info.  FALSE otherwise.
2595
2596   @return                   The pointer to string.
2597   @retval NULL              An error was encountered.
2598 **/
2599 CHAR16*
2600 EFIAPI
2601 GetProtocolInformationDump(
2602   IN CONST EFI_HANDLE TheHandle,
2603   IN CONST EFI_GUID   *Guid,
2604   IN CONST BOOLEAN    Verbose
2605   )
2606 {
2607   CONST GUID_INFO_BLOCK *Id;
2608
2609   ASSERT(TheHandle  != NULL);
2610   ASSERT(Guid       != NULL);
2611
2612   if (TheHandle == NULL || Guid == NULL) {
2613     return (NULL);
2614   }
2615
2616   Id = InternalShellGetNodeFromGuid(Guid);
2617   if (Id != NULL && Id->DumpInfo != NULL) {
2618     return (Id->DumpInfo(TheHandle, Verbose));
2619   }
2620   return (NULL);
2621 }
2622
2623 /**
2624   Function to get the Guid for a protocol or struct based on it's string name.
2625
2626   do not modify the returned Guid.
2627
2628   @param[in] Name           The pointer to the string name.
2629   @param[in] Lang           The pointer to the language code.
2630   @param[out] Guid          The pointer to the Guid.
2631
2632   @retval EFI_SUCCESS       The operation was sucessful.
2633 **/
2634 EFI_STATUS
2635 EFIAPI
2636 GetGuidFromStringName(
2637   IN CONST CHAR16 *Name,
2638   IN CONST CHAR8  *Lang OPTIONAL,
2639   OUT EFI_GUID    **Guid
2640   )
2641 {
2642   CONST GUID_INFO_BLOCK  *ListWalker;
2643   CHAR16                     *String;
2644   UINTN                  LoopCount;
2645
2646   HandleParsingHiiInit();
2647
2648   ASSERT(Guid != NULL);
2649   if (Guid == NULL) {
2650     return (EFI_INVALID_PARAMETER);
2651   }
2652   *Guid = NULL;
2653
2654   if (PcdGetBool(PcdShellIncludeNtGuids)) {
2655     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
2656       String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2657       if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
2658         *Guid = ListWalker->GuidId;
2659       }
2660       SHELL_FREE_NON_NULL(String);
2661       if (*Guid != NULL) {
2662         return (EFI_SUCCESS);
2663       }
2664     }
2665   }
2666   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
2667     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2668     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
2669       *Guid = ListWalker->GuidId;
2670     }
2671     SHELL_FREE_NON_NULL(String);
2672     if (*Guid != NULL) {
2673       return (EFI_SUCCESS);
2674     }
2675   }
2676
2677   for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {
2678     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2679     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
2680       *Guid = ListWalker->GuidId;
2681     }
2682     SHELL_FREE_NON_NULL(String);
2683     if (*Guid != NULL) {
2684       return (EFI_SUCCESS);
2685     }
2686   }
2687
2688   return (EFI_NOT_FOUND);
2689 }
2690
2691 /**
2692   Get best support language for this driver.
2693
2694   First base on the user input language  to search, second base on the current
2695   platform used language to search, third get the first language from the
2696   support language list. The caller need to free the buffer of the best language.
2697
2698   @param[in] SupportedLanguages      The support languages for this driver.
2699   @param[in] InputLanguage           The user input language.
2700   @param[in] Iso639Language          Whether get language for ISO639.
2701
2702   @return                            The best support language for this driver.
2703 **/
2704 CHAR8 *
2705 EFIAPI
2706 GetBestLanguageForDriver (
2707   IN CONST CHAR8  *SupportedLanguages,
2708   IN CONST CHAR8  *InputLanguage,
2709   IN BOOLEAN      Iso639Language
2710   )
2711 {
2712   CHAR8                         *LanguageVariable;
2713   CHAR8                         *BestLanguage;
2714
2715   GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);
2716
2717   BestLanguage = GetBestLanguage(
2718                    SupportedLanguages,
2719                    Iso639Language,
2720                    (InputLanguage != NULL) ? InputLanguage : "",
2721                    (LanguageVariable != NULL) ? LanguageVariable : "",
2722                    SupportedLanguages,
2723                    NULL
2724                    );
2725
2726   if (LanguageVariable != NULL) {
2727     FreePool (LanguageVariable);
2728   }
2729
2730   return BestLanguage;
2731 }
2732
2733 /**
2734   Function to retrieve the driver name (if possible) from the ComponentName or
2735   ComponentName2 protocol
2736
2737   @param[in] TheHandle      The driver handle to get the name of.
2738   @param[in] Language       The language to use.
2739
2740   @retval NULL              The name could not be found.
2741   @return                   A pointer to the string name.  Do not de-allocate the memory.
2742 **/
2743 CONST CHAR16*
2744 EFIAPI
2745 GetStringNameFromHandle(
2746   IN CONST EFI_HANDLE TheHandle,
2747   IN CONST CHAR8      *Language
2748   )
2749 {
2750   EFI_COMPONENT_NAME2_PROTOCOL  *CompNameStruct;
2751   EFI_STATUS                    Status;
2752   CHAR16                        *RetVal;
2753   CHAR8                         *BestLang;
2754
2755   BestLang = NULL;
2756
2757   Status = gBS->OpenProtocol(
2758     TheHandle,
2759     &gEfiComponentName2ProtocolGuid,
2760     (VOID**)&CompNameStruct,
2761     gImageHandle,
2762     NULL,
2763     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
2764   if (!EFI_ERROR(Status)) {
2765     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
2766     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
2767     if (BestLang != NULL) {
2768       FreePool (BestLang);
2769       BestLang = NULL;
2770     }
2771     if (!EFI_ERROR(Status)) {
2772       return (RetVal);
2773     }
2774   }
2775   Status = gBS->OpenProtocol(
2776     TheHandle,
2777     &gEfiComponentNameProtocolGuid,
2778     (VOID**)&CompNameStruct,
2779     gImageHandle,
2780     NULL,
2781     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
2782   if (!EFI_ERROR(Status)) {
2783     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
2784     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
2785     if (BestLang != NULL) {
2786       FreePool (BestLang);
2787     }
2788     if (!EFI_ERROR(Status)) {
2789       return (RetVal);
2790     }
2791   }
2792   return (NULL);
2793 }
2794
2795 /**
2796   Function to initialize the file global mHandleList object for use in
2797   vonverting handles to index and index to handle.
2798
2799   @retval EFI_SUCCESS     The operation was successful.
2800 **/
2801 EFI_STATUS
2802 InternalShellInitHandleList(
2803   VOID
2804   )
2805 {
2806   EFI_STATUS   Status;
2807   EFI_HANDLE   *HandleBuffer;
2808   UINTN        HandleCount;
2809   HANDLE_LIST  *ListWalker;
2810
2811   if (mHandleList.NextIndex != 0) {
2812     return EFI_SUCCESS;
2813   }
2814   InitializeListHead(&mHandleList.List.Link);
2815   mHandleList.NextIndex = 1;
2816   Status = gBS->LocateHandleBuffer (
2817                 AllHandles,
2818                 NULL,
2819                 NULL,
2820                 &HandleCount,
2821                 &HandleBuffer
2822                );
2823   ASSERT_EFI_ERROR(Status);
2824   if (EFI_ERROR(Status)) {
2825     return (Status);
2826   }
2827   for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){
2828     ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
2829     if (ListWalker != NULL) {
2830       ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];
2831       ListWalker->TheIndex = mHandleList.NextIndex;
2832       InsertTailList (&mHandleList.List.Link, &ListWalker->Link);
2833     }
2834   }
2835   FreePool(HandleBuffer);
2836   return (EFI_SUCCESS);
2837 }
2838
2839 /**
2840   Function to retrieve the human-friendly index of a given handle.  If the handle
2841   does not have a index one will be automatically assigned.  The index value is valid
2842   until the termination of the shell application.
2843
2844   @param[in] TheHandle    The handle to retrieve an index for.
2845
2846   @retval 0               A memory allocation failed.
2847   @return                 The index of the handle.
2848
2849 **/
2850 UINTN
2851 EFIAPI
2852 ConvertHandleToHandleIndex(
2853   IN CONST EFI_HANDLE TheHandle
2854   )
2855 {
2856   EFI_STATUS   Status;
2857   EFI_GUID     **ProtocolBuffer;
2858   UINTN        ProtocolCount;
2859   HANDLE_LIST  *ListWalker;
2860
2861   if (TheHandle == NULL) {
2862     return 0;
2863   }
2864
2865   InternalShellInitHandleList();
2866
2867   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
2868     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
2869     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
2870    ){
2871     if (ListWalker->TheHandle == TheHandle) {
2872       //
2873       // Verify that TheHandle is still present in the Handle Database
2874       //
2875       Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
2876       if (EFI_ERROR (Status)) {
2877         //
2878         // TheHandle is not present in the Handle Database, so delete from the handle list
2879         //
2880         RemoveEntryList (&ListWalker->Link);
2881         return 0;
2882       }
2883       FreePool (ProtocolBuffer);
2884       return (ListWalker->TheIndex);
2885     }
2886   }
2887
2888   //
2889   // Verify that TheHandle is valid handle
2890   //
2891   Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
2892   if (EFI_ERROR (Status)) {
2893     //
2894     // TheHandle is not valid, so do not add to handle list
2895     //
2896     return 0;
2897   }
2898   FreePool (ProtocolBuffer);
2899
2900   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
2901   if (ListWalker == NULL) {
2902     return 0;
2903   }
2904   ListWalker->TheHandle = TheHandle;
2905   ListWalker->TheIndex  = mHandleList.NextIndex++;
2906   InsertTailList(&mHandleList.List.Link,&ListWalker->Link);
2907   return (ListWalker->TheIndex);
2908 }
2909
2910
2911
2912 /**
2913   Function to retrieve the EFI_HANDLE from the human-friendly index.
2914
2915   @param[in] TheIndex     The index to retrieve the EFI_HANDLE for.
2916
2917   @retval NULL            The index was invalid.
2918   @return                 The EFI_HANDLE that index represents.
2919
2920 **/
2921 EFI_HANDLE
2922 EFIAPI
2923 ConvertHandleIndexToHandle(
2924   IN CONST UINTN TheIndex
2925   )
2926 {
2927   EFI_STATUS   Status;
2928   EFI_GUID     **ProtocolBuffer;
2929   UINTN        ProtocolCount;
2930   HANDLE_LIST *ListWalker;
2931
2932   InternalShellInitHandleList();
2933
2934   if (TheIndex >= mHandleList.NextIndex) {
2935     return NULL;
2936   }
2937
2938   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
2939     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
2940     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
2941    ){
2942     if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {
2943       //
2944       // Verify that LinkWalker->TheHandle is valid handle
2945       //
2946       Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);
2947       if (!EFI_ERROR (Status)) {
2948         FreePool (ProtocolBuffer);
2949       } else {
2950         //
2951         // TheHandle is not valid, so do not add to handle list
2952         //
2953         ListWalker->TheHandle = NULL;
2954       }
2955       return (ListWalker->TheHandle);
2956     }
2957   }
2958   return NULL;
2959 }
2960
2961 /**
2962   Gets all the related EFI_HANDLEs based on the mask supplied.
2963
2964   This function scans all EFI_HANDLES in the UEFI environment's handle database
2965   and returns the ones with the specified relationship (Mask) to the specified
2966   controller handle.
2967
2968   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2969   If MatchingHandleCount is NULL, then ASSERT.
2970
2971   If MatchingHandleBuffer is not NULL upon a successful return the memory must be
2972   caller freed.
2973
2974   @param[in] DriverBindingHandle    The handle with Driver Binding protocol on it.
2975   @param[in] ControllerHandle       The handle with Device Path protocol on it.
2976   @param[in] MatchingHandleCount    The pointer to UINTN that specifies the number of HANDLES in
2977                                     MatchingHandleBuffer.
2978   @param[out] MatchingHandleBuffer  On a successful return, a buffer of MatchingHandleCount
2979                                     EFI_HANDLEs with a terminating NULL EFI_HANDLE.
2980   @param[out] HandleType            An array of type information.
2981
2982   @retval EFI_SUCCESS               The operation was successful, and any related handles
2983                                     are in MatchingHandleBuffer.
2984   @retval EFI_NOT_FOUND             No matching handles were found.
2985   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
2986 **/
2987 EFI_STATUS
2988 EFIAPI
2989 ParseHandleDatabaseByRelationshipWithType (
2990   IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,
2991   IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
2992   IN UINTN            *HandleCount,
2993   OUT EFI_HANDLE      **HandleBuffer,
2994   OUT UINTN           **HandleType
2995   )
2996 {
2997   EFI_STATUS                          Status;
2998   UINTN                               HandleIndex;
2999   EFI_GUID                            **ProtocolGuidArray;
3000   UINTN                               ArrayCount;
3001   UINTN                               ProtocolIndex;
3002   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
3003   UINTN                               OpenInfoCount;
3004   UINTN                               OpenInfoIndex;
3005   UINTN                               ChildIndex;
3006   INTN                                DriverBindingHandleIndex;
3007
3008   ASSERT(HandleCount  != NULL);
3009   ASSERT(HandleBuffer != NULL);
3010   ASSERT(HandleType   != NULL);
3011   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
3012
3013   *HandleCount                  = 0;
3014   *HandleBuffer                 = NULL;
3015   *HandleType                   = NULL;
3016
3017   //
3018   // Retrieve the list of all handles from the handle database
3019   //
3020   Status = gBS->LocateHandleBuffer (
3021                 AllHandles,
3022                 NULL,
3023                 NULL,
3024                 HandleCount,
3025                 HandleBuffer
3026                );
3027   if (EFI_ERROR (Status)) {
3028     return (Status);
3029   }
3030
3031   *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));
3032   if (*HandleType == NULL) {
3033     SHELL_FREE_NON_NULL (*HandleBuffer);
3034     *HandleCount = 0;
3035     return EFI_OUT_OF_RESOURCES;
3036   }
3037
3038   DriverBindingHandleIndex = -1;
3039   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
3040     if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {
3041       DriverBindingHandleIndex = (INTN)HandleIndex;
3042     }
3043   }
3044
3045   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
3046     //
3047     // Retrieve the list of all the protocols on each handle
3048     //
3049     Status = gBS->ProtocolsPerHandle (
3050                   (*HandleBuffer)[HandleIndex],
3051                   &ProtocolGuidArray,
3052                   &ArrayCount
3053                  );
3054     if (EFI_ERROR (Status)) {
3055       continue;
3056     }
3057
3058     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
3059
3060       //
3061       // Set the bit describing what this handle has
3062       //
3063       if        (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)         ) {
3064         (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;
3065       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)       ) {
3066         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;
3067       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
3068         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
3069       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {
3070         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
3071       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)  ) {
3072         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
3073       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)   ) {
3074         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
3075       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)      ) {
3076         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
3077       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)       ) {
3078         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
3079       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {
3080         (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;
3081       }
3082       //
3083       // Retrieve the list of agents that have opened each protocol
3084       //
3085       Status = gBS->OpenProtocolInformation (
3086                       (*HandleBuffer)[HandleIndex],
3087                       ProtocolGuidArray[ProtocolIndex],
3088                       &OpenInfo,
3089                       &OpenInfoCount
3090                      );
3091       if (EFI_ERROR (Status)) {
3092         continue;
3093       }
3094
3095       if (ControllerHandle == NULL) {
3096         //
3097         // ControllerHandle == NULL and DriverBindingHandle != NULL.
3098         // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
3099         //
3100         for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3101           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
3102             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3103             if (DriverBindingHandleIndex != -1) {
3104               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
3105             }
3106           }
3107           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3108             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3109             if (DriverBindingHandleIndex != -1) {
3110               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3111             }
3112             for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3113               if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3114                 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3115               }
3116             }
3117           }
3118         }
3119       }
3120       if (DriverBindingHandle == NULL && ControllerHandle != NULL) {
3121         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
3122           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3123           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3124             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
3125               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3126                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3127                   (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;
3128                 }
3129               }
3130             }
3131             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3132               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3133                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3134                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3135                 }
3136                 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3137                   (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3138                 }
3139               }
3140             }
3141           }
3142         } else {
3143           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3144             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3145               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
3146                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
3147               }
3148             }
3149           }
3150         }
3151       }
3152       if (DriverBindingHandle != NULL && ControllerHandle != NULL) {
3153         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
3154           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3155           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3156             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
3157               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
3158                 if (DriverBindingHandleIndex != -1) {
3159                   (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
3160                 }
3161               }
3162             }
3163             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3164               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
3165                 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3166                   if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3167                     (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3168                   }
3169                 }
3170               }
3171
3172               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3173                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3174                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3175                 }
3176               }
3177             }
3178           }
3179         } else {
3180           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3181             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3182               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
3183                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
3184               }
3185             }
3186           }
3187         }
3188       }
3189       FreePool (OpenInfo);
3190     }
3191     FreePool (ProtocolGuidArray);
3192   }
3193   return EFI_SUCCESS;
3194 }
3195
3196 /**
3197   Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
3198   supplied.
3199
3200   This function will scan all EFI_HANDLES in the UEFI environment's handle database
3201   and return all the ones with the specified relationship (Mask) to the specified
3202   controller handle.
3203
3204   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
3205   If MatchingHandleCount is NULL, then ASSERT.
3206
3207   If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
3208   caller freed.
3209
3210   @param[in] DriverBindingHandle    Handle to a object with Driver Binding protocol
3211                                     on it.
3212   @param[in] ControllerHandle       Handle to a device with Device Path protocol on it.
3213   @param[in] Mask                   Mask of what relationship(s) is desired.
3214   @param[in] MatchingHandleCount    Poitner to UINTN specifying number of HANDLES in
3215                                     MatchingHandleBuffer.
3216   @param[out] MatchingHandleBuffer  On a sucessful return a buffer of MatchingHandleCount
3217                                     EFI_HANDLEs and a terminating NULL EFI_HANDLE.
3218
3219   @retval EFI_SUCCESS               The operation was sucessful and any related handles
3220                                     are in MatchingHandleBuffer;
3221   @retval EFI_NOT_FOUND             No matching handles were found.
3222   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
3223 **/
3224 EFI_STATUS
3225 EFIAPI
3226 ParseHandleDatabaseByRelationship (
3227   IN CONST EFI_HANDLE       DriverBindingHandle OPTIONAL,
3228   IN CONST EFI_HANDLE       ControllerHandle OPTIONAL,
3229   IN CONST UINTN            Mask,
3230   IN UINTN                  *MatchingHandleCount,
3231   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
3232   )
3233 {
3234   EFI_STATUS            Status;
3235   UINTN                 HandleCount;
3236   EFI_HANDLE            *HandleBuffer;
3237   UINTN                 *HandleType;
3238   UINTN                 HandleIndex;
3239
3240   ASSERT(MatchingHandleCount != NULL);
3241   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
3242
3243   if ((Mask & HR_VALID_MASK) != Mask) {
3244     return (EFI_INVALID_PARAMETER);
3245   }
3246
3247   if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {
3248     return (EFI_INVALID_PARAMETER);
3249   }
3250
3251   *MatchingHandleCount = 0;
3252   if (MatchingHandleBuffer != NULL) {
3253     *MatchingHandleBuffer = NULL;
3254   }
3255
3256   HandleBuffer  = NULL;
3257   HandleType    = NULL;
3258
3259   Status = ParseHandleDatabaseByRelationshipWithType (
3260             DriverBindingHandle,
3261             ControllerHandle,
3262             &HandleCount,
3263             &HandleBuffer,
3264             &HandleType
3265            );
3266   if (!EFI_ERROR (Status)) {
3267     //
3268     // Count the number of handles that match the attributes in Mask
3269     //
3270     for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
3271       if ((HandleType[HandleIndex] & Mask) == Mask) {
3272         (*MatchingHandleCount)++;
3273       }
3274     }
3275     //
3276     // If no handles match the attributes in Mask then return EFI_NOT_FOUND
3277     //
3278     if (*MatchingHandleCount == 0) {
3279       Status = EFI_NOT_FOUND;
3280     } else {
3281
3282       if (MatchingHandleBuffer == NULL) {
3283         //
3284         // Someone just wanted the count...
3285         //
3286         Status = EFI_SUCCESS;
3287       } else {
3288         //
3289         // Allocate a handle buffer for the number of handles that matched the attributes in Mask
3290         //
3291         *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));
3292         if (*MatchingHandleBuffer == NULL) {
3293           Status = EFI_OUT_OF_RESOURCES;
3294         } else {
3295           for (HandleIndex = 0, *MatchingHandleCount = 0
3296                ;  HandleIndex < HandleCount
3297                ;  HandleIndex++
3298                ) {
3299             //
3300             // Fill the allocated buffer with the handles that matched the attributes in Mask
3301             //
3302             if ((HandleType[HandleIndex] & Mask) == Mask) {
3303               (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];
3304             }
3305           }
3306
3307           //
3308           // Make the last one NULL
3309           //
3310           (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;
3311
3312           Status = EFI_SUCCESS;
3313         } // *MatchingHandleBuffer == NULL (ELSE)
3314       } // MacthingHandleBuffer == NULL (ELSE)
3315     } // *MatchingHandleCount  == 0 (ELSE)
3316   } // no error on ParseHandleDatabaseByRelationshipWithType
3317
3318   if (HandleBuffer != NULL) {
3319     FreePool (HandleBuffer);
3320   }
3321
3322   if (HandleType != NULL) {
3323     FreePool (HandleType);
3324   }
3325
3326   ASSERT ((MatchingHandleBuffer == NULL) ||
3327           (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||
3328           (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));
3329   return Status;
3330 }
3331
3332 /**
3333   Gets handles for any child controllers of the passed in controller.
3334
3335   @param[in] ControllerHandle       The handle of the "parent controller"
3336   @param[out] MatchingHandleCount   Pointer to the number of handles in
3337                                     MatchingHandleBuffer on return.
3338   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
3339                                     return.
3340
3341
3342   @retval EFI_SUCCESS               The operation was sucessful.
3343 **/
3344 EFI_STATUS
3345 EFIAPI
3346 ParseHandleDatabaseForChildControllers(
3347   IN CONST EFI_HANDLE       ControllerHandle,
3348   OUT UINTN                 *MatchingHandleCount,
3349   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
3350   )
3351 {
3352   EFI_STATUS  Status;
3353   UINTN       HandleIndex;
3354   UINTN       DriverBindingHandleCount;
3355   EFI_HANDLE  *DriverBindingHandleBuffer;
3356   UINTN       DriverBindingHandleIndex;
3357   UINTN       ChildControllerHandleCount;
3358   EFI_HANDLE  *ChildControllerHandleBuffer;
3359   UINTN       ChildControllerHandleIndex;
3360   EFI_HANDLE  *HandleBufferForReturn;
3361
3362   if (MatchingHandleCount == NULL) {
3363     return (EFI_INVALID_PARAMETER);
3364   }
3365   *MatchingHandleCount = 0;
3366
3367   Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
3368             ControllerHandle,
3369             &DriverBindingHandleCount,
3370             &DriverBindingHandleBuffer
3371            );
3372   if (EFI_ERROR (Status)) {
3373     return Status;
3374   }
3375
3376   //
3377   // Get a buffer big enough for all the controllers.
3378   //
3379   HandleBufferForReturn = GetHandleListByProtocol(NULL);
3380   if (HandleBufferForReturn == NULL) {
3381     FreePool (DriverBindingHandleBuffer);
3382     return (EFI_NOT_FOUND);
3383   }
3384
3385   for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {
3386     Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3387               DriverBindingHandleBuffer[DriverBindingHandleIndex],
3388               ControllerHandle,
3389               &ChildControllerHandleCount,
3390               &ChildControllerHandleBuffer
3391              );
3392     if (EFI_ERROR (Status)) {
3393       continue;
3394     }
3395
3396     for (ChildControllerHandleIndex = 0;
3397          ChildControllerHandleIndex < ChildControllerHandleCount;
3398          ChildControllerHandleIndex++
3399        ) {
3400       for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {
3401         if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
3402           break;
3403         }
3404       }
3405       if (HandleIndex >= *MatchingHandleCount) {
3406         HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
3407       }
3408     }
3409
3410     FreePool (ChildControllerHandleBuffer);
3411   }
3412
3413   FreePool (DriverBindingHandleBuffer);
3414
3415   if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {
3416     //
3417     // The caller is not interested in the actual handles, or we've found none.
3418     //
3419     FreePool (HandleBufferForReturn);
3420     HandleBufferForReturn = NULL;
3421   }
3422
3423   if (MatchingHandleBuffer != NULL) {
3424     *MatchingHandleBuffer = HandleBufferForReturn;
3425   }
3426
3427   ASSERT ((MatchingHandleBuffer == NULL) ||
3428           (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||
3429           (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));
3430
3431   return (EFI_SUCCESS);
3432 }
3433
3434 /**
3435   Appends 1 buffer to another buffer.  This will re-allocate the destination buffer
3436   if necessary to fit all of the data.
3437
3438   If DestinationBuffer is NULL, then ASSERT().
3439
3440   @param[in, out]  DestinationBuffer The pointer to the pointer to the buffer to append onto.
3441   @param[in, out]  DestinationSize   The pointer to the size of DestinationBuffer.
3442   @param[in]       SourceBuffer      The pointer to the buffer to append onto DestinationBuffer.
3443   @param[in]       SourceSize        The number of bytes of SourceBuffer to append.
3444
3445   @retval NULL                      A memory allocation failed.
3446   @retval NULL                      A parameter was invalid.
3447   @return                           A pointer to (*DestinationBuffer).
3448 **/
3449 VOID*
3450 BuffernCatGrow (
3451   IN OUT VOID   **DestinationBuffer,
3452   IN OUT UINTN  *DestinationSize,
3453   IN     VOID   *SourceBuffer,
3454   IN     UINTN  SourceSize
3455   )
3456 {
3457   UINTN LocalDestinationSize;
3458   UINTN LocalDestinationFinalSize;
3459
3460   ASSERT(DestinationBuffer != NULL);
3461
3462   if (SourceSize == 0 || SourceBuffer == NULL) {
3463     return (*DestinationBuffer);
3464   }
3465
3466   if (DestinationSize == NULL) {
3467     LocalDestinationSize = 0;
3468   } else {
3469     LocalDestinationSize = *DestinationSize;
3470   }
3471
3472   LocalDestinationFinalSize = LocalDestinationSize + SourceSize;
3473
3474   if (DestinationSize != NULL) {
3475     *DestinationSize = LocalDestinationSize;
3476   }
3477
3478   if (LocalDestinationSize == 0) {
3479     // allcoate
3480     *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);
3481   } else {
3482     // reallocate
3483     *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);
3484   }
3485
3486   ASSERT(*DestinationBuffer != NULL);
3487
3488   // copy
3489   return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));
3490 }
3491
3492 /**
3493   Gets handles for any child devices produced by the passed in driver.
3494
3495   @param[in] DriverHandle           The handle of the driver.
3496   @param[in] MatchingHandleCount    Pointer to the number of handles in
3497                                     MatchingHandleBuffer on return.
3498   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
3499                                     return.
3500   @retval EFI_SUCCESS               The operation was sucessful.
3501   @sa ParseHandleDatabaseByRelationship
3502 **/
3503 EFI_STATUS
3504 EFIAPI
3505 ParseHandleDatabaseForChildDevices(
3506   IN CONST EFI_HANDLE       DriverHandle,
3507   IN UINTN                  *MatchingHandleCount,
3508   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
3509   )
3510 {
3511   EFI_HANDLE      *Buffer;
3512   EFI_HANDLE      *Buffer2;
3513   UINTN           Count1;
3514   UINTN           Count2;
3515   UINTN           HandleIndex;
3516   EFI_STATUS      Status;
3517   UINTN           HandleBufferSize;
3518
3519   ASSERT(MatchingHandleCount != NULL);
3520
3521   HandleBufferSize      = 0;
3522   Buffer                = NULL;
3523   Buffer2               = NULL;
3524   *MatchingHandleCount  = 0;
3525
3526   Status = PARSE_HANDLE_DATABASE_DEVICES (
3527             DriverHandle,
3528             &Count1,
3529             &Buffer
3530            );
3531   if (!EFI_ERROR (Status)) {
3532     for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {
3533       //
3534       // now find the children
3535       //
3536       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3537                 DriverHandle,
3538                 Buffer[HandleIndex],
3539                 &Count2,
3540                 &Buffer2
3541                );
3542       if (EFI_ERROR(Status)) {
3543         break;
3544       }
3545       //
3546       // save out required and optional data elements
3547       //
3548       *MatchingHandleCount += Count2;
3549       if (MatchingHandleBuffer != NULL) {
3550         *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));
3551       }
3552
3553       //
3554       // free the memory
3555       //
3556       if (Buffer2 != NULL) {
3557         FreePool(Buffer2);
3558       }
3559     }
3560   }
3561
3562   if (Buffer != NULL) {
3563     FreePool(Buffer);
3564   }
3565   return (Status);
3566 }
3567
3568 /**
3569   Function to get all handles that support a given protocol or all handles.
3570
3571   @param[in] ProtocolGuid The guid of the protocol to get handles for.  If NULL
3572                           then the function will return all handles.
3573
3574   @retval NULL            A memory allocation failed.
3575   @return                 A NULL terminated list of handles.
3576 **/
3577 EFI_HANDLE*
3578 EFIAPI
3579 GetHandleListByProtocol (
3580   IN CONST EFI_GUID *ProtocolGuid OPTIONAL
3581   )
3582 {
3583   EFI_HANDLE          *HandleList;
3584   UINTN               Size;
3585   EFI_STATUS          Status;
3586
3587   Size = 0;
3588   HandleList = NULL;
3589
3590   //
3591   // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
3592   //
3593   if (ProtocolGuid == NULL) {
3594     Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
3595     if (Status == EFI_BUFFER_TOO_SMALL) {
3596       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
3597       if (HandleList == NULL) {
3598         return (NULL);
3599       }
3600       Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
3601       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
3602     }
3603   } else {
3604     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
3605     if (Status == EFI_BUFFER_TOO_SMALL) {
3606       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
3607       if (HandleList == NULL) {
3608         return (NULL);
3609       }
3610       Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
3611       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
3612     }
3613   }
3614   if (EFI_ERROR(Status)) {
3615     if (HandleList != NULL) {
3616       FreePool(HandleList);
3617     }
3618     return (NULL);
3619   }
3620   return (HandleList);
3621 }
3622
3623 /**
3624   Function to get all handles that support some protocols.
3625
3626   @param[in] ProtocolGuids  A NULL terminated list of protocol GUIDs.
3627
3628   @retval NULL              A memory allocation failed.
3629   @retval NULL              ProtocolGuids was NULL.
3630   @return                   A NULL terminated list of EFI_HANDLEs.
3631 **/
3632 EFI_HANDLE*
3633 EFIAPI
3634 GetHandleListByProtocolList (
3635   IN CONST EFI_GUID **ProtocolGuids
3636   )
3637 {
3638   EFI_HANDLE          *HandleList;
3639   UINTN               Size;
3640   UINTN               TotalSize;
3641   UINTN               TempSize;
3642   EFI_STATUS          Status;
3643   CONST EFI_GUID      **GuidWalker;
3644   EFI_HANDLE          *HandleWalker1;
3645   EFI_HANDLE          *HandleWalker2;
3646
3647   Size        = 0;
3648   HandleList  = NULL;
3649   TotalSize   = sizeof(EFI_HANDLE);
3650
3651   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){
3652     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);
3653     if (Status == EFI_BUFFER_TOO_SMALL) {
3654       TotalSize += Size;
3655     }
3656   }
3657
3658   //
3659   // No handles were found...
3660   //
3661   if (TotalSize == sizeof(EFI_HANDLE)) {
3662     return (NULL);
3663   }
3664
3665   HandleList = AllocateZeroPool(TotalSize);
3666   if (HandleList == NULL) {
3667     return (NULL);
3668   }
3669
3670   Size = 0;
3671   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){
3672     TempSize = TotalSize - Size;
3673     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));
3674
3675     //
3676     // Allow for missing protocols... Only update the 'used' size upon success.
3677     //
3678     if (!EFI_ERROR(Status)) {
3679       Size += TempSize;
3680     }
3681   }
3682   ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);
3683
3684   for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {
3685     for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {
3686       if (*HandleWalker1 == *HandleWalker2) {
3687         //
3688         // copy memory back 1 handle width.
3689         //
3690         CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));
3691       }
3692     }
3693   }
3694
3695   return (HandleList);
3696 }
3697
3698 /**
3699   Return all supported GUIDs.
3700
3701   @param[out]     Guids  The buffer to return all supported GUIDs.
3702   @param[in, out] Count  On input, the count of GUIDs the buffer can hold,
3703                          On output, the count of GUIDs to return.
3704
3705   @retval EFI_INVALID_PARAMETER Count is NULL.
3706   @retval EFI_BUFFER_TOO_SMALL  Buffer is not enough to hold all GUIDs.
3707   @retval EFI_SUCCESS           GUIDs are returned successfully.
3708 **/
3709 EFI_STATUS
3710 EFIAPI
3711 GetAllMappingGuids (
3712   OUT EFI_GUID *Guids,
3713   IN OUT UINTN *Count
3714   )
3715 {
3716   UINTN GuidCount;
3717   UINTN NtGuidCount;
3718   UINTN Index;
3719
3720   if (Count == NULL) {
3721     return EFI_INVALID_PARAMETER;
3722   }
3723
3724   NtGuidCount = 0;
3725   if (PcdGetBool (PcdShellIncludeNtGuids)) {
3726     NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;
3727   }
3728   GuidCount   = ARRAY_SIZE (mGuidStringList) - 1;
3729
3730   if (*Count < NtGuidCount + GuidCount + mGuidListCount) {
3731     *Count = NtGuidCount + GuidCount + mGuidListCount;
3732     return EFI_BUFFER_TOO_SMALL;
3733   }
3734
3735   for (Index = 0; Index < NtGuidCount; Index++) {
3736     CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);
3737   }
3738
3739   for (Index = 0; Index < GuidCount; Index++) {
3740     CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);
3741   }
3742
3743   for (Index = 0; Index < mGuidListCount; Index++) {
3744     CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);
3745   }
3746
3747   return EFI_SUCCESS;
3748 }