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) 2013 - 2014, Hewlett-Packard Development Company, L.P.
   5   Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UefiHandleParsingLib.h"
  17 #include "IndustryStandard/Acpi10.h"
  18
  19 EFI_HANDLE        mHandleParsingHiiHandle = NULL;
  20 HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};
  21 GUID_INFO_BLOCK   *GuidList;
  22 UINTN             GuidListCount;
  23 /**
  24   Function to translate the EFI_MEMORY_TYPE into a string.
  25
  26   @param[in] Memory     The memory type.
  27
  28   @retval               A string representation of the type allocated from BS Pool.
  29 **/
  30 CHAR16*
  31 EFIAPI
  32 ConvertMemoryType (
  33   IN CONST EFI_MEMORY_TYPE Memory
  34   )
  35 {
  36   CHAR16 *RetVal;
  37   RetVal = NULL;
  38
  39   switch (Memory) {
  40   case EfiReservedMemoryType:       StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0);        break;
  41   case EfiLoaderCode:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0);                break;
  42   case EfiLoaderData:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0);                break;
  43   case EfiBootServicesCode:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0);          break;
  44   case EfiBootServicesData:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0);          break;
  45   case EfiRuntimeServicesCode:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0);       break;
  46   case EfiRuntimeServicesData:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0);       break;
  47   case EfiConventionalMemory:       StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0);        break;
  48   case EfiUnusableMemory:           StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0);            break;
  49   case EfiACPIReclaimMemory:        StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0);         break;
  50   case EfiACPIMemoryNVS:            StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0);             break;
  51   case EfiMemoryMappedIO:           StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0);            break;
  52   case EfiMemoryMappedIOPortSpace:  StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0);   break;
  53   case EfiPalCode:                  StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0);                   break;
  54   case EfiMaxMemoryType:            StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0);             break;
  55   default: ASSERT(FALSE);
  56   }
  57   return (RetVal);
  58 }
  59
  60 /**
  61   Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
  62
  63   @param[in] Fmt     The format type.
  64
  65   @retval               A string representation of the type allocated from BS Pool.
  66 **/
  67 CHAR16*
  68 EFIAPI
  69 ConvertPixelFormat (
  70   IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
  71   )
  72 {
  73   CHAR16 *RetVal;
  74   RetVal = NULL;
  75
  76   switch (Fmt) {
  77   case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0);  break;
  78   case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0);  break;
  79   case PixelBitMask:                          StrnCatGrow(&RetVal, NULL, L"PixelBitMask", 0);                           break;
  80   case PixelBltOnly:                          StrnCatGrow(&RetVal, NULL, L"PixelBltOnly", 0);                           break;
  81   case PixelFormatMax:                        StrnCatGrow(&RetVal, NULL, L"PixelFormatMax", 0);                         break;
  82   default: ASSERT(FALSE);
  83   }
  84   return (RetVal);
  85 }
  86
  87 /**
  88   Constructor for the library.
  89
  90   @param[in] ImageHandle    Ignored.
  91   @param[in] SystemTable    Ignored.
  92
  93   @retval EFI_SUCCESS   The operation was successful.
  94 **/
  95 EFI_STATUS
  96 EFIAPI
  97 HandleParsingLibConstructor (
  98   IN EFI_HANDLE        ImageHandle,
  99   IN EFI_SYSTEM_TABLE  *SystemTable
 100   )
 101 {
 102   GuidListCount = 0;
 103   GuidList      = NULL;
 104
 105   //
 106   // Do nothing with mHandleParsingHiiHandle.  Initialize HII as needed.
 107   //
 108   return (EFI_SUCCESS);
 109 }
 110
 111 /**
 112   Initialization function for HII packages.
 113
 114 **/
 115 VOID
 116 HandleParsingHiiInit (VOID)
 117 {
 118   if (mHandleParsingHiiHandle == NULL) {
 119     mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);
 120     ASSERT (mHandleParsingHiiHandle != NULL);
 121   }
 122 }
 123
 124 /**
 125   Destructor for the library.  free any resources.
 126
 127   @param[in] ImageHandle    Ignored.
 128   @param[in] SystemTable    Ignored.
 129
 130   @retval EFI_SUCCESS   The operation was successful.
 131 **/
 132 EFI_STATUS
 133 EFIAPI
 134 HandleParsingLibDestructor (
 135   IN EFI_HANDLE        ImageHandle,
 136   IN EFI_SYSTEM_TABLE  *SystemTable
 137   )
 138 {
 139   UINTN                 LoopCount;
 140
 141   for (LoopCount = 0; GuidList != NULL && LoopCount < GuidListCount; LoopCount++) {
 142     SHELL_FREE_NON_NULL(GuidList[LoopCount].GuidId);
 143   }
 144
 145   SHELL_FREE_NON_NULL(GuidList);
 146   if (mHandleParsingHiiHandle != NULL) {
 147     HiiRemovePackages(mHandleParsingHiiHandle);
 148   }
 149   return (EFI_SUCCESS);
 150 }
 151
 152 /**
 153   Function to dump information about LoadedImage.
 154
 155   This will allocate the return buffer from boot services pool.
 156
 157   @param[in] TheHandle      The handle that has LoadedImage installed.
 158   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 159
 160   @retval A poitner to a string containing the information.
 161 **/
 162 CHAR16*
 163 EFIAPI
 164 LoadedImageProtocolDumpInformation(
 165   IN CONST EFI_HANDLE TheHandle,
 166   IN CONST BOOLEAN    Verbose
 167   )
 168 {
 169   EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;
 170   EFI_STATUS                        Status;
 171   CHAR16                            *RetVal;
 172   CHAR16                            *Temp;
 173   CHAR16                            *CodeType;
 174   CHAR16                            *DataType;
 175
 176   if (!Verbose) {
 177     return (CatSPrint(NULL, L"LoadedImage"));
 178   }
 179
 180   HandleParsingHiiInit();
 181
 182   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);
 183   RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));
 184   if (Temp == NULL || RetVal == NULL) {
 185     SHELL_FREE_NON_NULL(Temp);
 186     SHELL_FREE_NON_NULL(RetVal);
 187     return NULL;
 188   }
 189
 190   Status = gBS->OpenProtocol (
 191                 TheHandle,
 192                 &gEfiLoadedImageProtocolGuid,
 193                 (VOID**)&LoadedImage,
 194                 gImageHandle,
 195                 NULL,
 196                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 197                );
 198
 199   if (EFI_ERROR (Status)) {
 200     SHELL_FREE_NON_NULL (Temp);
 201     SHELL_FREE_NON_NULL (RetVal);
 202     return NULL;
 203   }
 204
 205   DataType = ConvertMemoryType(LoadedImage->ImageDataType);
 206   CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);
 207
 208   RetVal = CatSPrint(RetVal,
 209                       Temp,
 210                       LoadedImage->Revision,
 211                       LoadedImage->ParentHandle,
 212                       LoadedImage->SystemTable,
 213                       LoadedImage->DeviceHandle,
 214                       LoadedImage->FilePath,
 215                       LoadedImage->LoadOptionsSize,
 216                       LoadedImage->LoadOptions,
 217                       LoadedImage->ImageBase,
 218                       LoadedImage->ImageSize,
 219                       CodeType,
 220                       DataType,
 221                       LoadedImage->Unload);
 222
 223
 224   SHELL_FREE_NON_NULL(Temp);
 225   SHELL_FREE_NON_NULL(CodeType);
 226   SHELL_FREE_NON_NULL(DataType);
 227
 228   return RetVal;
 229 }
 230
 231 /**
 232   Function to dump information about GOP.
 233
 234   This will allocate the return buffer from boot services pool.
 235
 236   @param[in] TheHandle      The handle that has LoadedImage installed.
 237   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 238
 239   @retval A poitner to a string containing the information.
 240 **/
 241 CHAR16*
 242 EFIAPI
 243 GraphicsOutputProtocolDumpInformation(
 244   IN CONST EFI_HANDLE TheHandle,
 245   IN CONST BOOLEAN    Verbose
 246   )
 247 {
 248   EFI_GRAPHICS_OUTPUT_PROTOCOL      *GraphicsOutput;
 249   EFI_STATUS                        Status;
 250   CHAR16                            *RetVal;
 251   CHAR16                            *Temp;
 252   CHAR16                            *Fmt;
 253
 254   if (!Verbose) {
 255     return (CatSPrint(NULL, L"GraphicsOutput"));
 256   }
 257
 258   HandleParsingHiiInit();
 259
 260   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);
 261   RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));
 262   if (Temp == NULL || RetVal == NULL) {
 263     SHELL_FREE_NON_NULL(Temp);
 264     SHELL_FREE_NON_NULL(RetVal);
 265     return NULL;
 266   }
 267
 268   Status = gBS->OpenProtocol (
 269                 TheHandle,
 270                 &gEfiGraphicsOutputProtocolGuid,
 271                 (VOID**)&GraphicsOutput,
 272                 gImageHandle,
 273                 NULL,
 274                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 275                );
 276
 277   if (EFI_ERROR (Status)) {
 278     SHELL_FREE_NON_NULL (Temp);
 279     SHELL_FREE_NON_NULL (RetVal);
 280     return NULL;
 281   }
 282
 283   Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);
 284
 285   RetVal = CatSPrint(RetVal,
 286                       Temp,
 287                       GraphicsOutput->Mode->MaxMode,
 288                       GraphicsOutput->Mode->Mode,
 289                       GraphicsOutput->Mode->FrameBufferBase,
 290                       (UINT64)GraphicsOutput->Mode->FrameBufferSize,
 291                       (UINT64)GraphicsOutput->Mode->SizeOfInfo,
 292                       GraphicsOutput->Mode->Info->Version,
 293                       GraphicsOutput->Mode->Info->HorizontalResolution,
 294                       GraphicsOutput->Mode->Info->VerticalResolution,
 295                       Fmt,
 296                       GraphicsOutput->Mode->Info->PixelsPerScanLine,
 297                       GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.RedMask,
 298                       GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.GreenMask,
 299                       GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask
 300                       );
 301
 302   SHELL_FREE_NON_NULL(Temp);
 303   SHELL_FREE_NON_NULL(Fmt);
 304
 305   return RetVal;
 306 }
 307
 308 /**
 309   Function to dump information about PciRootBridgeIo.
 310
 311   This will allocate the return buffer from boot services pool.
 312
 313   @param[in] TheHandle      The handle that has PciRootBridgeIo installed.
 314   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 315
 316   @retval A poitner to a string containing the information.
 317 **/
 318 CHAR16*
 319 EFIAPI
 320 PciRootBridgeIoDumpInformation(
 321   IN CONST EFI_HANDLE TheHandle,
 322   IN CONST BOOLEAN    Verbose
 323   )
 324 {
 325   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   *PciRootBridgeIo;
 326   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;
 327   UINT64                            Supports;
 328   UINT64                            Attributes;
 329   CHAR16                            *Temp;
 330   CHAR16                            *Temp2;
 331   CHAR16                            *RetVal;
 332   EFI_STATUS                        Status;
 333
 334   RetVal  = NULL;
 335
 336   if (!Verbose) {
 337     return (CatSPrint(NULL, L"PciRootBridgeIo"));
 338   }
 339
 340   HandleParsingHiiInit();
 341
 342   Status = gBS->HandleProtocol(
 343     TheHandle,
 344     &gEfiPciRootBridgeIoProtocolGuid,
 345     (VOID**)&PciRootBridgeIo);
 346
 347   if (EFI_ERROR(Status)) {
 348     return NULL;
 349   }
 350
 351   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_PH), NULL);
 352   ASSERT (Temp != NULL);
 353   Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);
 354   FreePool(Temp);
 355   RetVal = Temp2;
 356   Temp2 = NULL;
 357
 358   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);
 359   ASSERT (Temp != NULL);
 360   Temp2 = CatSPrint(RetVal, Temp, PciRootBridgeIo->SegmentNumber);
 361   FreePool(Temp);
 362   FreePool(RetVal);
 363   RetVal = Temp2;
 364   Temp2 = NULL;
 365
 366   Supports   = 0;
 367   Attributes = 0;
 368   Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);
 369   if (!EFI_ERROR(Status)) {
 370     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_ATT), NULL);
 371     ASSERT (Temp != NULL);
 372     Temp2 = CatSPrint(RetVal, Temp, Attributes);
 373     FreePool(Temp);
 374     FreePool(RetVal);
 375     RetVal = Temp2;
 376     Temp2 = NULL;
 377
 378     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);
 379     ASSERT (Temp != NULL);
 380     Temp2 = CatSPrint(RetVal, Temp, Supports);
 381     FreePool(Temp);
 382     FreePool(RetVal);
 383     RetVal = Temp2;
 384     Temp2 = NULL;
 385   }
 386
 387   Configuration   = NULL;
 388   Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);
 389   if (!EFI_ERROR(Status) && Configuration != NULL) {
 390     Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_TITLE), NULL);
 391     ASSERT (Temp != NULL);
 392     Temp2 = CatSPrint(RetVal, Temp, Supports);
 393     FreePool(Temp);
 394     FreePool(RetVal);
 395     RetVal = Temp2;
 396     Temp2 = NULL;
 397     while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {
 398       Temp = NULL;
 399       switch (Configuration->ResType) {
 400       case ACPI_ADDRESS_SPACE_TYPE_MEM:
 401         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_MEM), NULL);
 402         break;
 403       case ACPI_ADDRESS_SPACE_TYPE_IO:
 404         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_IO), NULL);
 405         break;
 406       case ACPI_ADDRESS_SPACE_TYPE_BUS:
 407         Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_BUS), NULL);
 408         break;
 409       }
 410       if (Temp != NULL) {
 411         Temp2 = CatSPrint(RetVal, L"%s", Temp);
 412         FreePool(Temp);
 413         FreePool(RetVal);
 414         RetVal = Temp2;
 415         Temp2 = NULL;
 416       }
 417
 418       Temp2 = CatSPrint(RetVal,
 419         L"%H%02x    %016lx  %016lx  %02x%N\r\n",
 420         Configuration->SpecificFlag,
 421         Configuration->AddrRangeMin,
 422         Configuration->AddrRangeMax,
 423         Configuration->AddrSpaceGranularity
 424         );
 425       FreePool(RetVal);
 426       RetVal = Temp2;
 427       Temp2 = NULL;
 428       Configuration++;
 429     }
 430   }
 431   return (RetVal);
 432 }
 433
 434 /**
 435   Function to dump information about SimpleTextOut.
 436
 437   This will allocate the return buffer from boot services pool.
 438
 439   @param[in] TheHandle      The handle that has SimpleTextOut installed.
 440   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 441
 442   @retval A poitner to a string containing the information.
 443 **/
 444 CHAR16*
 445 EFIAPI
 446 TxtOutProtocolDumpInformation(
 447   IN CONST EFI_HANDLE TheHandle,
 448   IN CONST BOOLEAN    Verbose
 449   )
 450 {
 451   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Dev;
 452   INTN                            Index;
 453   UINTN                           Col;
 454   UINTN                           Row;
 455   EFI_STATUS                      Status;
 456   CHAR16                          *RetVal;
 457   UINTN                           Size;
 458   CHAR16                          *Temp;
 459   UINTN                           NewSize;
 460
 461   if (!Verbose) {
 462     return (NULL);
 463   }
 464
 465   HandleParsingHiiInit();
 466
 467   RetVal  = NULL;
 468   Size    = 0;
 469
 470   Status = gBS->HandleProtocol(
 471     TheHandle,
 472     &gEfiSimpleTextOutProtocolGuid,
 473     (VOID**)&Dev);
 474
 475   ASSERT_EFI_ERROR(Status);
 476   ASSERT (Dev != NULL && Dev->Mode != NULL);
 477
 478   Size = (Dev->Mode->MaxMode + 1) * 80;
 479   RetVal = AllocateZeroPool(Size);
 480
 481   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER), NULL);
 482   if (Temp != NULL) {
 483     UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);
 484     FreePool(Temp);
 485   }
 486
 487   //
 488   // Dump TextOut Info
 489   //
 490   Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE), NULL);
 491   for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {
 492     Status = Dev->QueryMode (Dev, Index, &Col, &Row);
 493     NewSize = Size - StrSize(RetVal);
 494     UnicodeSPrint(
 495       RetVal + StrLen(RetVal),
 496       NewSize,
 497       Temp == NULL?L"":Temp,
 498       Index == Dev->Mode->Mode ? L'*' : L' ',
 499       Index,
 500       !EFI_ERROR(Status)?(INTN)Col:-1,
 501       !EFI_ERROR(Status)?(INTN)Row:-1
 502      );
 503   }
 504   FreePool(Temp);
 505   return (RetVal);
 506 }
 507
 508 STATIC CONST UINTN VersionStringSize = 60;
 509
 510 /**
 511   Function to dump information about EfiDriverSupportedEfiVersion protocol.
 512
 513   This will allocate the return buffer from boot services pool.
 514
 515   @param[in] TheHandle      The handle that has the protocol installed.
 516   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 517
 518   @retval A poitner to a string containing the information.
 519 **/
 520 CHAR16*
 521 EFIAPI
 522 DriverEfiVersionProtocolDumpInformation(
 523   IN CONST EFI_HANDLE TheHandle,
 524   IN CONST BOOLEAN    Verbose
 525   )
 526 {
 527   EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
 528   EFI_STATUS                                Status;
 529   CHAR16                                    *RetVal;
 530
 531   Status = gBS->HandleProtocol(
 532     TheHandle,
 533     &gEfiDriverSupportedEfiVersionProtocolGuid,
 534     (VOID**)&DriverEfiVersion);
 535
 536   ASSERT_EFI_ERROR(Status);
 537
 538   RetVal = AllocateZeroPool(VersionStringSize);
 539   ASSERT(RetVal != NULL);
 540   UnicodeSPrint(RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);
 541   return (RetVal);
 542 }
 543
 544 /**
 545   Function to dump information about DevicePath protocol.
 546
 547   This will allocate the return buffer from boot services pool.
 548
 549   @param[in] TheHandle      The handle that has the protocol installed.
 550   @param[in] Verbose        TRUE for additional information, FALSE otherwise.
 551
 552   @retval A poitner to a string containing the information.
 553 **/
 554 CHAR16*
 555 EFIAPI
 556 DevicePathProtocolDumpInformation(
 557   IN CONST EFI_HANDLE TheHandle,
 558   IN CONST BOOLEAN    Verbose
 559   )
 560 {
 561   EFI_DEVICE_PATH_PROTOCOL          *DevPath;
 562   CHAR16                            *Temp;
 563   CHAR16                            *Temp2;
 564   EFI_STATUS                        Status;
 565   Temp = NULL;
 566
 567   Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 568   if (!EFI_ERROR(Status)) {
 569     //
 570     // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
 571     //
 572     Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);
 573     gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);
 574   }
 575   if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {
 576     Temp2 = NULL;
 577     Temp2 = StrnCatGrow(&Temp2, NULL, Temp+(StrLen(Temp) - 30), 30);
 578     FreePool(Temp);
 579     Temp = Temp2;
 580   }
 581   return (Temp);
 582 }
 583
 584 //
 585 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
 586 //
 587 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
 588   { \
 589     0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
 590   }
 591
 592 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
 593   { \
 594     0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
 595   }
 596
 597 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
 598   { \
 599     0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
 600   }
 601 STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;
 602 STATIC CONST EFI_GUID WinNtIoProtocolGuid    = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;
 603 STATIC CONST EFI_GUID WinNtSerialPortGuid    = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;
 604
 605 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {
 606   {STRING_TOKEN(STR_WINNT_THUNK),           (EFI_GUID*)&WinNtThunkProtocolGuid,               NULL},
 607   {STRING_TOKEN(STR_WINNT_DRIVER_IO),       (EFI_GUID*)&WinNtIoProtocolGuid,                  NULL},
 608   {STRING_TOKEN(STR_WINNT_SERIAL_PORT),     (EFI_GUID*)&WinNtSerialPortGuid,                  NULL},
 609   {STRING_TOKEN(STR_UNKNOWN_DEVICE),        NULL,                                             NULL},
 610 };
 611
 612 STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
 613   {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     LoadedImageProtocolDumpInformation},
 614   {STRING_TOKEN(STR_DEVICE_PATH),           &gEfiDevicePathProtocolGuid,                      DevicePathProtocolDumpInformation},
 615   {STRING_TOKEN(STR_IMAGE_PATH),            &gEfiLoadedImageDevicePathProtocolGuid,           DevicePathProtocolDumpInformation},
 616   {STRING_TOKEN(STR_DEVICE_PATH_UTIL),      &gEfiDevicePathUtilitiesProtocolGuid,             NULL},
 617   {STRING_TOKEN(STR_DEVICE_PATH_TXT),       &gEfiDevicePathToTextProtocolGuid,                NULL},
 618   {STRING_TOKEN(STR_DEVICE_PATH_FTXT),      &gEfiDevicePathFromTextProtocolGuid,              NULL},
 619   {STRING_TOKEN(STR_DEVICE_PATH_PC),        &gEfiPcAnsiGuid,                                  NULL},
 620   {STRING_TOKEN(STR_DEVICE_PATH_VT100),     &gEfiVT100Guid,                                   NULL},
 621   {STRING_TOKEN(STR_DEVICE_PATH_VT100P),    &gEfiVT100PlusGuid,                               NULL},
 622   {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8),    &gEfiVTUTF8Guid,                                  NULL},
 623   {STRING_TOKEN(STR_DRIVER_BINDING),        &gEfiDriverBindingProtocolGuid,                   NULL},
 624   {STRING_TOKEN(STR_PLATFORM_OVERRIDE),     &gEfiPlatformDriverOverrideProtocolGuid,          NULL},
 625   {STRING_TOKEN(STR_BUS_OVERRIDE),          &gEfiBusSpecificDriverOverrideProtocolGuid,       NULL},
 626   {STRING_TOKEN(STR_DRIVER_DIAG),           &gEfiDriverDiagnosticsProtocolGuid,               NULL},
 627   {STRING_TOKEN(STR_DRIVER_DIAG2),          &gEfiDriverDiagnostics2ProtocolGuid,              NULL},
 628   {STRING_TOKEN(STR_DRIVER_CN),             &gEfiComponentNameProtocolGuid,                   NULL},
 629   {STRING_TOKEN(STR_DRIVER_CN2),            &gEfiComponentName2ProtocolGuid,                  NULL},
 630   {STRING_TOKEN(STR_PLAT_DRV_CFG),          &gEfiPlatformToDriverConfigurationProtocolGuid,   NULL},
 631   {STRING_TOKEN(STR_DRIVER_VERSION),        &gEfiDriverSupportedEfiVersionProtocolGuid,       DriverEfiVersionProtocolDumpInformation},
 632   {STRING_TOKEN(STR_TXT_IN),                &gEfiSimpleTextInProtocolGuid,                    NULL},
 633   {STRING_TOKEN(STR_TXT_IN_EX),             &gEfiSimpleTextInputExProtocolGuid,               NULL},
 634   {STRING_TOKEN(STR_TXT_OUT),               &gEfiSimpleTextOutProtocolGuid,                   TxtOutProtocolDumpInformation},
 635   {STRING_TOKEN(STR_SIM_POINTER),           &gEfiSimplePointerProtocolGuid,                   NULL},
 636   {STRING_TOKEN(STR_ABS_POINTER),           &gEfiAbsolutePointerProtocolGuid,                 NULL},
 637   {STRING_TOKEN(STR_SERIAL_IO),             &gEfiSerialIoProtocolGuid,                        NULL},
 638   {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  GraphicsOutputProtocolDumpInformation},
 639   {STRING_TOKEN(STR_EDID_DISCOVERED),       &gEfiEdidDiscoveredProtocolGuid,                  NULL},
 640   {STRING_TOKEN(STR_EDID_ACTIVE),           &gEfiEdidActiveProtocolGuid,                      NULL},
 641   {STRING_TOKEN(STR_EDID_OVERRIDE),         &gEfiEdidOverrideProtocolGuid,                    NULL},
 642   {STRING_TOKEN(STR_CON_IN),                &gEfiConsoleInDeviceGuid,                         NULL},
 643   {STRING_TOKEN(STR_CON_OUT),               &gEfiConsoleOutDeviceGuid,                        NULL},
 644   {STRING_TOKEN(STR_STD_ERR),               &gEfiStandardErrorDeviceGuid,                     NULL},
 645   {STRING_TOKEN(STR_LOAD_FILE),             &gEfiLoadFileProtocolGuid,                        NULL},
 646   {STRING_TOKEN(STR_LOAD_FILE2),            &gEfiLoadFile2ProtocolGuid,                       NULL},
 647   {STRING_TOKEN(STR_SIMPLE_FILE_SYS),       &gEfiSimpleFileSystemProtocolGuid,                NULL},
 648   {STRING_TOKEN(STR_TAPE_IO),               &gEfiTapeIoProtocolGuid,                          NULL},
 649   {STRING_TOKEN(STR_DISK_IO),               &gEfiDiskIoProtocolGuid,                          NULL},
 650   {STRING_TOKEN(STR_BLK_IO),                &gEfiBlockIoProtocolGuid,                         NULL},
 651   {STRING_TOKEN(STR_UC),                    &gEfiUnicodeCollationProtocolGuid,                NULL},
 652   {STRING_TOKEN(STR_UC2),                   &gEfiUnicodeCollation2ProtocolGuid,               NULL},
 653   {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 PciRootBridgeIoDumpInformation},
 654   {STRING_TOKEN(STR_PCI_IO),                &gEfiPciIoProtocolGuid,                           NULL},
 655   {STRING_TOKEN(STR_SCSI_PT),               &gEfiScsiPassThruProtocolGuid,                    NULL},
 656   {STRING_TOKEN(STR_SCSI_IO),               &gEfiScsiIoProtocolGuid,                          NULL},
 657   {STRING_TOKEN(STR_SCSI_PT_EXT),           &gEfiExtScsiPassThruProtocolGuid,                 NULL},
 658   {STRING_TOKEN(STR_ISCSI),                 &gEfiIScsiInitiatorNameProtocolGuid,              NULL},
 659   {STRING_TOKEN(STR_USB_IO),                &gEfiUsbIoProtocolGuid,                           NULL},
 660   {STRING_TOKEN(STR_USB_HC),                &gEfiUsbHcProtocolGuid,                           NULL},
 661   {STRING_TOKEN(STR_USB_HC2),               &gEfiUsb2HcProtocolGuid,                          NULL},
 662   {STRING_TOKEN(STR_DEBUG_SUPPORT),         &gEfiDebugSupportProtocolGuid,                    NULL},
 663   {STRING_TOKEN(STR_DEBUG_PORT),            &gEfiDebugPortProtocolGuid,                       NULL},
 664   {STRING_TOKEN(STR_DECOMPRESS),            &gEfiDecompressProtocolGuid,                      NULL},
 665   {STRING_TOKEN(STR_ACPI_TABLE),            &gEfiAcpiTableProtocolGuid,                       NULL},
 666   {STRING_TOKEN(STR_EBC_INTERPRETER),       &gEfiEbcProtocolGuid,                             NULL},
 667   {STRING_TOKEN(STR_SNP),                   &gEfiSimpleNetworkProtocolGuid,                   NULL},
 668   {STRING_TOKEN(STR_NII),                   &gEfiNetworkInterfaceIdentifierProtocolGuid,      NULL},
 669   {STRING_TOKEN(STR_NII_31),                &gEfiNetworkInterfaceIdentifierProtocolGuid_31,   NULL},
 670   {STRING_TOKEN(STR_PXE_BC),                &gEfiPxeBaseCodeProtocolGuid,                     NULL},
 671   {STRING_TOKEN(STR_PXE_CB),                &gEfiPxeBaseCodeCallbackProtocolGuid,             NULL},
 672   {STRING_TOKEN(STR_BIS),                   &gEfiBisProtocolGuid,                             NULL},
 673   {STRING_TOKEN(STR_MNP_SB),                &gEfiManagedNetworkServiceBindingProtocolGuid,    NULL},
 674   {STRING_TOKEN(STR_MNP),                   &gEfiManagedNetworkProtocolGuid,                  NULL},
 675   {STRING_TOKEN(STR_ARP_SB),                &gEfiArpServiceBindingProtocolGuid,               NULL},
 676   {STRING_TOKEN(STR_ARP),                   &gEfiArpProtocolGuid,                             NULL},
 677   {STRING_TOKEN(STR_DHCPV4_SB),             &gEfiDhcp4ServiceBindingProtocolGuid,             NULL},
 678   {STRING_TOKEN(STR_DHCPV4),                &gEfiDhcp4ProtocolGuid,                           NULL},
 679   {STRING_TOKEN(STR_TCPV4_SB),              &gEfiTcp4ServiceBindingProtocolGuid,              NULL},
 680   {STRING_TOKEN(STR_TCPV4),                 &gEfiTcp4ProtocolGuid,                            NULL},
 681   {STRING_TOKEN(STR_IPV4_SB),               &gEfiIp4ServiceBindingProtocolGuid,               NULL},
 682   {STRING_TOKEN(STR_IPV4),                  &gEfiIp4ProtocolGuid,                             NULL},
 683   {STRING_TOKEN(STR_IPV4_CFG),              &gEfiIp4ConfigProtocolGuid,                       NULL},
 684   {STRING_TOKEN(STR_UDPV4_SB),              &gEfiUdp4ServiceBindingProtocolGuid,              NULL},
 685   {STRING_TOKEN(STR_UDPV4),                 &gEfiUdp4ProtocolGuid,                            NULL},
 686   {STRING_TOKEN(STR_MTFTPV4_SB),            &gEfiMtftp4ServiceBindingProtocolGuid,            NULL},
 687   {STRING_TOKEN(STR_MTFTPV4),               &gEfiMtftp4ProtocolGuid,                          NULL},
 688   {STRING_TOKEN(STR_AUTH_INFO),             &gEfiAuthenticationInfoProtocolGuid,              NULL},
 689   {STRING_TOKEN(STR_HASH_SB),               &gEfiHashServiceBindingProtocolGuid,              NULL},
 690   {STRING_TOKEN(STR_HASH),                  &gEfiHashProtocolGuid,                            NULL},
 691   {STRING_TOKEN(STR_HII_FONT),              &gEfiHiiFontProtocolGuid,                         NULL},
 692   {STRING_TOKEN(STR_HII_STRING),            &gEfiHiiStringProtocolGuid,                       NULL},
 693   {STRING_TOKEN(STR_HII_IMAGE),             &gEfiHiiImageProtocolGuid,                        NULL},
 694   {STRING_TOKEN(STR_HII_DATABASE),          &gEfiHiiDatabaseProtocolGuid,                     NULL},
 695   {STRING_TOKEN(STR_HII_CONFIG_ROUT),       &gEfiHiiConfigRoutingProtocolGuid,                NULL},
 696   {STRING_TOKEN(STR_HII_CONFIG_ACC),        &gEfiHiiConfigAccessProtocolGuid,                 NULL},
 697   {STRING_TOKEN(STR_HII_FORM_BROWSER2),     &gEfiFormBrowser2ProtocolGuid,                    NULL},
 698   {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE),   &gEfiDriverFamilyOverrideProtocolGuid,            NULL},
 699   {STRING_TOKEN(STR_PCD),                   &gPcdProtocolGuid,                                NULL},
 700   {STRING_TOKEN(STR_TCG),                   &gEfiTcgProtocolGuid,                             NULL},
 701   {STRING_TOKEN(STR_HII_PACKAGE_LIST),      &gEfiHiiPackageListProtocolGuid,                  NULL},
 702
 703 //
 704 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
 705 //
 706   {STRING_TOKEN(STR_SHELL_INTERFACE),       &gEfiShellInterfaceGuid,                          NULL},
 707   {STRING_TOKEN(STR_SHELL_ENV2),            &gEfiShellEnvironment2Guid,                       NULL},
 708   {STRING_TOKEN(STR_SHELL_ENV),             &gEfiShellEnvironment2Guid,                       NULL},
 709   {STRING_TOKEN(STR_DEVICE_IO),             &gEfiDeviceIoProtocolGuid,                        NULL},
 710   {STRING_TOKEN(STR_UGA_DRAW),              &gEfiUgaDrawProtocolGuid,                         NULL},
 711   {STRING_TOKEN(STR_UGA_IO),                &gEfiUgaIoProtocolGuid,                           NULL},
 712   {STRING_TOKEN(STR_ESP),                   &gEfiPartTypeSystemPartGuid,                      NULL},
 713   {STRING_TOKEN(STR_GPT_NBR),               &gEfiPartTypeLegacyMbrGuid,                       NULL},
 714   {STRING_TOKEN(STR_DRIVER_CONFIG),         &gEfiDriverConfigurationProtocolGuid,             NULL},
 715   {STRING_TOKEN(STR_DRIVER_CONFIG2),        &gEfiDriverConfiguration2ProtocolGuid,            NULL},
 716
 717 //
 718 // the ones under this are GUID identified structs, not protocols
 719 //
 720   {STRING_TOKEN(STR_FILE_INFO),             &gEfiFileInfoGuid,                                NULL},
 721   {STRING_TOKEN(STR_FILE_SYS_INFO),         &gEfiFileSystemInfoGuid,                          NULL},
 722
 723 //
 724 // the ones under this are misc GUIDS.
 725 //
 726   {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE),   &gEfiGlobalVariableGuid,                          NULL},
 727
 728 //
 729 // UEFI 2.2
 730 //
 731   {STRING_TOKEN(STR_IP6_SB),                &gEfiIp6ServiceBindingProtocolGuid,               NULL},
 732   {STRING_TOKEN(STR_IP6),                   &gEfiIp6ProtocolGuid,                             NULL},
 733   {STRING_TOKEN(STR_IP6_CONFIG),            &gEfiIp6ConfigProtocolGuid,                       NULL},
 734   {STRING_TOKEN(STR_MTFTP6_SB),             &gEfiMtftp6ServiceBindingProtocolGuid,            NULL},
 735   {STRING_TOKEN(STR_MTFTP6),                &gEfiMtftp6ProtocolGuid,                          NULL},
 736   {STRING_TOKEN(STR_DHCP6_SB),              &gEfiDhcp6ServiceBindingProtocolGuid,             NULL},
 737   {STRING_TOKEN(STR_DHCP6),                 &gEfiDhcp6ProtocolGuid,                           NULL},
 738   {STRING_TOKEN(STR_UDP6_SB),               &gEfiUdp6ServiceBindingProtocolGuid,              NULL},
 739   {STRING_TOKEN(STR_UDP6),                  &gEfiUdp6ProtocolGuid,                            NULL},
 740   {STRING_TOKEN(STR_TCP6_SB),               &gEfiTcp6ServiceBindingProtocolGuid,              NULL},
 741   {STRING_TOKEN(STR_TCP6),                  &gEfiTcp6ProtocolGuid,                            NULL},
 742   {STRING_TOKEN(STR_VLAN_CONFIG),           &gEfiVlanConfigProtocolGuid,                      NULL},
 743   {STRING_TOKEN(STR_EAP),                   &gEfiEapProtocolGuid,                             NULL},
 744   {STRING_TOKEN(STR_EAP_MGMT),              &gEfiEapManagementProtocolGuid,                   NULL},
 745   {STRING_TOKEN(STR_FTP4_SB),               &gEfiFtp4ServiceBindingProtocolGuid,              NULL},
 746   {STRING_TOKEN(STR_FTP4),                  &gEfiFtp4ProtocolGuid,                            NULL},
 747   {STRING_TOKEN(STR_IP_SEC_CONFIG),         &gEfiIpSecConfigProtocolGuid,                     NULL},
 748   {STRING_TOKEN(STR_DH),                    &gEfiDriverHealthProtocolGuid,                    NULL},
 749   {STRING_TOKEN(STR_DEF_IMG_LOAD),          &gEfiDeferredImageLoadProtocolGuid,               NULL},
 750   {STRING_TOKEN(STR_USER_CRED),             &gEfiUserCredentialProtocolGuid,                  NULL},
 751   {STRING_TOKEN(STR_USER_MNGR),             &gEfiUserManagerProtocolGuid,                     NULL},
 752   {STRING_TOKEN(STR_ATA_PASS_THRU),         &gEfiAtaPassThruProtocolGuid,                     NULL},
 753
 754 //
 755 // UEFI 2.3
 756 //
 757   {STRING_TOKEN(STR_FW_MGMT),               &gEfiFirmwareManagementProtocolGuid,              NULL},
 758   {STRING_TOKEN(STR_IP_SEC),                &gEfiIpSecProtocolGuid,                           NULL},
 759   {STRING_TOKEN(STR_IP_SEC2),               &gEfiIpSec2ProtocolGuid,                          NULL},
 760
 761 //
 762 // UEFI 2.3.1
 763 //
 764   {STRING_TOKEN(STR_KMS),                   &gEfiKmsProtocolGuid,                             NULL},
 765   {STRING_TOKEN(STR_BLK_IO2),               &gEfiBlockIo2ProtocolGuid,                        NULL},
 766   {STRING_TOKEN(STR_SSC),                   &gEfiStorageSecurityCommandProtocolGuid,          NULL},
 767   {STRING_TOKEN(STR_UCRED2),                &gEfiUserCredential2ProtocolGuid,                 NULL},
 768
 769 //
 770 // UEFI 2.4
 771 //
 772   {STRING_TOKEN(STR_DISK_IO2),              &gEfiDiskIo2ProtocolGuid,                         NULL},
 773   {STRING_TOKEN(STR_ADAPTER_INFO),          &gEfiAdapterInformationProtocolGuid,              NULL},
 774
 775 //
 776 // PI Spec ones
 777 //
 778   {STRING_TOKEN(STR_IDE_CONT_INIT),         &gEfiIdeControllerInitProtocolGuid,               NULL},
 779
 780 //
 781 // UEFI Shell Spec 2.0
 782 //
 783   {STRING_TOKEN(STR_SHELL_PARAMETERS),      &gEfiShellParametersProtocolGuid,                 NULL},
 784   {STRING_TOKEN(STR_SHELL),                 &gEfiShellProtocolGuid,                           NULL},
 785
 786 //
 787 // UEFI Shell Spec 2.1
 788 //
 789   {STRING_TOKEN(STR_SHELL_DYNAMIC),         &gEfiShellDynamicCommandProtocolGuid,             NULL},
 790
 791 //
 792 // terminator
 793 //
 794   {STRING_TOKEN(STR_UNKNOWN_DEVICE),        NULL,                                             NULL},
 795 };
 796
 797 /**
 798   Function to get the node for a protocol or struct from it's GUID.
 799
 800   if Guid is NULL, then ASSERT.
 801
 802   @param[in] Guid               The GUID to look for the name of.
 803
 804   @return                       The node.
 805 **/
 806 CONST GUID_INFO_BLOCK *
 807 EFIAPI
 808 InternalShellGetNodeFromGuid(
 809   IN CONST EFI_GUID* Guid
 810   )
 811 {
 812   CONST GUID_INFO_BLOCK *ListWalker;
 813   UINTN                 LoopCount;
 814
 815   ASSERT(Guid != NULL);
 816
 817   for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {
 818     if (CompareGuid(ListWalker->GuidId, Guid)) {
 819       return (ListWalker);
 820     }
 821   }
 822
 823   if (PcdGetBool(PcdShellIncludeNtGuids)) {
 824     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
 825       if (CompareGuid(ListWalker->GuidId, Guid)) {
 826         return (ListWalker);
 827       }
 828     }
 829   }
 830   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
 831     if (CompareGuid(ListWalker->GuidId, Guid)) {
 832       return (ListWalker);
 833     }
 834   }
 835   return (NULL);
 836 }
 837
 838 /**
 839 Function to add a new GUID/Name mapping.
 840
 841 @param[in] Guid       The Guid
 842 @param[in] NameID     The STRING id of the HII string to use
 843 @param[in] DumpFunc   The pointer to the dump function
 844
 845
 846 @retval EFI_SUCCESS           The operation was sucessful
 847 @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
 848 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
 849 **/
 850 EFI_STATUS
 851 EFIAPI
 852 InsertNewGuidNameMapping(
 853   IN CONST EFI_GUID           *Guid,
 854   IN CONST EFI_STRING_ID      NameID,
 855   IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
 856   )
 857 {
 858   ASSERT(Guid   != NULL);
 859   ASSERT(NameID != 0);
 860
 861   GuidList = ReallocatePool(GuidListCount * sizeof(GUID_INFO_BLOCK), GuidListCount+1 * sizeof(GUID_INFO_BLOCK), GuidList);
 862   if (GuidList == NULL) {
 863     GuidListCount = 0;
 864     return (EFI_OUT_OF_RESOURCES);
 865   }
 866   GuidListCount++;
 867
 868   GuidList[GuidListCount - 1].GuidId   = AllocateCopyPool(sizeof(EFI_GUID), Guid);
 869   GuidList[GuidListCount - 1].StringId = NameID;
 870   GuidList[GuidListCount - 1].DumpInfo = DumpFunc;
 871
 872   if (GuidList[GuidListCount - 1].GuidId == NULL) {
 873     return (EFI_OUT_OF_RESOURCES);
 874   }
 875
 876   return (EFI_SUCCESS);
 877 }
 878
 879 /**
 880   Function to add a new GUID/Name mapping.
 881
 882   This cannot overwrite an existing mapping.
 883
 884   @param[in] Guid       The Guid
 885   @param[in] TheName    The Guid's name
 886   @param[in] Lang       RFC4646 language code list or NULL
 887
 888   @retval EFI_SUCCESS           The operation was sucessful
 889   @retval EFI_ACCESS_DENIED     There was a duplicate
 890   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
 891   @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
 892 **/
 893 EFI_STATUS
 894 EFIAPI
 895 AddNewGuidNameMapping(
 896   IN CONST EFI_GUID *Guid,
 897   IN CONST CHAR16   *TheName,
 898   IN CONST CHAR8    *Lang OPTIONAL
 899   )
 900 {
 901   EFI_STRING_ID         NameID;
 902
 903   HandleParsingHiiInit();
 904
 905   if (Guid == NULL || TheName == NULL){
 906     return (EFI_INVALID_PARAMETER);
 907   }
 908
 909   if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {
 910     return (EFI_ACCESS_DENIED);
 911   }
 912
 913   NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);
 914   if (NameID == 0) {
 915     return (EFI_OUT_OF_RESOURCES);
 916   }
 917
 918   return (InsertNewGuidNameMapping(Guid, NameID, NULL));
 919 }
 920
 921 /**
 922   Function to get the name of a protocol or struct from it's GUID.
 923
 924   if Guid is NULL, then ASSERT.
 925
 926   @param[in] Guid               The GUID to look for the name of.
 927   @param[in] Lang               The language to use.
 928
 929   @return                       pointer to string of the name.  The caller
 930                                 is responsible to free this memory.
 931 **/
 932 CHAR16*
 933 EFIAPI
 934 GetStringNameFromGuid(
 935   IN CONST EFI_GUID *Guid,
 936   IN CONST CHAR8    *Lang OPTIONAL
 937   )
 938 {
 939   CONST GUID_INFO_BLOCK *Id;
 940
 941   HandleParsingHiiInit();
 942
 943   Id = InternalShellGetNodeFromGuid(Guid);
 944   return (HiiGetString(mHandleParsingHiiHandle, Id==NULL?STRING_TOKEN(STR_UNKNOWN_DEVICE):Id->StringId, Lang));
 945 }
 946
 947 /**
 948   Function to dump protocol information from a handle.
 949
 950   This function will return a allocated string buffer containing the
 951   information.  The caller is responsible for freeing the memory.
 952
 953   If Guid is NULL, ASSERT().
 954   If TheHandle is NULL, ASSERT().
 955
 956   @param[in] TheHandle      The handle to dump information from.
 957   @param[in] Guid           The GUID of the protocol to dump.
 958   @param[in] Verbose        TRUE for extra info.  FALSE otherwise.
 959
 960   @return                   The pointer to string.
 961   @retval NULL              An error was encountered.
 962 **/
 963 CHAR16*
 964 EFIAPI
 965 GetProtocolInformationDump(
 966   IN CONST EFI_HANDLE TheHandle,
 967   IN CONST EFI_GUID   *Guid,
 968   IN CONST BOOLEAN    Verbose
 969   )
 970 {
 971   CONST GUID_INFO_BLOCK *Id;
 972
 973   ASSERT(TheHandle  != NULL);
 974   ASSERT(Guid       != NULL);
 975
 976   if (TheHandle == NULL || Guid == NULL) {
 977     return (NULL);
 978   }
 979
 980   Id = InternalShellGetNodeFromGuid(Guid);
 981   if (Id != NULL && Id->DumpInfo != NULL) {
 982     return (Id->DumpInfo(TheHandle, Verbose));
 983   }
 984   return (NULL);
 985 }
 986
 987 /**
 988   Function to get the Guid for a protocol or struct based on it's string name.
 989
 990   do not modify the returned Guid.
 991
 992   @param[in] Name           The pointer to the string name.
 993   @param[in] Lang           The pointer to the language code.
 994   @param[out] Guid          The pointer to the Guid.
 995
 996   @retval EFI_SUCCESS       The operation was sucessful.
 997 **/
 998 EFI_STATUS
 999 EFIAPI
