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