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   CONST GUID_INFO_BLOCK *Temp;
 902   EFI_STRING_ID         NameID;
 903
 904   HandleParsingHiiInit();
 905
 906   if (Guid == NULL || TheName == NULL){
 907     return (EFI_INVALID_PARAMETER);
 908   }
 909
 910   if ((Temp = InternalShellGetNodeFromGuid(Guid)) != NULL) {
 911     return (EFI_ACCESS_DENIED);
 912   }
 913
 914   NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);
 915   if (NameID == 0) {
 916     return (EFI_OUT_OF_RESOURCES);
 917   }
 918
 919   return (InsertNewGuidNameMapping(Guid, NameID, NULL));
 920 }
 921
 922 /**
 923   Function to get the name of a protocol or struct from it's GUID.
 924
 925   if Guid is NULL, then ASSERT.
 926
 927   @param[in] Guid               The GUID to look for the name of.
 928   @param[in] Lang               The language to use.
 929
 930   @return                       pointer to string of the name.  The caller
 931                                 is responsible to free this memory.
 932 **/
 933 CHAR16*
 934 EFIAPI
 935 GetStringNameFromGuid(
 936   IN CONST EFI_GUID *Guid,
 937   IN CONST CHAR8    *Lang OPTIONAL
 938   )
 939 {
 940   CONST GUID_INFO_BLOCK *Id;
 941
 942   HandleParsingHiiInit();
 943
 944   Id = InternalShellGetNodeFromGuid(Guid);
 945   return (HiiGetString(mHandleParsingHiiHandle, Id==NULL?STRING_TOKEN(STR_UNKNOWN_DEVICE):Id->StringId, Lang));
 946 }
 947
 948 /**
 949   Function to dump protocol information from a handle.
 950
 951   This function will return a allocated string buffer containing the
 952   information.  The caller is responsible for freeing the memory.
 953
 954   If Guid is NULL, ASSERT().
 955   If TheHandle is NULL, ASSERT().
 956
 957   @param[in] TheHandle      The handle to dump information from.
 958   @param[in] Guid           The GUID of the protocol to dump.
 959   @param[in] Verbose        TRUE for extra info.  FALSE otherwise.
 960
 961   @return                   The pointer to string.
 962   @retval NULL              An error was encountered.
 963 **/
 964 CHAR16*
 965 EFIAPI
 966 GetProtocolInformationDump(
 967   IN CONST EFI_HANDLE TheHandle,
 968   IN CONST EFI_GUID   *Guid,
 969   IN CONST BOOLEAN    Verbose
 970   )
 971 {
 972   CONST GUID_INFO_BLOCK *Id;
 973
 974   ASSERT(TheHandle  != NULL);
 975   ASSERT(Guid       != NULL);
 976
 977   if (TheHandle == NULL || Guid == NULL) {
 978     return (NULL);
 979   }
 980
 981   Id = InternalShellGetNodeFromGuid(Guid);
 982   if (Id != NULL && Id->DumpInfo != NULL) {
 983     return (Id->DumpInfo(TheHandle, Verbose));
 984   }
 985   return (NULL);
 986 }
 987
 988 /**
 989   Function to get the Guid for a protocol or struct based on it's string name.
 990
 991   do not modify the returned Guid.
 992
 993   @param[in] Name           The pointer to the string name.
 994   @param[in] Lang           The pointer to the language code.
 995   @param[out] Guid          The pointer to the Guid.
 996
 997   @retval EFI_SUCCESS       The operation was sucessful.
 998 **/
 999 EFI_STATUS