1000 GetGuidFromStringName(
1001   IN CONST CHAR16 *Name,
1002   IN CONST CHAR8  *Lang OPTIONAL,
1003   OUT EFI_GUID    **Guid
1004   )
1005 {
1006   CONST GUID_INFO_BLOCK  *ListWalker;
1007   CHAR16                     *String;
1008   UINTN                  LoopCount;
1009
1010   HandleParsingHiiInit();
1011
1012   ASSERT(Guid != NULL);
1013   if (Guid == NULL) {
1014     return (EFI_INVALID_PARAMETER);
1015   }
1016   *Guid = NULL;
1017
1018   if (PcdGetBool(PcdShellIncludeNtGuids)) {
1019     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
1020       String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1021       if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1022         *Guid = ListWalker->GuidId;
1023       }
1024       SHELL_FREE_NON_NULL(String);
1025       if (*Guid != NULL) {
1026         return (EFI_SUCCESS);
1027       }
1028     }
1029   }
1030   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
1031     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1032     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1033       *Guid = ListWalker->GuidId;
1034     }
1035     SHELL_FREE_NON_NULL(String);
1036     if (*Guid != NULL) {
1037       return (EFI_SUCCESS);
1038     }
1039   }
1040
1041   for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {
1042     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1043     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1044       *Guid = ListWalker->GuidId;
1045     }
1046     SHELL_FREE_NON_NULL(String);
1047     if (*Guid != NULL) {
1048       return (EFI_SUCCESS);
1049     }
1050   }
1051
1052   return (EFI_NOT_FOUND);
1053 }
1054
1055 /**
1056   Get best support language for this driver.
1057
1058   First base on the user input language  to search, second base on the current
1059   platform used language to search, third get the first language from the
1060   support language list. The caller need to free the buffer of the best language.
1061
1062   @param[in] SupportedLanguages      The support languages for this driver.
1063   @param[in] InputLanguage           The user input language.
1064   @param[in] Iso639Language          Whether get language for ISO639.
1065
1066   @return                            The best support language for this driver.
1067 **/
1068 CHAR8 *
1069 EFIAPI
1070 GetBestLanguageForDriver (
1071   IN CONST CHAR8  *SupportedLanguages,
1072   IN CONST CHAR8  *InputLanguage,
1073   IN BOOLEAN      Iso639Language
1074   )
1075 {
1076   CHAR8                         *LanguageVariable;
1077   CHAR8                         *BestLanguage;
1078
1079   LanguageVariable = GetVariable (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid);
1080
1081   BestLanguage = GetBestLanguage(
1082                    SupportedLanguages,
1083                    Iso639Language,
1084                    (InputLanguage != NULL) ? InputLanguage : "",
1085                    (LanguageVariable != NULL) ? LanguageVariable : "",
1086                    SupportedLanguages,
1087                    NULL
1088                    );
1089
1090   if (LanguageVariable != NULL) {
1091     FreePool (LanguageVariable);
1092   }
1093
1094   return BestLanguage;
1095 }
1096
1097 /**
1098   Function to retrieve the driver name (if possible) from the ComponentName or
1099   ComponentName2 protocol
1100
1101   @param[in] TheHandle      The driver handle to get the name of.
1102   @param[in] Language       The language to use.
1103
1104   @retval NULL              The name could not be found.
1105   @return                   A pointer to the string name.  Do not de-allocate the memory.
1106 **/
1107 CONST CHAR16*
1108 EFIAPI
1109 GetStringNameFromHandle(
1110   IN CONST EFI_HANDLE TheHandle,
1111   IN CONST CHAR8      *Language
1112   )
1113 {
1114   EFI_COMPONENT_NAME2_PROTOCOL  *CompNameStruct;
1115   EFI_STATUS                    Status;
1116   CHAR16                        *RetVal;
1117   CHAR8                         *BestLang;
1118
1119   BestLang = NULL;
1120
1121   Status = gBS->OpenProtocol(
1122     TheHandle,
1123     &gEfiComponentName2ProtocolGuid,
1124     (VOID**)&CompNameStruct,
1125     gImageHandle,
1126     NULL,
1127     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1128   if (!EFI_ERROR(Status)) {
1129     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
1130     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
1131     if (BestLang != NULL) {
1132       FreePool (BestLang);
1133       BestLang = NULL;
1134     }
1135     if (!EFI_ERROR(Status)) {
1136       return (RetVal);
1137     }
1138   }
1139   Status = gBS->OpenProtocol(
1140     TheHandle,
1141     &gEfiComponentNameProtocolGuid,
1142     (VOID**)&CompNameStruct,
1143     gImageHandle,
1144     NULL,
1145     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1146   if (!EFI_ERROR(Status)) {
1147     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
1148     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
1149     if (BestLang != NULL) {
1150       FreePool (BestLang);
1151     }
1152     if (!EFI_ERROR(Status)) {
1153       return (RetVal);
1154     }
1155   }
1156   return (NULL);
1157 }
1158
1159 /**
1160   Function to initialize the file global mHandleList object for use in
1161   vonverting handles to index and index to handle.
1162
1163   @retval EFI_SUCCESS     The operation was successful.
1164 **/
1165 EFI_STATUS
1166 EFIAPI
1167 InternalShellInitHandleList(
1168   VOID
1169   )
1170 {
1171   EFI_STATUS   Status;
1172   EFI_HANDLE   *HandleBuffer;
1173   UINTN        HandleCount;
1174   HANDLE_LIST  *ListWalker;
1175
1176   if (mHandleList.NextIndex != 0) {
1177     return EFI_SUCCESS;
1178   }
1179   InitializeListHead(&mHandleList.List.Link);
1180   mHandleList.NextIndex = 1;
1181   Status = gBS->LocateHandleBuffer (
1182                 AllHandles,
1183                 NULL,
1184                 NULL,
1185                 &HandleCount,
1186                 &HandleBuffer
1187                );
1188   ASSERT_EFI_ERROR(Status);
1189   if (EFI_ERROR(Status)) {
1190     return (Status);
1191   }
1192   for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){
1193     ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
1194     ASSERT(ListWalker != NULL);
1195     ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex-1];
1196     ListWalker->TheIndex  = mHandleList.NextIndex;
1197     InsertTailList(&mHandleList.List.Link,&ListWalker->Link);
1198   }
1199   FreePool(HandleBuffer);
1200   return (EFI_SUCCESS);
1201 }
1202
1203 /**
1204   Function to retrieve the human-friendly index of a given handle.  If the handle
1205   does not have a index one will be automatically assigned.  The index value is valid
1206   until the termination of the shell application.
1207
1208   @param[in] TheHandle    The handle to retrieve an index for.
1209
1210   @retval 0               A memory allocation failed.
1211   @return                 The index of the handle.
1212
1213 **/
1214 UINTN
1215 EFIAPI
1216 ConvertHandleToHandleIndex(
1217   IN CONST EFI_HANDLE TheHandle
1218   )
1219 {
1220   EFI_STATUS   Status;
1221   EFI_GUID     **ProtocolBuffer;
1222   UINTN        ProtocolCount;
1223   HANDLE_LIST  *ListWalker;
1224
1225   if (TheHandle == NULL) {
1226     return 0;
1227   }
1228
1229   InternalShellInitHandleList();
1230
1231   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
1232     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
1233     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
1234    ){
1235     if (ListWalker->TheHandle == TheHandle) {
1236       //
1237       // Verify that TheHandle is still present in the Handle Database
1238       //
1239       Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
1240       if (EFI_ERROR (Status)) {
1241         //
1242         // TheHandle is not present in the Handle Database, so delete from the handle list
1243         //
1244         RemoveEntryList (&ListWalker->Link);
1245         return 0;
1246       }
1247       FreePool (ProtocolBuffer);
1248       return (ListWalker->TheIndex);
1249     }
1250   }
1251
1252   //
1253   // Verify that TheHandle is valid handle
1254   //
1255   Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
1256   if (EFI_ERROR (Status)) {
1257     //
1258     // TheHandle is not valid, so do not add to handle list
1259     //
1260     return 0;
1261   }
1262   FreePool (ProtocolBuffer);
1263
1264   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
1265   ASSERT(ListWalker != NULL);
1266   ListWalker->TheHandle = TheHandle;
1267   ListWalker->TheIndex  = mHandleList.NextIndex++;
1268   InsertTailList(&mHandleList.List.Link,&ListWalker->Link);
1269   return (ListWalker->TheIndex);
1270 }
1271
1272
1273
1274 /**
1275   Function to retrieve the EFI_HANDLE from the human-friendly index.
1276
1277   @param[in] TheIndex     The index to retrieve the EFI_HANDLE for.
1278
1279   @retval NULL            The index was invalid.
1280   @return                 The EFI_HANDLE that index represents.
1281
1282 **/
1283 EFI_HANDLE
1284 EFIAPI
1285 ConvertHandleIndexToHandle(
1286   IN CONST UINTN TheIndex
1287   )
1288 {
1289   EFI_STATUS   Status;
1290   EFI_GUID     **ProtocolBuffer;
1291   UINTN        ProtocolCount;
1292   HANDLE_LIST *ListWalker;
1293
1294   InternalShellInitHandleList();
1295
1296   if (TheIndex >= mHandleList.NextIndex) {
1297     return NULL;
1298   }
1299
1300   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
1301     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
1302     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
1303    ){
1304     if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {
1305       //
1306       // Verify that LinkWalker->TheHandle is valid handle
1307       //
1308       Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);
1309       if (EFI_ERROR (Status)) {
1310         //
1311         // TheHandle is not valid, so do not add to handle list
1312         //
1313         ListWalker->TheHandle = NULL;
1314       }
1315       return (ListWalker->TheHandle);
1316     }
1317   }
1318   return NULL;
1319 }
1320
1321 /**
1322   Gets all the related EFI_HANDLEs based on the mask supplied.
1323
1324   This function scans all EFI_HANDLES in the UEFI environment's handle database
1325   and returns the ones with the specified relationship (Mask) to the specified
1326   controller handle.
1327
1328   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1329   If MatchingHandleCount is NULL, then ASSERT.
1330
1331   If MatchingHandleBuffer is not NULL upon a successful return the memory must be
1332   caller freed.
1333
1334   @param[in] DriverBindingHandle    The handle with Driver Binding protocol on it.
1335   @param[in] ControllerHandle       The handle with Device Path protocol on it.
1336   @param[in] MatchingHandleCount    The pointer to UINTN that specifies the number of HANDLES in
1337                                     MatchingHandleBuffer.
1338   @param[out] MatchingHandleBuffer  On a successful return, a buffer of MatchingHandleCount
1339                                     EFI_HANDLEs with a terminating NULL EFI_HANDLE.
1340   @param[out] HandleType            An array of type information.
1341
1342   @retval EFI_SUCCESS               The operation was successful, and any related handles
1343                                     are in MatchingHandleBuffer.
1344   @retval EFI_NOT_FOUND             No matching handles were found.
1345   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
1346 **/
1347 EFI_STATUS
1348 EFIAPI
1349 ParseHandleDatabaseByRelationshipWithType (
1350   IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,
1351   IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
1352   IN UINTN            *HandleCount,
1353   OUT EFI_HANDLE      **HandleBuffer,
1354   OUT UINTN           **HandleType
1355   )
1356 {
1357   EFI_STATUS                          Status;
1358   UINTN                               HandleIndex;
1359   EFI_GUID                            **ProtocolGuidArray;
1360   UINTN                               ArrayCount;
1361   UINTN                               ProtocolIndex;
1362   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
1363   UINTN                               OpenInfoCount;
1364   UINTN                               OpenInfoIndex;
1365   UINTN                               ChildIndex;
1366   INTN                                DriverBindingHandleIndex;
1367
1368   ASSERT(HandleCount  != NULL);
1369   ASSERT(HandleBuffer != NULL);
1370   ASSERT(HandleType   != NULL);
1371   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
1372
1373   *HandleCount                  = 0;
1374   *HandleBuffer                 = NULL;
1375   *HandleType                   = NULL;
1376
1377   //
1378   // Retrieve the list of all handles from the handle database
1379   //
1380   Status = gBS->LocateHandleBuffer (
1381                 AllHandles,
1382                 NULL,
1383                 NULL,
1384                 HandleCount,
1385                 HandleBuffer
1386                );
1387   if (EFI_ERROR (Status)) {
1388     return (Status);
1389   }
1390
1391   *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));
1392   ASSERT(*HandleType != NULL);
1393
1394   DriverBindingHandleIndex = -1;
1395   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
1396     if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {
1397       DriverBindingHandleIndex = (INTN)HandleIndex;
1398     }
1399   }
1400
1401   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
1402     //
1403     // Retrieve the list of all the protocols on each handle
1404     //
1405     Status = gBS->ProtocolsPerHandle (
1406                   (*HandleBuffer)[HandleIndex],
1407                   &ProtocolGuidArray,
1408                   &ArrayCount
1409                  );
1410     if (EFI_ERROR (Status)) {
1411       continue;
1412     }
1413
1414     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
1415
1416       //
1417       // Set the bit describing what this handle has
1418       //
1419       if        (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)         ) {
1420         (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;
1421       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)       ) {
1422         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;
1423       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
1424         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
1425       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {
1426         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
1427       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)  ) {
1428         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
1429       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)   ) {
1430         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
1431       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)      ) {
1432         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
1433       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)       ) {
1434         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
1435       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {
1436         (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;
1437       } else {
1438         DEBUG_CODE_BEGIN();
1439         ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);
1440         DEBUG_CODE_END();
1441       }
1442       //
1443       // Retrieve the list of agents that have opened each protocol
1444       //
1445       Status = gBS->OpenProtocolInformation (
1446                       (*HandleBuffer)[HandleIndex],
1447                       ProtocolGuidArray[ProtocolIndex],
1448                       &OpenInfo,
1449                       &OpenInfoCount
1450                      );
1451       if (EFI_ERROR (Status)) {
1452         continue;
1453       }
1454
1455       if (ControllerHandle == NULL) {
1456         //
1457         // ControllerHandle == NULL and DriverBindingHandle != NULL.
1458         // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
1459         //
1460         for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1461           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1462             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1463             if (DriverBindingHandleIndex != -1) {
1464               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
1465             }
1466           }
1467           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1468             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1469             if (DriverBindingHandleIndex != -1) {
1470               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1471             }
1472             for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1473               if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1474                 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1475               }
1476             }
1477           }
1478         }
1479       }
1480       if (DriverBindingHandle == NULL && ControllerHandle != NULL) {
1481         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
1482           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1483           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1484             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1485               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1486                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1487                   (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;
1488                 }
1489               }
1490             }
1491             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1492               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1493                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1494                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1495                 }
1496                 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1497                   (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1498                 }
1499               }
1500             }
1501           }
1502         } else {
1503           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1504             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1505               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
1506                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
1507               }
1508             }
1509           }
1510         }
1511       }
1512       if (DriverBindingHandle != NULL && ControllerHandle != NULL) {
1513         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
1514           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1515           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1516             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1517               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
1518                 if (DriverBindingHandleIndex != -1) {
1519                   (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
1520                 }
1521               }
1522             }
1523             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1524               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
1525                 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1526                   if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1527                     (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1528                   }
1529                 }
1530               }
1531
1532               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1533                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1534                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1535                 }
1536               }
1537             }
1538           }
1539         } else {
1540           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1541             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1542               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
1543                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
1544               }
1545             }
1546           }
1547         }
1548       }
1549       FreePool (OpenInfo);
1550     }
1551     FreePool (ProtocolGuidArray);
1552   }
1553   return EFI_SUCCESS;
1554 }
1555
1556 /**
1557   Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
1558   supplied.
1559
1560   This function will scan all EFI_HANDLES in the UEFI environment's handle database
1561   and return all the ones with the specified relationship (Mask) to the specified
1562   controller handle.
1563
1564   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1565   If MatchingHandleCount is NULL, then ASSERT.
1566
1567   If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
1568   caller freed.
1569
1570   @param[in] DriverBindingHandle    Handle to a object with Driver Binding protocol
1571                                     on it.
1572   @param[in] ControllerHandle       Handle to a device with Device Path protocol on it.
1573   @param[in] Mask                   Mask of what relationship(s) is desired.
1574   @param[in] MatchingHandleCount    Poitner to UINTN specifying number of HANDLES in
1575                                     MatchingHandleBuffer.
1576   @param[out] MatchingHandleBuffer  On a sucessful return a buffer of MatchingHandleCount
1577                                     EFI_HANDLEs and a terminating NULL EFI_HANDLE.
1578
1579   @retval EFI_SUCCESS               The operation was sucessful and any related handles
1580                                     are in MatchingHandleBuffer;
1581   @retval EFI_NOT_FOUND             No matching handles were found.
1582   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
1583 **/
1584 EFI_STATUS
1585 EFIAPI
1586 ParseHandleDatabaseByRelationship (
1587   IN CONST EFI_HANDLE       DriverBindingHandle OPTIONAL,
1588   IN CONST EFI_HANDLE       ControllerHandle OPTIONAL,
1589   IN CONST UINTN            Mask,
1590   IN UINTN                  *MatchingHandleCount,
1591   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1592   )
1593 {
1594   EFI_STATUS            Status;
1595   UINTN                 HandleCount;
1596   EFI_HANDLE            *HandleBuffer;
1597   UINTN                 *HandleType;
1598   UINTN                 HandleIndex;
1599
1600   ASSERT(MatchingHandleCount != NULL);
1601   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
1602
1603   if ((Mask & HR_VALID_MASK) != Mask) {
1604     return (EFI_INVALID_PARAMETER);
1605   }
1606
1607   if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {
1608     return (EFI_INVALID_PARAMETER);
1609   }
1610
1611   *MatchingHandleCount = 0;
1612   if (MatchingHandleBuffer != NULL) {
1613     *MatchingHandleBuffer = NULL;
1614   }
1615
1616   HandleBuffer  = NULL;
1617   HandleType    = NULL;
1618
1619   Status = ParseHandleDatabaseByRelationshipWithType (
1620             DriverBindingHandle,
1621             ControllerHandle,
1622             &HandleCount,
1623             &HandleBuffer,
1624             &HandleType
1625            );
1626   if (!EFI_ERROR (Status)) {
1627     //
1628     // Count the number of handles that match the attributes in Mask
1629     //
1630     for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
1631       if ((HandleType[HandleIndex] & Mask) == Mask) {
1632         (*MatchingHandleCount)++;
1633       }
1634     }
1635     //
1636     // If no handles match the attributes in Mask then return EFI_NOT_FOUND
1637     //
1638     if (*MatchingHandleCount == 0) {
1639       Status = EFI_NOT_FOUND;
1640     } else {
1641
1642       if (MatchingHandleBuffer == NULL) {
1643         //
1644         // Someone just wanted the count...
1645         //
1646         Status = EFI_SUCCESS;
1647       } else {
1648         //
1649         // Allocate a handle buffer for the number of handles that matched the attributes in Mask
1650         //
1651         *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));
1652         ASSERT(*MatchingHandleBuffer != NULL);
1653
1654         for (HandleIndex = 0,*MatchingHandleCount = 0
1655           ;  HandleIndex < HandleCount
1656           ;  HandleIndex++
1657          ){
1658           //
1659           // Fill the allocated buffer with the handles that matched the attributes in Mask
1660           //
1661           if ((HandleType[HandleIndex] & Mask) == Mask) {
1662             (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];
1663           }
1664         }
1665
1666         //
1667         // Make the last one NULL
1668         //
1669         (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;
1670
1671         Status = EFI_SUCCESS;
1672       } // MacthingHandleBuffer == NULL (ELSE)
1673     } // *MatchingHandleCount  == 0 (ELSE)
1674   } // no error on ParseHandleDatabaseByRelationshipWithType
1675
1676   if (HandleBuffer != NULL) {
1677     FreePool (HandleBuffer);
1678   }
1679
1680   if (HandleType != NULL) {
1681     FreePool (HandleType);
1682   }
1683
1684   return Status;
1685 }
1686
1687 /**
1688   Gets handles for any child controllers of the passed in controller.
1689
1690   @param[in] ControllerHandle       The handle of the "parent controller"
1691   @param[in] MatchingHandleCount    Pointer to the number of handles in
1692                                     MatchingHandleBuffer on return.
1693   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
1694                                     return.
1695
1696
1697   @retval EFI_SUCCESS               The operation was sucessful.
1698 **/
1699 EFI_STATUS
1700 EFIAPI
1701 ParseHandleDatabaseForChildControllers(
1702   IN CONST EFI_HANDLE       ControllerHandle,
1703   IN UINTN                  *MatchingHandleCount,
1704   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1705   )
1706 {
1707   EFI_STATUS  Status;
1708   UINTN       HandleIndex;
1709   UINTN       DriverBindingHandleCount;
1710   EFI_HANDLE  *DriverBindingHandleBuffer;
1711   UINTN       DriverBindingHandleIndex;
1712   UINTN       ChildControllerHandleCount;
1713   EFI_HANDLE  *ChildControllerHandleBuffer;
1714   UINTN       ChildControllerHandleIndex;
1715   EFI_HANDLE  *HandleBufferForReturn;
1716
1717   if (MatchingHandleCount == NULL) {
1718     return (EFI_INVALID_PARAMETER);
1719   }
1720   *MatchingHandleCount = 0;
1721
1722   Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
1723             ControllerHandle,
1724             &DriverBindingHandleCount,
1725             &DriverBindingHandleBuffer
1726            );
1727   if (EFI_ERROR (Status)) {
1728     return Status;
1729   }
1730
1731   //
1732   // Get a buffer big enough for all the controllers.
1733   //
1734   HandleBufferForReturn = GetHandleListByProtocol(NULL);
1735   if (HandleBufferForReturn == NULL) {
1736     FreePool (DriverBindingHandleBuffer);
1737     return (EFI_NOT_FOUND);
1738   }
1739
1740   for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {
1741     Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1742               DriverBindingHandleBuffer[DriverBindingHandleIndex],
1743               ControllerHandle,
1744               &ChildControllerHandleCount,
1745               &ChildControllerHandleBuffer
1746              );
1747     if (EFI_ERROR (Status)) {
1748       continue;
1749     }
1750
1751     for (ChildControllerHandleIndex = 0;
1752          ChildControllerHandleIndex < ChildControllerHandleCount;
1753          ChildControllerHandleIndex++
1754        ) {
1755       for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {
1756         if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
1757           break;
1758         }
1759       }
1760       if (HandleIndex >= *MatchingHandleCount) {
1761         HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
1762       }
1763     }
1764
1765     FreePool (ChildControllerHandleBuffer);
1766   }
1767
1768   FreePool (DriverBindingHandleBuffer);
1769
1770   if (MatchingHandleBuffer != NULL) {
1771     *MatchingHandleBuffer = HandleBufferForReturn;
1772   } else {
1773     FreePool(HandleBufferForReturn);
1774   }
1775
1776   return (EFI_SUCCESS);
1777 }
1778
1779 /**
1780   Appends 1 buffer to another buffer.  This will re-allocate the destination buffer
1781   if necessary to fit all of the data.
1782
1783   If DestinationBuffer is NULL, then ASSERT().
1784
1785   @param[in, out]  DestinationBuffer The pointer to the pointer to the buffer to append onto.
1786   @param[in, out]  DestinationSize   The pointer to the size of DestinationBuffer.
1787   @param[in]       SourceBuffer      The pointer to the buffer to append onto DestinationBuffer.
1788   @param[in]       SourceSize        The number of bytes of SourceBuffer to append.
1789
1790   @retval NULL                      A memory allocation failed.
1791   @retval NULL                      A parameter was invalid.
1792   @return                           A pointer to (*DestinationBuffer).
1793 **/
1794 VOID*
1795 EFIAPI
1796 BuffernCatGrow (
1797   IN OUT VOID   **DestinationBuffer,
1798   IN OUT UINTN  *DestinationSize,
1799   IN     VOID   *SourceBuffer,
1800   IN     UINTN  SourceSize
1801   )
1802 {
1803   UINTN LocalDestinationSize;
1804   UINTN LocalDestinationFinalSize;
1805
1806   ASSERT(DestinationBuffer != NULL);
1807
1808   if (SourceSize == 0 || SourceBuffer == NULL) {
1809     return (*DestinationBuffer);
1810   }
1811
1812   if (DestinationSize == NULL) {
1813     LocalDestinationSize = 0;
1814   } else {
1815     LocalDestinationSize = *DestinationSize;
1816   }
1817
1818   LocalDestinationFinalSize = LocalDestinationSize + SourceSize;
1819
1820   if (DestinationSize != NULL) {
1821     *DestinationSize = LocalDestinationSize;
1822   }
1823
1824   if (LocalDestinationSize == 0) {
1825     // allcoate
1826     *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);
1827   } else {
1828     // reallocate
1829     *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);
1830   }
1831
1832   ASSERT(*DestinationBuffer != NULL);
1833
1834   // copy
1835   return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));
1836 }
1837
1838 /**
1839   Gets handles for any child devices produced by the passed in driver.
1840
1841   @param[in] DriverHandle           The handle of the driver.
1842   @param[in] MatchingHandleCount    Pointer to the number of handles in
1843                                     MatchingHandleBuffer on return.
1844   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
1845                                     return.
1846   @retval EFI_SUCCESS               The operation was sucessful.
1847   @sa ParseHandleDatabaseByRelationship
1848 **/
1849 EFI_STATUS
1850 EFIAPI
1851 ParseHandleDatabaseForChildDevices(
1852   IN CONST EFI_HANDLE       DriverHandle,
1853   IN UINTN                  *MatchingHandleCount,
1854   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1855   )
1856 {
1857   EFI_HANDLE      *Buffer;
1858   EFI_HANDLE      *Buffer2;
1859   UINTN           Count1;
1860   UINTN           Count2;
1861   UINTN           HandleIndex;
1862   EFI_STATUS      Status;
1863   UINTN           HandleBufferSize;
1864
1865   ASSERT(MatchingHandleCount != NULL);
1866
1867   HandleBufferSize      = 0;
1868   Buffer                = NULL;
1869   Buffer2               = NULL;
1870   *MatchingHandleCount  = 0;
1871
1872   Status = PARSE_HANDLE_DATABASE_DEVICES (
1873             DriverHandle,
1874             &Count1,
1875             &Buffer
1876            );
1877   if (!EFI_ERROR (Status)) {
1878     for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {
1879       //
1880       // now find the children
1881       //
1882       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1883                 DriverHandle,
1884                 Buffer[HandleIndex],
1885                 &Count2,
1886                 &Buffer2
1887                );
1888       if (EFI_ERROR(Status)) {
1889         break;
1890       }
1891       //
1892       // save out required and optional data elements
1893       //
1894       *MatchingHandleCount += Count2;
1895       if (MatchingHandleBuffer != NULL) {
1896         *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));
1897       }
1898
1899       //
1900       // free the memory
1901       //
1902       if (Buffer2 != NULL) {
1903         FreePool(Buffer2);
1904       }
1905     }
1906   }
1907
1908   if (Buffer != NULL) {
1909     FreePool(Buffer);
1910   }
1911   return (Status);
1912 }
1913
1914 /**
1915   Function to get all handles that support a given protocol or all handles.
1916
1917   @param[in] ProtocolGuid The guid of the protocol to get handles for.  If NULL
1918                           then the function will return all handles.
1919
1920   @retval NULL            A memory allocation failed.
1921   @return                 A NULL terminated list of handles.
1922 **/
1923 EFI_HANDLE*
1924 EFIAPI
1925 GetHandleListByProtocol (
1926   IN CONST EFI_GUID *ProtocolGuid OPTIONAL
1927   )
1928 {
1929   EFI_HANDLE          *HandleList;
1930   UINTN               Size;
1931   EFI_STATUS          Status;
1932
1933   Size = 0;
1934   HandleList = NULL;
1935
1936   //
1937   // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
1938   //
1939   if (ProtocolGuid == NULL) {
1940     Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
1941     if (Status == EFI_BUFFER_TOO_SMALL) {
1942       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
1943       if (HandleList == NULL) {
1944         return (NULL);
1945       }
1946       Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
1947       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
1948     }
1949   } else {
1950     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
1951     if (Status == EFI_BUFFER_TOO_SMALL) {
1952       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
1953       if (HandleList == NULL) {
1954         return (NULL);
1955       }
1956       Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
1957       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
1958     }
1959   }
1960   if (EFI_ERROR(Status)) {
1961     if (HandleList != NULL) {
1962       FreePool(HandleList);
1963     }
1964     return (NULL);
1965   }
1966   return (HandleList);
1967 }
1968
1969 /**
1970   Function to get all handles that support some protocols.
1971
1972   @param[in] ProtocolGuids  A NULL terminated list of protocol GUIDs.
1973
1974   @retval NULL              A memory allocation failed.
1975   @retval NULL              ProtocolGuids was NULL.
1976   @return                   A NULL terminated list of EFI_HANDLEs.
1977 **/
1978 EFI_HANDLE*
1979 EFIAPI
1980 GetHandleListByProtocolList (
1981   IN CONST EFI_GUID **ProtocolGuids
1982   )
1983 {
1984   EFI_HANDLE          *HandleList;
1985   UINTN               Size;
1986   UINTN               TotalSize;
1987   UINTN               TempSize;
1988   EFI_STATUS          Status;
1989   CONST EFI_GUID      **GuidWalker;
1990   EFI_HANDLE          *HandleWalker1;
1991   EFI_HANDLE          *HandleWalker2;
1992
1993   Size        = 0;
1994   HandleList  = NULL;
1995   TotalSize   = sizeof(EFI_HANDLE);
1996
1997   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){
1998     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);
1999     if (Status == EFI_BUFFER_TOO_SMALL) {
2000       TotalSize += Size;
2001     }
2002   }
2003
2004   //
2005   // No handles were found...
2006   //
2007   if (TotalSize == sizeof(EFI_HANDLE)) {
2008     return (NULL);
2009   }
2010
2011   HandleList = AllocateZeroPool(TotalSize);
2012   if (HandleList == NULL) {
2013     return (NULL);
2014   }
2015
2016   Size = 0;
2017   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){
2018     TempSize = TotalSize - Size;
2019     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));
2020
2021     //
2022     // Allow for missing protocols... Only update the 'used' size upon success.
2023     //
2024     if (!EFI_ERROR(Status)) {
2025       Size += TempSize;
2026     }
2027   }
2028   ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);
2029
2030   for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {
2031     for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {
2032       if (*HandleWalker1 == *HandleWalker2) {
2033         //
2034         // copy memory back 1 handle width.
2035         //
2036         CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));
2037       }
2038     }
2039   }
2040
2041   return (HandleList);
2042 }
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052