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