1000 EFIAPI
1001 GetGuidFromStringName(
1002   IN CONST CHAR16 *Name,
1003   IN CONST CHAR8  *Lang OPTIONAL,
1004   OUT EFI_GUID    **Guid
1005   )
1006 {
1007   CONST GUID_INFO_BLOCK  *ListWalker;
1008   CHAR16                     *String;
1009   UINTN                  LoopCount;
1010
1011   HandleParsingHiiInit();
1012
1013   ASSERT(Guid != NULL);
1014   if (Guid == NULL) {
1015     return (EFI_INVALID_PARAMETER);
1016   }
1017   *Guid = NULL;
1018
1019   if (PcdGetBool(PcdShellIncludeNtGuids)) {
1020     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
1021       String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1022       if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1023         *Guid = ListWalker->GuidId;
1024       }
1025       SHELL_FREE_NON_NULL(String);
1026       if (*Guid != NULL) {
1027         return (EFI_SUCCESS);
1028       }
1029     }
1030   }
1031   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
1032     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1033     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1034       *Guid = ListWalker->GuidId;
1035     }
1036     SHELL_FREE_NON_NULL(String);
1037     if (*Guid != NULL) {
1038       return (EFI_SUCCESS);
1039     }
1040   }
1041
1042   for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {
1043     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
1044     if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
1045       *Guid = ListWalker->GuidId;
1046     }
1047     SHELL_FREE_NON_NULL(String);
1048     if (*Guid != NULL) {
1049       return (EFI_SUCCESS);
1050     }
1051   }
1052
1053   return (EFI_NOT_FOUND);
1054 }
1055
1056 /**
1057   Get best support language for this driver.
1058
1059   First base on the user input language  to search, second base on the current
1060   platform used language to search, third get the first language from the
1061   support language list. The caller need to free the buffer of the best language.
1062
1063   @param[in] SupportedLanguages      The support languages for this driver.
1064   @param[in] InputLanguage           The user input language.
1065   @param[in] Iso639Language          Whether get language for ISO639.
1066
1067   @return                            The best support language for this driver.
1068 **/
1069 CHAR8 *
1070 EFIAPI
1071 GetBestLanguageForDriver (
1072   IN CONST CHAR8  *SupportedLanguages,
1073   IN CONST CHAR8  *InputLanguage,
1074   IN BOOLEAN      Iso639Language
1075   )
1076 {
1077   CHAR8                         *LanguageVariable;
1078   CHAR8                         *BestLanguage;
1079
1080   LanguageVariable = GetVariable (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid);
1081
1082   BestLanguage = GetBestLanguage(
1083                    SupportedLanguages,
1084                    Iso639Language,
1085                    (InputLanguage != NULL) ? InputLanguage : "",
1086                    (LanguageVariable != NULL) ? LanguageVariable : "",
1087                    SupportedLanguages,
1088                    NULL
1089                    );
1090
1091   if (LanguageVariable != NULL) {
1092     FreePool (LanguageVariable);
1093   }
1094
1095   return BestLanguage;
1096 }
1097
1098 /**
1099   Function to retrieve the driver name (if possible) from the ComponentName or
1100   ComponentName2 protocol
1101
1102   @param[in] TheHandle      The driver handle to get the name of.
1103   @param[in] Language       The language to use.
1104
1105   @retval NULL              The name could not be found.
1106   @return                   A pointer to the string name.  Do not de-allocate the memory.
1107 **/
1108 CONST CHAR16*
1109 EFIAPI
1110 GetStringNameFromHandle(
1111   IN CONST EFI_HANDLE TheHandle,
1112   IN CONST CHAR8      *Language
1113   )
1114 {
1115   EFI_COMPONENT_NAME2_PROTOCOL  *CompNameStruct;
1116   EFI_STATUS                    Status;
1117   CHAR16                        *RetVal;
1118   CHAR8                         *BestLang;
1119
1120   BestLang = NULL;
1121
1122   Status = gBS->OpenProtocol(
1123     TheHandle,
1124     &gEfiComponentName2ProtocolGuid,
1125     (VOID**)&CompNameStruct,
1126     gImageHandle,
1127     NULL,
1128     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1129   if (!EFI_ERROR(Status)) {
1130     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
1131     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
1132     if (BestLang != NULL) {
1133       FreePool (BestLang);
1134       BestLang = NULL;
1135     }
1136     if (!EFI_ERROR(Status)) {
1137       return (RetVal);
1138     }
1139   }
1140   Status = gBS->OpenProtocol(
1141     TheHandle,
1142     &gEfiComponentNameProtocolGuid,
1143     (VOID**)&CompNameStruct,
1144     gImageHandle,
1145     NULL,
1146     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1147   if (!EFI_ERROR(Status)) {
1148     BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
1149     Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
1150     if (BestLang != NULL) {
1151       FreePool (BestLang);
1152     }
1153     if (!EFI_ERROR(Status)) {
1154       return (RetVal);
1155     }
1156   }
1157   return (NULL);
1158 }
1159
1160 /**
1161   Function to initialize the file global mHandleList object for use in
1162   vonverting handles to index and index to handle.
1163
1164   @retval EFI_SUCCESS     The operation was successful.
1165 **/
1166 EFI_STATUS
1167 EFIAPI
1168 InternalShellInitHandleList(
1169   VOID
1170   )
1171 {
1172   EFI_STATUS   Status;
1173   EFI_HANDLE   *HandleBuffer;
1174   UINTN        HandleCount;
1175   HANDLE_LIST  *ListWalker;
1176
1177   if (mHandleList.NextIndex != 0) {
1178     return EFI_SUCCESS;
1179   }
1180   InitializeListHead(&mHandleList.List.Link);
1181   mHandleList.NextIndex = 1;
1182   Status = gBS->LocateHandleBuffer (
1183                 AllHandles,
1184                 NULL,
1185                 NULL,
1186                 &HandleCount,
1187                 &HandleBuffer
1188                );
1189   ASSERT_EFI_ERROR(Status);
1190   if (EFI_ERROR(Status)) {
1191     return (Status);
1192   }
1193   for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){
1194     ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
1195     ASSERT(ListWalker != NULL);
1196     ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex-1];
1197     ListWalker->TheIndex  = mHandleList.NextIndex;
1198     InsertTailList(&mHandleList.List.Link,&ListWalker->Link);
1199   }
1200   FreePool(HandleBuffer);
1201   return (EFI_SUCCESS);
1202 }
1203
1204 /**
1205   Function to retrieve the human-friendly index of a given handle.  If the handle
1206   does not have a index one will be automatically assigned.  The index value is valid
1207   until the termination of the shell application.
1208
1209   @param[in] TheHandle    The handle to retrieve an index for.
1210
1211   @retval 0               A memory allocation failed.
1212   @return                 The index of the handle.
1213
1214 **/
1215 UINTN
1216 EFIAPI
1217 ConvertHandleToHandleIndex(
1218   IN CONST EFI_HANDLE TheHandle
1219   )
1220 {
1221   EFI_STATUS   Status;
1222   EFI_GUID     **ProtocolBuffer;
1223   UINTN        ProtocolCount;
1224   HANDLE_LIST  *ListWalker;
1225
1226   if (TheHandle == NULL) {
1227     return 0;
1228   }
1229
1230   InternalShellInitHandleList();
1231
1232   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
1233     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
1234     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
1235    ){
1236     if (ListWalker->TheHandle == TheHandle) {
1237       //
1238       // Verify that TheHandle is still present in the Handle Database
1239       //
1240       Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
1241       if (EFI_ERROR (Status)) {
1242         //
1243         // TheHandle is not present in the Handle Database, so delete from the handle list
1244         //
1245         RemoveEntryList (&ListWalker->Link);
1246         return 0;
1247       }
1248       FreePool (ProtocolBuffer);
1249       return (ListWalker->TheIndex);
1250     }
1251   }
1252
1253   //
1254   // Verify that TheHandle is valid handle
1255   //
1256   Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
1257   if (EFI_ERROR (Status)) {
1258     //
1259     // TheHandle is not valid, so do not add to handle list
1260     //
1261     return 0;
1262   }
1263   FreePool (ProtocolBuffer);
1264
1265   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
1266   ASSERT(ListWalker != NULL);
1267   ListWalker->TheHandle = TheHandle;
1268   ListWalker->TheIndex  = mHandleList.NextIndex++;
1269   InsertTailList(&mHandleList.List.Link,&ListWalker->Link);
1270   return (ListWalker->TheIndex);
1271 }
1272
1273
1274
1275 /**
1276   Function to retrieve the EFI_HANDLE from the human-friendly index.
1277
1278   @param[in] TheIndex     The index to retrieve the EFI_HANDLE for.
1279
1280   @retval NULL            The index was invalid.
1281   @return                 The EFI_HANDLE that index represents.
1282
1283 **/
1284 EFI_HANDLE
1285 EFIAPI
1286 ConvertHandleIndexToHandle(
1287   IN CONST UINTN TheIndex
1288   )
1289 {
1290   EFI_STATUS   Status;
1291   EFI_GUID     **ProtocolBuffer;
1292   UINTN        ProtocolCount;
1293   HANDLE_LIST *ListWalker;
1294
1295   InternalShellInitHandleList();
1296
1297   if (TheIndex >= mHandleList.NextIndex) {
1298     return NULL;
1299   }
1300
1301   for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)
1302     ;  !IsNull(&mHandleList.List.Link,&ListWalker->Link)
1303     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
1304    ){
1305     if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {
1306       //
1307       // Verify that LinkWalker->TheHandle is valid handle
1308       //
1309       Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);
1310       if (EFI_ERROR (Status)) {
1311         //
1312         // TheHandle is not valid, so do not add to handle list
1313         //
1314         ListWalker->TheHandle = NULL;
1315       }
1316       return (ListWalker->TheHandle);
1317     }
1318   }
1319   return NULL;
1320 }
1321
1322 /**
1323   Gets all the related EFI_HANDLEs based on the mask supplied.
1324
1325   This function scans all EFI_HANDLES in the UEFI environment's handle database
1326   and returns the ones with the specified relationship (Mask) to the specified
1327   controller handle.
1328
1329   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1330   If MatchingHandleCount is NULL, then ASSERT.
1331
1332   If MatchingHandleBuffer is not NULL upon a successful return the memory must be
1333   caller freed.
1334
1335   @param[in] DriverBindingHandle    The handle with Driver Binding protocol on it.
1336   @param[in] ControllerHandle       The handle with Device Path protocol on it.
1337   @param[in] MatchingHandleCount    The pointer to UINTN that specifies the number of HANDLES in
1338                                     MatchingHandleBuffer.
1339   @param[out] MatchingHandleBuffer  On a successful return, a buffer of MatchingHandleCount
1340                                     EFI_HANDLEs with a terminating NULL EFI_HANDLE.
1341   @param[out] HandleType            An array of type information.
1342
1343   @retval EFI_SUCCESS               The operation was successful, and any related handles
1344                                     are in MatchingHandleBuffer.
1345   @retval EFI_NOT_FOUND             No matching handles were found.
1346   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
1347 **/
1348 EFI_STATUS
1349 EFIAPI
1350 ParseHandleDatabaseByRelationshipWithType (
1351   IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,
1352   IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
1353   IN UINTN            *HandleCount,
1354   OUT EFI_HANDLE      **HandleBuffer,
1355   OUT UINTN           **HandleType
1356   )
1357 {
1358   EFI_STATUS                          Status;
1359   UINTN                               HandleIndex;
1360   EFI_GUID                            **ProtocolGuidArray;
1361   UINTN                               ArrayCount;
1362   UINTN                               ProtocolIndex;
1363   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
1364   UINTN                               OpenInfoCount;
1365   UINTN                               OpenInfoIndex;
1366   UINTN                               ChildIndex;
1367   INTN                                DriverBindingHandleIndex;
1368
1369   ASSERT(HandleCount  != NULL);
1370   ASSERT(HandleBuffer != NULL);
1371   ASSERT(HandleType   != NULL);
1372   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
1373
1374   *HandleCount                  = 0;
1375   *HandleBuffer                 = NULL;
1376   *HandleType                   = NULL;
1377
1378   //
1379   // Retrieve the list of all handles from the handle database
1380   //
1381   Status = gBS->LocateHandleBuffer (
1382                 AllHandles,
1383                 NULL,
1384                 NULL,
1385                 HandleCount,
1386                 HandleBuffer
1387                );
1388   if (EFI_ERROR (Status)) {
1389     return (Status);
1390   }
1391
1392   *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));
1393   ASSERT(*HandleType != NULL);
1394
1395   DriverBindingHandleIndex = -1;
1396   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
1397     if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {
1398       DriverBindingHandleIndex = (INTN)HandleIndex;
1399     }
1400   }
1401
1402   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
1403     //
1404     // Retrieve the list of all the protocols on each handle
1405     //
1406     Status = gBS->ProtocolsPerHandle (
1407                   (*HandleBuffer)[HandleIndex],
1408                   &ProtocolGuidArray,
1409                   &ArrayCount
1410                  );
1411     if (EFI_ERROR (Status)) {
1412       continue;
1413     }
1414
1415     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
1416
1417       //
1418       // Set the bit describing what this handle has
1419       //
1420       if        (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)         ) {
1421         (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;
1422       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)       ) {
1423         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;
1424       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
1425         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
1426       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {
1427         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
1428       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)  ) {
1429         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
1430       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)   ) {
1431         (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
1432       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)      ) {
1433         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
1434       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)       ) {
1435         (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
1436       } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {
1437         (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;
1438       } else {
1439         DEBUG_CODE_BEGIN();
1440         ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);
1441         DEBUG_CODE_END();
1442       }
1443       //
1444       // Retrieve the list of agents that have opened each protocol
1445       //
1446       Status = gBS->OpenProtocolInformation (
1447                       (*HandleBuffer)[HandleIndex],
1448                       ProtocolGuidArray[ProtocolIndex],
1449                       &OpenInfo,
1450                       &OpenInfoCount
1451                      );
1452       if (EFI_ERROR (Status)) {
1453         continue;
1454       }
1455
1456       if (ControllerHandle == NULL) {
1457         //
1458         // ControllerHandle == NULL and DriverBindingHandle != NULL.
1459         // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
1460         //
1461         for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1462           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1463             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1464             if (DriverBindingHandleIndex != -1) {
1465               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
1466             }
1467           }
1468           if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1469             (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1470             if (DriverBindingHandleIndex != -1) {
1471               (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1472             }
1473             for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1474               if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1475                 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1476               }
1477             }
1478           }
1479         }
1480       }
1481       if (DriverBindingHandle == NULL && ControllerHandle != NULL) {
1482         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
1483           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1484           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1485             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1486               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1487                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1488                   (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;
1489                 }
1490               }
1491             }
1492             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1493               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1494                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1495                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1496                 }
1497                 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1498                   (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1499                 }
1500               }
1501             }
1502           }
1503         } else {
1504           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1505             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1506               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
1507                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
1508               }
1509             }
1510           }
1511         }
1512       }
1513       if (DriverBindingHandle != NULL && ControllerHandle != NULL) {
1514         if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
1515           (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
1516           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1517             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
1518               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
1519                 if (DriverBindingHandleIndex != -1) {
1520                   (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
1521                 }
1522               }
1523             }
1524             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1525               if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
1526                 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1527                   if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
1528                     (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
1529                   }
1530                 }
1531               }
1532
1533               for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
1534                 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
1535                   (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
1536                 }
1537               }
1538             }
1539           }
1540         } else {
1541           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1542             if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1543               if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
1544                 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
1545               }
1546             }
1547           }
1548         }
1549       }
1550       FreePool (OpenInfo);
1551     }
1552     FreePool (ProtocolGuidArray);
1553   }
1554   return EFI_SUCCESS;
1555 }
1556
1557 /**
1558   Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
1559   supplied.
1560
1561   This function will scan all EFI_HANDLES in the UEFI environment's handle database
1562   and return all the ones with the specified relationship (Mask) to the specified
1563   controller handle.
1564
1565   If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1566   If MatchingHandleCount is NULL, then ASSERT.
1567
1568   If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
1569   caller freed.
1570
1571   @param[in] DriverBindingHandle    Handle to a object with Driver Binding protocol
1572                                     on it.
1573   @param[in] ControllerHandle       Handle to a device with Device Path protocol on it.
1574   @param[in] Mask                   Mask of what relationship(s) is desired.
1575   @param[in] MatchingHandleCount    Poitner to UINTN specifying number of HANDLES in
1576                                     MatchingHandleBuffer.
1577   @param[out] MatchingHandleBuffer  On a sucessful return a buffer of MatchingHandleCount
1578                                     EFI_HANDLEs and a terminating NULL EFI_HANDLE.
1579
1580   @retval EFI_SUCCESS               The operation was sucessful and any related handles
1581                                     are in MatchingHandleBuffer;
1582   @retval EFI_NOT_FOUND             No matching handles were found.
1583   @retval EFI_INVALID_PARAMETER     A parameter was invalid or out of range.
1584 **/
1585 EFI_STATUS
1586 EFIAPI
1587 ParseHandleDatabaseByRelationship (
1588   IN CONST EFI_HANDLE       DriverBindingHandle OPTIONAL,
1589   IN CONST EFI_HANDLE       ControllerHandle OPTIONAL,
1590   IN CONST UINTN            Mask,
1591   IN UINTN                  *MatchingHandleCount,
1592   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1593   )
1594 {
1595   EFI_STATUS            Status;
1596   UINTN                 HandleCount;
1597   EFI_HANDLE            *HandleBuffer;
1598   UINTN                 *HandleType;
1599   UINTN                 HandleIndex;
1600
1601   ASSERT(MatchingHandleCount != NULL);
1602   ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);
1603
1604   if ((Mask & HR_VALID_MASK) != Mask) {
1605     return (EFI_INVALID_PARAMETER);
1606   }
1607
1608   if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {
1609     return (EFI_INVALID_PARAMETER);
1610   }
1611
1612   *MatchingHandleCount = 0;
1613   if (MatchingHandleBuffer != NULL) {
1614     *MatchingHandleBuffer = NULL;
1615   }
1616
1617   HandleBuffer  = NULL;
1618   HandleType    = NULL;
1619
1620   Status = ParseHandleDatabaseByRelationshipWithType (
1621             DriverBindingHandle,
1622             ControllerHandle,
1623             &HandleCount,
1624             &HandleBuffer,
1625             &HandleType
1626            );
1627   if (!EFI_ERROR (Status)) {
1628     //
1629     // Count the number of handles that match the attributes in Mask
1630     //
1631     for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
1632       if ((HandleType[HandleIndex] & Mask) == Mask) {
1633         (*MatchingHandleCount)++;
1634       }
1635     }
1636     //
1637     // If no handles match the attributes in Mask then return EFI_NOT_FOUND
1638     //
1639     if (*MatchingHandleCount == 0) {
1640       Status = EFI_NOT_FOUND;
1641     } else {
1642
1643       if (MatchingHandleBuffer == NULL) {
1644         //
1645         // Someone just wanted the count...
1646         //
1647         Status = EFI_SUCCESS;
1648       } else {
1649         //
1650         // Allocate a handle buffer for the number of handles that matched the attributes in Mask
1651         //
1652         *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));
1653         ASSERT(*MatchingHandleBuffer != NULL);
1654
1655         for (HandleIndex = 0,*MatchingHandleCount = 0
1656           ;  HandleIndex < HandleCount
1657           ;  HandleIndex++
1658          ){
1659           //
1660           // Fill the allocated buffer with the handles that matched the attributes in Mask
1661           //
1662           if ((HandleType[HandleIndex] & Mask) == Mask) {
1663             (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];
1664           }
1665         }
1666
1667         //
1668         // Make the last one NULL
1669         //
1670         (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;
1671
1672         Status = EFI_SUCCESS;
1673       } // MacthingHandleBuffer == NULL (ELSE)
1674     } // *MatchingHandleCount  == 0 (ELSE)
1675   } // no error on ParseHandleDatabaseByRelationshipWithType
1676
1677   if (HandleBuffer != NULL) {
1678     FreePool (HandleBuffer);
1679   }
1680
1681   if (HandleType != NULL) {
1682     FreePool (HandleType);
1683   }
1684
1685   return Status;
1686 }
1687
1688 /**
1689   Gets handles for any child controllers of the passed in controller.
1690
1691   @param[in] ControllerHandle       The handle of the "parent controller"
1692   @param[in] MatchingHandleCount    Pointer to the number of handles in
1693                                     MatchingHandleBuffer on return.
1694   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
1695                                     return.
1696
1697
1698   @retval EFI_SUCCESS               The operation was sucessful.
1699 **/
1700 EFI_STATUS
1701 EFIAPI
1702 ParseHandleDatabaseForChildControllers(
1703   IN CONST EFI_HANDLE       ControllerHandle,
1704   IN UINTN                  *MatchingHandleCount,
1705   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1706   )
1707 {
1708   EFI_STATUS  Status;
1709   UINTN       HandleIndex;
1710   UINTN       DriverBindingHandleCount;
1711   EFI_HANDLE  *DriverBindingHandleBuffer;
1712   UINTN       DriverBindingHandleIndex;
1713   UINTN       ChildControllerHandleCount;
1714   EFI_HANDLE  *ChildControllerHandleBuffer;
1715   UINTN       ChildControllerHandleIndex;
1716   EFI_HANDLE  *HandleBufferForReturn;
1717
1718   if (MatchingHandleCount == NULL) {
1719     return (EFI_INVALID_PARAMETER);
1720   }
1721   *MatchingHandleCount = 0;
1722
1723   Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
1724             ControllerHandle,
1725             &DriverBindingHandleCount,
1726             &DriverBindingHandleBuffer
1727            );
1728   if (EFI_ERROR (Status)) {
1729     return Status;
1730   }
1731
1732   //
1733   // Get a buffer big enough for all the controllers.
1734   //
1735   HandleBufferForReturn = GetHandleListByProtocol(NULL);
1736   if (HandleBufferForReturn == NULL) {
1737     FreePool (DriverBindingHandleBuffer);
1738     return (EFI_NOT_FOUND);
1739   }
1740
1741   for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {
1742     Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1743               DriverBindingHandleBuffer[DriverBindingHandleIndex],
1744               ControllerHandle,
1745               &ChildControllerHandleCount,
1746               &ChildControllerHandleBuffer
1747              );
1748     if (EFI_ERROR (Status)) {
1749       continue;
1750     }
1751
1752     for (ChildControllerHandleIndex = 0;
1753          ChildControllerHandleIndex < ChildControllerHandleCount;
1754          ChildControllerHandleIndex++
1755        ) {
1756       for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {
1757         if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
1758           break;
1759         }
1760       }
1761       if (HandleIndex >= *MatchingHandleCount) {
1762         HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
1763       }
1764     }
1765
1766     FreePool (ChildControllerHandleBuffer);
1767   }
1768
1769   FreePool (DriverBindingHandleBuffer);
1770
1771   if (MatchingHandleBuffer != NULL) {
1772     *MatchingHandleBuffer = HandleBufferForReturn;
1773   } else {
1774     FreePool(HandleBufferForReturn);
1775   }
1776
1777   return (EFI_SUCCESS);
1778 }
1779
1780 /**
1781   Appends 1 buffer to another buffer.  This will re-allocate the destination buffer
1782   if necessary to fit all of the data.
1783
1784   If DestinationBuffer is NULL, then ASSERT().
1785
1786   @param[in, out]  DestinationBuffer The pointer to the pointer to the buffer to append onto.
1787   @param[in, out]  DestinationSize   The pointer to the size of DestinationBuffer.
1788   @param[in]       SourceBuffer      The pointer to the buffer to append onto DestinationBuffer.
1789   @param[in]       SourceSize        The number of bytes of SourceBuffer to append.
1790
1791   @retval NULL                      A memory allocation failed.
1792   @retval NULL                      A parameter was invalid.
1793   @return                           A pointer to (*DestinationBuffer).
1794 **/
1795 VOID*
1796 EFIAPI
1797 BuffernCatGrow (
1798   IN OUT VOID   **DestinationBuffer,
1799   IN OUT UINTN  *DestinationSize,
1800   IN     VOID   *SourceBuffer,
1801   IN     UINTN  SourceSize
1802   )
1803 {
1804   UINTN LocalDestinationSize;
1805   UINTN LocalDestinationFinalSize;
1806
1807   ASSERT(DestinationBuffer != NULL);
1808
1809   if (SourceSize == 0 || SourceBuffer == NULL) {
1810     return (*DestinationBuffer);
1811   }
1812
1813   if (DestinationSize == NULL) {
1814     LocalDestinationSize = 0;
1815   } else {
1816     LocalDestinationSize = *DestinationSize;
1817   }
1818
1819   LocalDestinationFinalSize = LocalDestinationSize + SourceSize;
1820
1821   if (DestinationSize != NULL) {
1822     *DestinationSize = LocalDestinationSize;
1823   }
1824
1825   if (LocalDestinationSize == 0) {
1826     // allcoate
1827     *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);
1828   } else {
1829     // reallocate
1830     *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);
1831   }
1832
1833   ASSERT(*DestinationBuffer != NULL);
1834
1835   // copy
1836   return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));
1837 }
1838
1839 /**
1840   Gets handles for any child devices produced by the passed in driver.
1841
1842   @param[in] DriverHandle           The handle of the driver.
1843   @param[in] MatchingHandleCount    Pointer to the number of handles in
1844                                     MatchingHandleBuffer on return.
1845   @param[out] MatchingHandleBuffer  Buffer containing handles on a successful
1846                                     return.
1847   @retval EFI_SUCCESS               The operation was sucessful.
1848   @sa ParseHandleDatabaseByRelationship
1849 **/
1850 EFI_STATUS
1851 EFIAPI
1852 ParseHandleDatabaseForChildDevices(
1853   IN CONST EFI_HANDLE       DriverHandle,
1854   IN UINTN                  *MatchingHandleCount,
1855   OUT EFI_HANDLE            **MatchingHandleBuffer OPTIONAL
1856   )
1857 {
1858   EFI_HANDLE      *Buffer;
1859   EFI_HANDLE      *Buffer2;
1860   UINTN           Count1;
1861   UINTN           Count2;
1862   UINTN           HandleIndex;
1863   EFI_STATUS      Status;
1864   UINTN           HandleBufferSize;
1865
1866   ASSERT(MatchingHandleCount != NULL);
1867
1868   HandleBufferSize      = 0;
1869   Buffer                = NULL;
1870   Buffer2               = NULL;
1871   *MatchingHandleCount  = 0;
1872
1873   Status = PARSE_HANDLE_DATABASE_DEVICES (
1874             DriverHandle,
1875             &Count1,
1876             &Buffer
1877            );
1878   if (!EFI_ERROR (Status)) {
1879     for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {
1880       //
1881       // now find the children
1882       //
1883       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1884                 DriverHandle,
1885                 Buffer[HandleIndex],
1886                 &Count2,
1887                 &Buffer2
1888                );
1889       if (EFI_ERROR(Status)) {
1890         break;
1891       }
1892       //
1893       // save out required and optional data elements
1894       //
1895       *MatchingHandleCount += Count2;
1896       if (MatchingHandleBuffer != NULL) {
1897         *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));
1898       }
1899
1900       //
1901       // free the memory
1902       //
1903       if (Buffer2 != NULL) {
1904         FreePool(Buffer2);
1905       }
1906     }
1907   }
1908
1909   if (Buffer != NULL) {
1910     FreePool(Buffer);
1911   }
1912   return (Status);
1913 }
1914
1915 /**
1916   Function to get all handles that support a given protocol or all handles.
1917
1918   @param[in] ProtocolGuid The guid of the protocol to get handles for.  If NULL
1919                           then the function will return all handles.
1920
1921   @retval NULL            A memory allocation failed.
1922   @return                 A NULL terminated list of handles.
1923 **/
1924 EFI_HANDLE*
1925 EFIAPI
1926 GetHandleListByProtocol (
1927   IN CONST EFI_GUID *ProtocolGuid OPTIONAL
1928   )
1929 {
1930   EFI_HANDLE          *HandleList;
1931   UINTN               Size;
1932   EFI_STATUS          Status;
1933
1934   Size = 0;
1935   HandleList = NULL;
1936
1937   //
1938   // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
1939   //
1940   if (ProtocolGuid == NULL) {
1941     Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
1942     if (Status == EFI_BUFFER_TOO_SMALL) {
1943       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
1944       if (HandleList == NULL) {
1945         return (NULL);
1946       }
1947       Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);
1948       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
1949     }
1950   } else {
1951     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
1952     if (Status == EFI_BUFFER_TOO_SMALL) {
1953       HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));
1954       if (HandleList == NULL) {
1955         return (NULL);
1956       }
1957       Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);
1958       HandleList[Size/sizeof(EFI_HANDLE)] = NULL;
1959     }
1960   }
1961   if (EFI_ERROR(Status)) {
1962     if (HandleList != NULL) {
1963       FreePool(HandleList);
1964     }
1965     return (NULL);
1966   }
1967   return (HandleList);
1968 }
1969
1970 /**
1971   Function to get all handles that support some protocols.
1972
1973   @param[in] ProtocolGuids  A NULL terminated list of protocol GUIDs.
1974
1975   @retval NULL              A memory allocation failed.
1976   @retval NULL              ProtocolGuids was NULL.
1977   @return                   A NULL terminated list of EFI_HANDLEs.
1978 **/
1979 EFI_HANDLE*
1980 EFIAPI
1981 GetHandleListByProtocolList (
1982   IN CONST EFI_GUID **ProtocolGuids
1983   )
1984 {
1985   EFI_HANDLE          *HandleList;
1986   UINTN               Size;
1987   UINTN               TotalSize;
1988   UINTN               TempSize;
1989   EFI_STATUS          Status;
1990   CONST EFI_GUID      **GuidWalker;
1991   EFI_HANDLE          *HandleWalker1;
1992   EFI_HANDLE          *HandleWalker2;
1993
1994   Size        = 0;
1995   HandleList  = NULL;
1996   TotalSize   = sizeof(EFI_HANDLE);
1997
1998   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){
1999     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);
2000     if (Status == EFI_BUFFER_TOO_SMALL) {
2001       TotalSize += Size;
2002     }
2003   }
2004
2005   //
2006   // No handles were found...
2007   //
2008   if (TotalSize == sizeof(EFI_HANDLE)) {
2009     return (NULL);
2010   }
2011
2012   HandleList = AllocateZeroPool(TotalSize);
2013   if (HandleList == NULL) {
2014     return (NULL);
2015   }
2016
2017   Size = 0;
2018   for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){
2019     TempSize = TotalSize - Size;
2020     Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));
2021
2022     //
2023     // Allow for missing protocols... Only update the 'used' size upon success.
2024     //
2025     if (!EFI_ERROR(Status)) {
2026       Size += TempSize;
2027     }
2028   }
2029   ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);
2030
2031   for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {
2032     for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {
2033       if (*HandleWalker1 == *HandleWalker2) {
2034         //
2035         // copy memory back 1 handle width.
2036         //
2037         CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));
2038       }
2039     }
2040   }
2041
2042   return (HandleList);
2043 }
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053