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