ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

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