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