ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

   1 /** @file
   2   Main file for Dh shell Driver1 function.
   3
   4   (C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2010 - 2017, 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 "UefiShellDriver1CommandsLib.h"
  17
  18 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
  19   {L"-p", TypeValue},
  20   {L"-d", TypeFlag},
  21   {L"-v", TypeFlag},
  22   {L"-verbose", TypeFlag},
  23   {L"-sfo", TypeFlag},
  24   {L"-l", TypeValue},
  25   {NULL, TypeMax}
  26   };
  27
  28 STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
  29   &gEfiDriverBindingProtocolGuid,
  30   &gEfiPlatformDriverOverrideProtocolGuid,
  31   &gEfiBusSpecificDriverOverrideProtocolGuid,
  32   &gEfiDriverDiagnosticsProtocolGuid,
  33   &gEfiDriverDiagnostics2ProtocolGuid,
  34   &gEfiComponentNameProtocolGuid,
  35   &gEfiComponentName2ProtocolGuid,
  36   &gEfiPlatformToDriverConfigurationProtocolGuid,
  37   &gEfiDriverSupportedEfiVersionProtocolGuid,
  38   &gEfiDriverFamilyOverrideProtocolGuid,
  39   &gEfiDriverHealthProtocolGuid,
  40   &gEfiLoadedImageProtocolGuid,
  41   NULL
  42 };
  43
  44 /**
  45   Get the name of a driver by it's handle.
  46
  47   If a name is found the memory must be callee freed.
  48
  49   @param[in] TheHandle    The driver's handle.
  50   @param[in] Language     The language to use.
  51   @param[in] NameFound    Upon a successful return the name found.
  52
  53   @retval EFI_SUCCESS     The name was found.
  54 **/
  55 EFI_STATUS
  56 GetDriverName (
  57   IN EFI_HANDLE   TheHandle,
  58   IN CONST CHAR8  *Language,
  59   IN CHAR16       **NameFound
  60   )
  61 {
  62   CHAR8                             *Lang;
  63   EFI_STATUS                        Status;
  64   EFI_COMPONENT_NAME2_PROTOCOL      *CompName2;
  65   CHAR16                            *NameToReturn;
  66   //
  67   // Go through those handles until we get one that passes for GetComponentName
  68   //
  69   Status = gBS->OpenProtocol(
  70     TheHandle,
  71     &gEfiComponentName2ProtocolGuid,
  72     (VOID**)&CompName2,
  73     gImageHandle,
  74     NULL,
  75     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  76   if (EFI_ERROR(Status)) {
  77     Status = gBS->OpenProtocol(
  78       TheHandle,
  79       &gEfiComponentNameProtocolGuid,
  80       (VOID**)&CompName2,
  81       gImageHandle,
  82       NULL,
  83       EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  84   }
  85
  86   if (EFI_ERROR(Status)) {
  87     return (EFI_NOT_FOUND);
  88   }
  89   Lang = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);
  90   Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
  91   FreePool(Lang);
  92
  93   if (!EFI_ERROR(Status) && NameToReturn != NULL) {
  94     *NameFound = NULL;
  95     StrnCatGrow(NameFound, NULL, NameToReturn, 0);
  96   }
  97   return (Status);
  98 }
  99
 100 /**
 101   Discover if a protocol guid is one of the UEFI Driver Model Protocols.
 102
 103   @param[in] Guid   The guid to test.
 104
 105   @retval TRUE      The guid does represent a driver model protocol.
 106   @retval FALSE     The guid does not represent a driver model protocol.
 107 **/
 108 BOOLEAN
 109 IsDriverProt (
 110   IN CONST EFI_GUID *Guid
 111   )
 112 {
 113   CONST EFI_GUID            **GuidWalker;
 114   BOOLEAN                   GuidFound;
 115   GuidFound = FALSE;
 116   for (GuidWalker = UefiDriverModelProtocolsGuidArray
 117     ;  GuidWalker != NULL && *GuidWalker != NULL
 118     ;  GuidWalker++
 119    ){
 120     if (CompareGuid(*GuidWalker, Guid)) {
 121       GuidFound = TRUE;
 122       break;
 123     }
 124   }
 125   return (GuidFound);
 126 }
 127
 128 /**
 129   Get information for a handle.
 130
 131   @param[in] TheHandle        The handles to show info on.
 132   @param[in] Language         Language string per UEFI specification.
 133   @param[in] Separator        Separator string between information blocks.
 134   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 135   @param[in] ExtraInfo        TRUE for extra info, FALSE otherwise.
 136
 137   @retval SHELL_SUCCESS           The operation was successful.
 138   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 139 **/
 140 CHAR16*
 141 GetProtocolInfoString(
 142   IN CONST EFI_HANDLE TheHandle,
 143   IN CONST CHAR8      *Language,
 144   IN CONST CHAR16     *Separator,
 145   IN CONST BOOLEAN    Verbose,
 146   IN CONST BOOLEAN    ExtraInfo
 147   )
 148 {
 149   EFI_GUID                  **ProtocolGuidArray;
 150   UINTN                     ArrayCount;
 151   UINTN                     ProtocolIndex;
 152   EFI_STATUS                Status;
 153   CHAR16                    *RetVal;
 154   UINTN                     Size;
 155   CHAR16                    *Temp;
 156   CHAR16                    GuidStr[40];
 157
 158   ProtocolGuidArray = NULL;
 159   RetVal            = NULL;
 160   Size              = 0;
 161
 162   Status = gBS->ProtocolsPerHandle (
 163                 TheHandle,
 164                 &ProtocolGuidArray,
 165                 &ArrayCount
 166                );
 167   if (!EFI_ERROR (Status)) {
 168     for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
 169       Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
 170       ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 171       if (Size != 0) {
 172         StrnCatGrow(&RetVal, &Size, Separator, 0);
 173       }
 174       StrnCatGrow(&RetVal, &Size, L"%H", 0);
 175       if (Temp == NULL) {
 176         UnicodeSPrint (GuidStr, sizeof (GuidStr), L"%g", ProtocolGuidArray[ProtocolIndex]);
 177         StrnCatGrow (&RetVal, &Size, GuidStr, 0);
 178       } else {
 179         StrnCatGrow(&RetVal, &Size, Temp, 0);
 180         FreePool(Temp);
 181       }
 182       StrnCatGrow(&RetVal, &Size, L"%N", 0);
 183       if (ExtraInfo) {
 184         Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
 185         if (Temp != NULL) {
 186           ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 187           if (!Verbose) {
 188             StrnCatGrow(&RetVal, &Size, L"(", 0);
 189             StrnCatGrow(&RetVal, &Size, Temp, 0);
 190             StrnCatGrow(&RetVal, &Size, L")\r\n", 0);
 191           } else {
 192             StrnCatGrow(&RetVal, &Size, Separator, 0);
 193             StrnCatGrow(&RetVal, &Size, Temp, 0);
 194           }
 195           FreePool(Temp);
 196         }
 197       }
 198     }
 199   }
 200
 201   SHELL_FREE_NON_NULL(ProtocolGuidArray);
 202
 203   if (RetVal == NULL) {
 204     return (NULL);
 205   }
 206
 207   ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
 208   StrnCatGrow(&RetVal, &Size, Separator, 0);
 209   return (RetVal);
 210 }
 211
 212 /**
 213   Gets the name of the loaded image.
 214
 215   @param[in] TheHandle    The handle of the driver to get info on.
 216   @param[out] Name        The pointer to the pointer.  Valid upon a successful return.
 217
 218   @retval EFI_SUCCESS     The operation was successful.
 219 **/
 220 EFI_STATUS
 221 GetDriverImageName (
 222   IN EFI_HANDLE   TheHandle,
 223   OUT CHAR16      **Name
 224   )
 225 {
 226   // get loaded image and devicepathtotext on image->Filepath
 227   EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
 228   EFI_STATUS                Status;
 229   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 230
 231   if (TheHandle == NULL || Name == NULL) {
 232     return (EFI_INVALID_PARAMETER);
 233   }
 234
 235   Status = gBS->OpenProtocol (
 236                 TheHandle,
 237                 &gEfiLoadedImageProtocolGuid,
 238                 (VOID **) &LoadedImage,
 239                 gImageHandle,
 240                 NULL,
 241                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 242                );
 243   if (EFI_ERROR(Status)) {
 244     return (Status);
 245   }
 246   DevicePath = LoadedImage->FilePath;
 247   *Name = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
 248   return (EFI_SUCCESS);
 249 }
 250
 251 /**
 252   Display driver model information for a given handle.
 253
 254   @param[in] Handle     The handle to display info on.
 255   @param[in] BestName   Use the best name?
 256   @param[in] Language   The language to output in.
 257 **/
 258 EFI_STATUS
 259 DisplayDriverModelHandle (
 260   IN EFI_HANDLE  Handle,
 261   IN BOOLEAN     BestName,
 262   IN CONST CHAR8 *Language OPTIONAL
 263   )
 264 {
 265   EFI_STATUS                  Status;
 266   BOOLEAN                     ConfigurationStatus;
 267   BOOLEAN                     DiagnosticsStatus;
 268   UINTN                       DriverBindingHandleCount;
 269   EFI_HANDLE                  *DriverBindingHandleBuffer;
 270   UINTN                       ParentControllerHandleCount;
 271   EFI_HANDLE                  *ParentControllerHandleBuffer;
 272   UINTN                       ChildControllerHandleCount;
 273   EFI_HANDLE                  *ChildControllerHandleBuffer;
 274   CHAR16                      *TempStringPointer;
 275   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
 276   UINTN                       Index;
 277   CHAR16                      *DriverName;
 278   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
 279   UINTN                       NumberOfChildren;
 280   UINTN                       HandleIndex;
 281   UINTN                       ControllerHandleCount;
 282   EFI_HANDLE                  *ControllerHandleBuffer;
 283   UINTN                       ChildIndex;
 284   BOOLEAN                     Image;
 285
 286   DriverName = NULL;
 287
 288   //
 289   // See if Handle is a device handle and display its details.
 290   //
 291   DriverBindingHandleBuffer = NULL;
 292   Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
 293             Handle,
 294             &DriverBindingHandleCount,
 295             &DriverBindingHandleBuffer
 296             );
 297
 298   ParentControllerHandleBuffer = NULL;
 299   Status = PARSE_HANDLE_DATABASE_PARENTS (
 300             Handle,
 301             &ParentControllerHandleCount,
 302             &ParentControllerHandleBuffer
 303             );
 304
 305   ChildControllerHandleBuffer = NULL;
 306   Status = ParseHandleDatabaseForChildControllers (
 307             Handle,
 308             &ChildControllerHandleCount,
 309             &ChildControllerHandleBuffer
 310             );
 311
 312   DiagnosticsStatus = FALSE;
 313   ConfigurationStatus = FALSE;
 314
 315   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 316     ConfigurationStatus = TRUE;
 317   }
 318   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 319     ConfigurationStatus = TRUE;
 320   }
 321   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 322     DiagnosticsStatus = TRUE;
 323   }
 324   if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
 325     DiagnosticsStatus = TRUE;
 326   }
 327
 328   Status = EFI_SUCCESS;
 329
 330   if (DriverBindingHandleCount > 0 || ParentControllerHandleCount > 0 || ChildControllerHandleCount > 0) {
 331
 332
 333
 334     DevicePath          = NULL;
 335     TempStringPointer   = NULL;
 336     Status              = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
 337
 338     Status = gEfiShellProtocol->GetDeviceName(Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 339     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer!=NULL?TempStringPointer:L"<Unknown>");
 340     SHELL_FREE_NON_NULL(TempStringPointer);
 341
 342     TempStringPointer = ConvertDevicePathToText(DevicePath, TRUE, FALSE);
 343     ShellPrintHiiEx(
 344       -1,
 345       -1,
 346       NULL,
 347       STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),
 348       gShellDriver1HiiHandle,
 349       TempStringPointer!=NULL?TempStringPointer:L"<None>",
 350       ParentControllerHandleCount == 0?L"ROOT":(ChildControllerHandleCount > 0)?L"BUS":L"DEVICE",
 351       ConfigurationStatus?L"YES":L"NO",
 352       DiagnosticsStatus?L"YES":L"NO"
 353       );
 354
 355     SHELL_FREE_NON_NULL(TempStringPointer);
 356
 357     if (DriverBindingHandleCount == 0) {
 358       ShellPrintHiiEx(
 359         -1,
 360         -1,
 361         NULL,
 362         STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
 363         gShellDriver1HiiHandle,
 364         L"<None>"
 365         );
 366     } else {
 367       ShellPrintHiiEx(
 368         -1,
 369         -1,
 370         NULL,
 371         STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
 372         gShellDriver1HiiHandle,
 373         L""
 374         );
 375       for (Index = 0; Index < DriverBindingHandleCount; Index++) {
 376         Image = FALSE;
 377         Status = GetDriverName (
 378                   DriverBindingHandleBuffer[Index],
 379                   Language,
 380                   &DriverName
 381                   );
 382         if (EFI_ERROR (Status)) {
 383           Status = GetDriverImageName (
 384                     DriverBindingHandleBuffer[Index],
 385                     &DriverName
 386                     );
 387           if (EFI_ERROR (Status)) {
 388             DriverName = NULL;
 389           }
 390         }
 391
 392         if (Image) {
 393           ShellPrintHiiEx(
 394             -1,
 395             -1,
 396             NULL,
 397             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
 398             gShellDriver1HiiHandle,
 399             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 400             DriverName!=NULL?DriverName:L"<Unknown>"
 401             );
 402         } else {
 403           ShellPrintHiiEx(
 404             -1,
 405             -1,
 406             NULL,
 407             STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
 408             gShellDriver1HiiHandle,
 409             ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
 410             DriverName!=NULL?DriverName:L"<Unknown>"
 411             );
 412         }
 413         SHELL_FREE_NON_NULL(DriverName);
 414       }
 415     }
 416
 417     if (ParentControllerHandleCount == 0) {
 418       ShellPrintHiiEx(
 419         -1,
 420         -1,
 421         NULL,
 422         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 423         gShellDriver1HiiHandle,
 424         L"<None>"
 425         );
 426     } else {
 427       ShellPrintHiiEx(
 428         -1,
 429         -1,
 430         NULL,
 431         STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
 432         gShellDriver1HiiHandle,
 433         L""
 434         );
 435       for (Index = 0; Index < ParentControllerHandleCount; Index++) {
 436         Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 437         ShellPrintHiiEx(
 438           -1,
 439           -1,
 440           NULL,
 441           STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
 442           gShellDriver1HiiHandle,
 443           ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
 444           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 445           );
 446         SHELL_FREE_NON_NULL(TempStringPointer);
 447       }
 448     }
 449
 450     if (ChildControllerHandleCount == 0) {
 451       ShellPrintHiiEx(
 452         -1,
 453         -1,
 454         NULL,
 455         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 456         gShellDriver1HiiHandle,
 457         L"<None>"
 458         );
 459     } else {
 460       ShellPrintHiiEx(
 461         -1,
 462         -1,
 463         NULL,
 464         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 465         gShellDriver1HiiHandle,
 466         L""
 467         );
 468       for (Index = 0; Index < ChildControllerHandleCount; Index++) {
 469         Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 470         ShellPrintHiiEx(
 471           -1,
 472           -1,
 473           NULL,
 474           STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 475           gShellDriver1HiiHandle,
 476           ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
 477           TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 478           );
 479         SHELL_FREE_NON_NULL(TempStringPointer);
 480       }
 481     }
 482   }
 483
 484   SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
 485
 486   SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
 487
 488   SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
 489
 490   if (EFI_ERROR (Status)) {
 491     return Status;
 492   }
 493   //
 494   // See if Handle is a driver binding handle and display its details.
 495   //
 496   Status = gBS->OpenProtocol (
 497                 Handle,
 498                 &gEfiDriverBindingProtocolGuid,
 499                 (VOID **) &DriverBinding,
 500                 NULL,
 501                 NULL,
 502                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 503                 );
 504   if (EFI_ERROR (Status)) {
 505     return EFI_SUCCESS;
 506   }
 507
 508   NumberOfChildren        = 0;
 509   ControllerHandleBuffer  = NULL;
 510   Status = PARSE_HANDLE_DATABASE_DEVICES (
 511             Handle,
 512             &ControllerHandleCount,
 513             &ControllerHandleBuffer
 514             );
 515   if (ControllerHandleCount > 0) {
 516     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 517       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 518                 Handle,
 519                 ControllerHandleBuffer[HandleIndex],
 520                 &ChildControllerHandleCount,
 521                 NULL
 522                 );
 523       NumberOfChildren += ChildControllerHandleCount;
 524     }
 525   }
 526
 527   Status = GetDriverName (Handle, Language, &DriverName);
 528   if (EFI_ERROR (Status)) {
 529     DriverName = NULL;
 530   }
 531
 532   ShellPrintHiiEx(
 533     -1,
 534     -1,
 535     NULL,
 536     STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 537     gShellDriver1HiiHandle,
 538     ConvertHandleToHandleIndex(Handle),
 539     DriverName!=NULL?DriverName:L"<Unknown>"
 540     );
 541   SHELL_FREE_NON_NULL(DriverName);
 542   Status = GetDriverImageName (
 543             Handle,
 544             &DriverName
 545             );
 546   if (EFI_ERROR (Status)) {
 547     DriverName = NULL;
 548   }
 549   ShellPrintHiiEx(
 550     -1,
 551     -1,
 552     NULL,
 553     STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
 554     gShellDriver1HiiHandle,
 555     DriverName!=NULL?DriverName:L"<Unknown>"
 556     );
 557   SHELL_FREE_NON_NULL(DriverName);
 558
 559   ShellPrintHiiEx(
 560     -1,
 561     -1,
 562     NULL,
 563     STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
 564     gShellDriver1HiiHandle,
 565     DriverBinding->Version,
 566     NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
 567     ConfigurationStatus?L"YES":L"NO",
 568     DiagnosticsStatus?L"YES":L"NO"
 569     );
 570
 571   if (ControllerHandleCount == 0) {
 572       ShellPrintHiiEx(
 573         -1,
 574         -1,
 575         NULL,
 576         STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 577         gShellDriver1HiiHandle,
 578         L"None"
 579         );
 580   } else {
 581     ShellPrintHiiEx(
 582       -1,
 583       -1,
 584       NULL,
 585       STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
 586       gShellDriver1HiiHandle,
 587       L""
 588       );
 589     for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
 590       Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 591
 592       ShellPrintHiiEx(
 593         -1,
 594         -1,
 595         NULL,
 596         STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
 597         gShellDriver1HiiHandle,
 598         ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
 599         TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 600         );
 601       SHELL_FREE_NON_NULL(TempStringPointer);
 602
 603       Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
 604                 Handle,
 605                 ControllerHandleBuffer[HandleIndex],
 606                 &ChildControllerHandleCount,
 607                 &ChildControllerHandleBuffer
 608                 );
 609       if (!EFI_ERROR (Status)) {
 610         for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
 611           Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
 612
 613           ShellPrintHiiEx(
 614             -1,
 615             -1,
 616             NULL,
 617             STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
 618             gShellDriver1HiiHandle,
 619             ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
 620             TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
 621             );
 622           SHELL_FREE_NON_NULL(TempStringPointer);
 623         }
 624
 625         SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
 626       }
 627     }
 628
 629     SHELL_FREE_NON_NULL (ControllerHandleBuffer);
 630   }
 631
 632   return EFI_SUCCESS;
 633 }
 634
 635 /**
 636   Display information for a handle.
 637
 638   @param[in] TheHandle        The handles to show info on.
 639   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 640   @param[in] Sfo              TRUE to output in standard format output (spec).
 641   @param[in] Language         Language string per UEFI specification.
 642   @param[in] DriverInfo       TRUE to show all info about the handle.
 643   @param[in] Multiple         TRUE indicates more than  will be output,
 644                               FALSE for a single one.
 645 **/
 646 VOID
 647 DoDhByHandle(
 648   IN CONST EFI_HANDLE TheHandle,
 649   IN CONST BOOLEAN    Verbose,
 650   IN CONST BOOLEAN    Sfo,
 651   IN CONST CHAR8      *Language,
 652   IN CONST BOOLEAN    DriverInfo,
 653   IN CONST BOOLEAN    Multiple
 654   )
 655 {
 656   CHAR16 *ProtocolInfoString;
 657
 658   ProtocolInfoString  = NULL;
 659
 660   if (!Sfo) {
 661     if (Multiple) {
 662       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
 663       ShellPrintHiiEx(
 664         -1,
 665         -1,
 666         NULL,
 667         STRING_TOKEN (STR_DH_OUTPUT),
 668         gShellDriver1HiiHandle,
 669         ConvertHandleToHandleIndex(TheHandle),
 670         ProtocolInfoString==NULL?L"":ProtocolInfoString
 671       );
 672     } else {
 673       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", Verbose, TRUE);
 674       ShellPrintHiiEx(
 675         -1,
 676         -1,
 677         NULL,
 678         STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
 679         gShellDriver1HiiHandle,
 680         ConvertHandleToHandleIndex(TheHandle),
 681         TheHandle,
 682         ProtocolInfoString==NULL?L"":ProtocolInfoString
 683       );
 684     }
 685
 686     if (DriverInfo) {
 687       DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
 688     }
 689   } else {
 690       ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
 691       ShellPrintHiiEx(
 692         -1,
 693         -1,
 694         NULL,
 695         STRING_TOKEN (STR_DH_OUTPUT_SFO),
 696         gShellDriver1HiiHandle,
 697         Multiple ?L"HandlesInfo":L"HandleInfo",
 698         L"DriverName",
 699         L"ControllerName",
 700         ConvertHandleToHandleIndex(TheHandle),
 701         L"DevPath",
 702         ProtocolInfoString==NULL?L"":ProtocolInfoString
 703       );
 704   }
 705
 706   if (ProtocolInfoString != NULL) {
 707     FreePool(ProtocolInfoString);
 708   }
 709 }
 710
 711 /**
 712   Display information for all handles on a list.
 713
 714   @param[in] HandleList       The NULL-terminated list of handles.
 715   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 716   @param[in] Sfo              TRUE to output in standard format output (spec).
 717   @param[in] Language         Language string per UEFI specification.
 718   @param[in] DriverInfo       TRUE to show all info about the handle.
 719
 720   @retval SHELL_SUCCESS       The operation was successful.
 721   @retval SHELL_ABORTED       The operation was aborted.
 722 **/
 723 SHELL_STATUS
 724 DoDhForHandleList(
 725   IN CONST EFI_HANDLE *HandleList,
 726   IN CONST BOOLEAN    Verbose,
 727   IN CONST BOOLEAN    Sfo,
 728   IN CONST CHAR8      *Language,
 729   IN CONST BOOLEAN    DriverInfo
 730   )
 731 {
 732   CONST EFI_HANDLE  *HandleWalker;
 733   SHELL_STATUS      ShellStatus;
 734
 735   ShellStatus       = SHELL_SUCCESS;
 736
 737   for ( HandleWalker = HandleList; HandleWalker != NULL && *HandleWalker != NULL; HandleWalker++ ) {
 738     DoDhByHandle (*HandleWalker, Verbose, Sfo, Language, DriverInfo, TRUE);
 739     if (ShellGetExecutionBreakFlag ()) {
 740       ShellStatus = SHELL_ABORTED;
 741       break;
 742     }
 743   }
 744   return (ShellStatus);
 745 }
 746
 747 /**
 748   Display information for all handles.
 749
 750   @param[in] Sfo              TRUE to output in standard format output (spec).
 751   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 752   @param[in] Language         Language string per UEFI specification.
 753   @param[in] DriverInfo       TRUE to show all info about the handle.
 754
 755   @retval SHELL_SUCCESS           The operation was successful.
 756   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 757 **/
 758 SHELL_STATUS
 759 DoDhForAll(
 760   IN CONST BOOLEAN  Sfo,
 761   IN CONST BOOLEAN  Verbose,
 762   IN CONST CHAR8    *Language,
 763   IN CONST BOOLEAN  DriverInfo
 764   )
 765 {
 766   EFI_HANDLE    *HandleList;
 767   SHELL_STATUS  ShellStatus;
 768
 769   HandleList = GetHandleListByProtocol(NULL);
 770
 771   ShellStatus = DoDhForHandleList(
 772     HandleList,
 773     Verbose,
 774     Sfo,
 775     Language,
 776     DriverInfo);
 777
 778   FreePool(HandleList);
 779
 780   return (ShellStatus);
 781 }
 782
 783 /**
 784   Display information for all handles which have a specific protocol.
 785
 786   @param[in] ProtocolName     The pointer to the name of the protocol.
 787   @param[in] Verbose          TRUE for extra info, FALSE otherwise.
 788   @param[in] Sfo              TRUE to output in standard format output (spec).
 789   @param[in] Language         Language string per UEFI specification.
 790   @param[in] DriverInfo       TRUE to show all info about the handle.
 791
 792   @retval SHELL_SUCCESS           The operation was successful.
 793   @retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
 794 **/
 795 SHELL_STATUS
 796 DoDhByProtocol(
 797   IN CONST CHAR16   *ProtocolName,
 798   IN CONST BOOLEAN  Verbose,
 799   IN CONST BOOLEAN  Sfo,
 800   IN CONST CHAR8    *Language,
 801   IN CONST BOOLEAN  DriverInfo
 802   )
 803 {
 804   EFI_GUID      *Guid;
 805   EFI_STATUS    Status;
 806   EFI_HANDLE    *HandleList;
 807   SHELL_STATUS  ShellStatus;
 808
 809   if (ProtocolName == NULL) {
 810     return (SHELL_INVALID_PARAMETER);
 811   }
 812
 813   Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
 814   if (EFI_ERROR(Status)) {
 815     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
 816     return (SHELL_INVALID_PARAMETER);
 817   }
 818
 819   HandleList = GetHandleListByProtocol(Guid);
 820
 821   ShellStatus = DoDhForHandleList(
 822     HandleList,
 823     Verbose,
 824     Sfo,
 825     Language,
 826     DriverInfo);
 827
 828   SHELL_FREE_NON_NULL(HandleList);
 829
 830   return (ShellStatus);
 831 }
 832
 833 /**
 834   Function for 'dh' command.
 835
 836   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 837   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 838 **/
 839 SHELL_STATUS
 840 EFIAPI
 841 ShellCommandRunDh (
 842   IN EFI_HANDLE        ImageHandle,
 843   IN EFI_SYSTEM_TABLE  *SystemTable
 844   )
 845 {
 846   EFI_STATUS          Status;
 847   LIST_ENTRY          *Package;
 848   CHAR16              *ProblemParam;
 849   SHELL_STATUS        ShellStatus;
 850   CHAR8               *Language;
 851   CONST CHAR16        *Lang;
 852   CONST CHAR16        *RawValue;
 853   BOOLEAN             SfoFlag;
 854   BOOLEAN             DriverFlag;
 855   BOOLEAN             VerboseFlag;
 856   UINT64              Intermediate;
 857
 858   ShellStatus         = SHELL_SUCCESS;
 859   Status              = EFI_SUCCESS;
 860   Language            = NULL;
 861
 862   //
 863   // initialize the shell lib (we must be in non-auto-init...)
 864   //
 865   Status = ShellInitialize();
 866   ASSERT_EFI_ERROR(Status);
 867
 868   Status = CommandInit();
 869   ASSERT_EFI_ERROR(Status);
 870
 871   //
 872   // parse the command line
 873   //
 874   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 875   if (EFI_ERROR(Status)) {
 876     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 877       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"dh", ProblemParam);
 878       FreePool(ProblemParam);
 879       ShellStatus = SHELL_INVALID_PARAMETER;
 880     } else {
 881       ASSERT(FALSE);
 882     }
 883   } else {
 884     if (ShellCommandLineGetCount(Package) > 2) {
 885       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
 886       ShellCommandLineFreeVarList (Package);
 887       return (SHELL_INVALID_PARAMETER);
 888     }
 889
 890     if (ShellCommandLineGetFlag(Package, L"-l")) {
 891       Lang = ShellCommandLineGetValue(Package, L"-l");
 892       if (Lang != NULL) {
 893         Language = AllocateZeroPool(StrSize(Lang));
 894         AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
 895       } else {
 896         ASSERT(Language == NULL);
 897         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-l");
 898         ShellCommandLineFreeVarList(Package);
 899         return (SHELL_INVALID_PARAMETER);
 900       }
 901     } else {
 902       Language = AllocateZeroPool(10);
 903       AsciiSPrint(Language, 10, "en-us");
 904     }
 905
 906     SfoFlag     = ShellCommandLineGetFlag (Package, L"-sfo");
 907     DriverFlag  = ShellCommandLineGetFlag (Package, L"-d");
 908     VerboseFlag = (BOOLEAN)(ShellCommandLineGetFlag (Package, L"-v") || ShellCommandLineGetFlag (Package, L"-verbose"));
 909
 910     if (ShellCommandLineGetFlag (Package, L"-p")) {
 911       if (ShellCommandLineGetCount (Package) > 1) {
 912         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
 913         ShellStatus = SHELL_INVALID_PARAMETER;
 914       } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
 915         ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh",  L"-p");
 916         ShellStatus = SHELL_INVALID_PARAMETER;
 917       } else {
 918         //
 919         // print by protocol
 920         //
 921         ShellStatus = DoDhByProtocol(
 922           ShellCommandLineGetValue(Package, L"-p"),
 923           VerboseFlag,
 924           SfoFlag,
 925           Language,
 926           DriverFlag
 927         );
 928       }
 929     } else {
 930       RawValue = ShellCommandLineGetRawValue(Package, 1);
 931       if (RawValue == NULL) {
 932         //
 933         // Print everything
 934         //
 935         ShellStatus = DoDhForAll(
 936           SfoFlag,
 937           VerboseFlag,
 938           Language,
 939           DriverFlag
 940          );
 941       } else {
 942         Status = ShellConvertStringToUint64(RawValue, &Intermediate, TRUE, FALSE);
 943         if (EFI_ERROR(Status) || ConvertHandleIndexToHandle((UINTN)Intermediate) == NULL) {
 944           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);
 945           ShellStatus = SHELL_INVALID_PARAMETER;
 946         } else {
 947           //
 948           // print 1 handle
 949           //
 950           DoDhByHandle(
 951             ConvertHandleIndexToHandle((UINTN)Intermediate),
 952             VerboseFlag,
 953             SfoFlag,
 954             Language,
 955             DriverFlag,
 956             FALSE
 957           );
 958         }
 959       }
 960     }
 961
 962
 963     ShellCommandLineFreeVarList (Package);
 964     SHELL_FREE_NON_NULL(Language);
 965   }
 966
 967   return (ShellStatus);
 968 }