tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-10-31 11:13:53 +01:00
Code Issues Packages Projects Releases Wiki Activity
audk/ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c
Michael D Kinney 56ba37463a ShellPkg: Replace BSD License with BSD+Patent License 
https://bugzilla.tianocore.org/show_bug.cgi?id=1373

Replace BSD 2-Clause License with BSD+Patent License.  This change is
based on the following emails:

  https://lists.01.org/pipermail/edk2-devel/2019-February/036260.html
  https://lists.01.org/pipermail/edk2-devel/2018-October/030385.html

RFCs with detailed process for the license change:

  V3: https://lists.01.org/pipermail/edk2-devel/2019-March/038116.html
  V2: https://lists.01.org/pipermail/edk2-devel/2019-March/037669.html
  V1: https://lists.01.org/pipermail/edk2-devel/2019-March/037500.html

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
Reviewed-by: Ray Ni <ray.ni@intel.com>
Reviewed-by: Jaben Carsey <jaben.carsey@intel.com>
2019-04-09 10:58:25 -07:00

1192 lines
37 KiB
C
Raw Blame History

/** @file
Main file for Dh shell Driver1 function.
(C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2017 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "UefiShellDriver1CommandsLib.h"
STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
{L"-p", TypeValue},
{L"-d", TypeFlag},
{L"-v", TypeFlag},
{L"-verbose", TypeFlag},
{L"-sfo", TypeFlag},
{L"-l", TypeValue},
{NULL, TypeMax}
};
STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
&gEfiDriverBindingProtocolGuid,
&gEfiPlatformDriverOverrideProtocolGuid,
&gEfiBusSpecificDriverOverrideProtocolGuid,
&gEfiDriverDiagnosticsProtocolGuid,
&gEfiDriverDiagnostics2ProtocolGuid,
&gEfiComponentNameProtocolGuid,
&gEfiComponentName2ProtocolGuid,
&gEfiPlatformToDriverConfigurationProtocolGuid,
&gEfiDriverSupportedEfiVersionProtocolGuid,
&gEfiDriverFamilyOverrideProtocolGuid,
&gEfiDriverHealthProtocolGuid,
&gEfiLoadedImageProtocolGuid,
NULL
};
UINTN mGuidDataLen[] = {8, 4, 4, 4, 12};
/**
Function to determine if the string can convert to a GUID.
The string must be restricted as "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" format.
@param[in] String The string to test.
@retval TRUE The string can convert to a GUID.
@retval FALSE The string can't convert to a GUID.
**/
BOOLEAN
IsValidGuidString(
IN CONST CHAR16 *String
)
{
CONST CHAR16 *Walker;
CONST CHAR16 *PrevWalker;
UINTN Index;
if (String == NULL) {
return FALSE;
}
Walker = String;
PrevWalker = String;
Index = 0;
while (Walker != NULL && *Walker != CHAR_NULL) {
if ( (*Walker >= '0' && *Walker <= '9') ||
(*Walker >= 'a' && *Walker <= 'f') ||
(*Walker >= 'A' && *Walker <= 'F')
) {
Walker++;
} else {
if (*Walker == L'-' && (((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {
Walker++;
PrevWalker = Walker;
Index++;
} else {
return FALSE;
}
}
}
if ((((UINTN)Walker - (UINTN)PrevWalker) / sizeof (CHAR16)) == mGuidDataLen[Index]) {
return TRUE;
} else {
return FALSE;
}
}
/**
Convert a hex-character to decimal value.
This internal function only deal with Unicode character
which maps to a valid hexadecimal ASII character, i.e.
L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
Unicode character, the value returned does not make sense.
@param[in] Char The character to convert.
@retval The numerical value converted.
**/
UINTN
HexCharToDecimal(
IN CHAR16 Char
)
{
if (Char >= '0' && Char <= '9') {
return Char - L'0';
} else if (Char >= 'a' && Char <= 'f') {
return Char - L'a' + 10;
} else {
return Char - L'A' + 10;
}
}
/**
Function try to convert a string to GUID format.
@param[in] String The string will be converted.
@param[out] Guid Save the result convert from string.
@retval EFI_SUCCESS The string was successfully converted to a GUID.
@retval EFI_UNSUPPORTED The input string is not in registry format.
**/
EFI_STATUS
ConvertStrToGuid(
IN CONST CHAR16 *String,
OUT GUID *Guid
)
{
CONST CHAR16 *Walker;
UINT8 TempValue;
UINTN Index;
if (String == NULL || !IsValidGuidString (String)) {
return EFI_UNSUPPORTED;
}
Index = 0;
Walker = String;
Guid->Data1 = (UINT32)StrHexToUint64 (Walker);
Walker += 9;
Guid->Data2 = (UINT16)StrHexToUint64 (Walker);
Walker += 5;
Guid->Data3 = (UINT16)StrHexToUint64 (Walker);
Walker += 5;
while (Walker != NULL && *Walker != CHAR_NULL) {
if (*Walker == L'-') {
Walker++;
} else {
TempValue = (UINT8)HexCharToDecimal (*Walker);
TempValue = (UINT8)LShiftU64 (TempValue, 4);
Walker++;
TempValue += (UINT8)HexCharToDecimal (*Walker);
Walker++;
Guid->Data4[Index] = TempValue;
Index++;
}
}
return EFI_SUCCESS;
}
/**
Get the name of a driver by it's handle.
If a name is found the memory must be callee freed.
@param[in] TheHandle The driver's handle.
@param[in] Language The language to use.
@param[in] NameFound Upon a successful return the name found.
@retval EFI_SUCCESS The name was found.
**/
EFI_STATUS
GetDriverName (
IN EFI_HANDLE TheHandle,
IN CONST CHAR8 *Language,
IN CHAR16 **NameFound
)
{
CHAR8 *Lang;
EFI_STATUS Status;
EFI_COMPONENT_NAME2_PROTOCOL *CompName2;
CHAR16 *NameToReturn;
//
// Go through those handles until we get one that passes for GetComponentName
//
Status = gBS->OpenProtocol(
TheHandle,
&gEfiComponentName2ProtocolGuid,
(VOID**)&CompName2,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (EFI_ERROR(Status)) {
Status = gBS->OpenProtocol(
TheHandle,
&gEfiComponentNameProtocolGuid,
(VOID**)&CompName2,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
}
if (EFI_ERROR(Status)) {
return (EFI_NOT_FOUND);
}
Lang = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);
Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
FreePool(Lang);
if (!EFI_ERROR(Status) && NameToReturn != NULL) {
*NameFound = NULL;
StrnCatGrow(NameFound, NULL, NameToReturn, 0);
}
return (Status);
}
/**
Discover if a protocol guid is one of the UEFI Driver Model Protocols.
@param[in] Guid The guid to test.
@retval TRUE The guid does represent a driver model protocol.
@retval FALSE The guid does not represent a driver model protocol.
**/
BOOLEAN
IsDriverProt (
IN CONST EFI_GUID *Guid
)
{
CONST EFI_GUID **GuidWalker;
BOOLEAN GuidFound;
GuidFound = FALSE;
for (GuidWalker = UefiDriverModelProtocolsGuidArray
; GuidWalker != NULL && *GuidWalker != NULL
; GuidWalker++
){
if (CompareGuid(*GuidWalker, Guid)) {
GuidFound = TRUE;
break;
}
}
return (GuidFound);
}
/**
Get information for a handle.
@param[in] TheHandle The handles to show info on.
@param[in] Language Language string per UEFI specification.
@param[in] Separator Separator string between information blocks.
@param[in] Verbose TRUE for extra info, FALSE otherwise.
@param[in] ExtraInfo TRUE for extra info, FALSE otherwise.
@retval SHELL_SUCCESS The operation was successful.
@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
**/
CHAR16*
GetProtocolInfoString(
IN CONST EFI_HANDLE TheHandle,
IN CONST CHAR8 *Language,
IN CONST CHAR16 *Separator,
IN CONST BOOLEAN Verbose,
IN CONST BOOLEAN ExtraInfo
)
{
EFI_GUID **ProtocolGuidArray;
UINTN ArrayCount;
UINTN ProtocolIndex;
EFI_STATUS Status;
CHAR16 *RetVal;
UINTN Size;
CHAR16 *Temp;
CHAR16 GuidStr[40];
VOID *Instance;
CHAR16 InstanceStr[17];
ProtocolGuidArray = NULL;
RetVal = NULL;
Size = 0;
Status = gBS->ProtocolsPerHandle (
TheHandle,
&ProtocolGuidArray,
&ArrayCount
);
if (!EFI_ERROR (Status)) {
for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
if (Size != 0) {
StrnCatGrow(&RetVal, &Size, Separator, 0);
}
StrnCatGrow(&RetVal, &Size, L"%H", 0);
if (Temp == NULL) {
UnicodeSPrint (GuidStr, sizeof (GuidStr), L"%g", ProtocolGuidArray[ProtocolIndex]);
StrnCatGrow (&RetVal, &Size, GuidStr, 0);
} else {
StrnCatGrow(&RetVal, &Size, Temp, 0);
FreePool(Temp);
}
StrnCatGrow(&RetVal, &Size, L"%N", 0);
if(Verbose) {
Status = gBS->HandleProtocol (TheHandle, ProtocolGuidArray[ProtocolIndex], &Instance);
if (!EFI_ERROR (Status)) {
StrnCatGrow (&RetVal, &Size, L"(%H", 0);
UnicodeSPrint (InstanceStr, sizeof (InstanceStr), L"%x", Instance);
StrnCatGrow (&RetVal, &Size, InstanceStr, 0);
StrnCatGrow (&RetVal, &Size, L"%N)", 0);
}
}
if (ExtraInfo) {
Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
if (Temp != NULL) {
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
if (!Verbose) {
StrnCatGrow(&RetVal, &Size, L"(", 0);
StrnCatGrow(&RetVal, &Size, Temp, 0);
StrnCatGrow(&RetVal, &Size, L")", 0);
} else {
StrnCatGrow(&RetVal, &Size, Separator, 0);
StrnCatGrow(&RetVal, &Size, Temp, 0);
}
FreePool(Temp);
}
}
}
}
SHELL_FREE_NON_NULL(ProtocolGuidArray);
if (RetVal == NULL) {
return (NULL);
}
ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));
StrnCatGrow(&RetVal, &Size, Separator, 0);
return (RetVal);
}
/**
Gets the name of the loaded image.
@param[in] TheHandle The handle of the driver to get info on.
@param[out] Name The pointer to the pointer. Valid upon a successful return.
@retval EFI_SUCCESS The operation was successful.
**/
EFI_STATUS
GetDriverImageName (
IN EFI_HANDLE TheHandle,
OUT CHAR16 **Name
)
{
// get loaded image and devicepathtotext on image->Filepath
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
if (TheHandle == NULL || Name == NULL) {
return (EFI_INVALID_PARAMETER);
}
Status = gBS->OpenProtocol (
TheHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **) &LoadedImage,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR(Status)) {
return (Status);
}
DevicePath = LoadedImage->FilePath;
*Name = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
return (EFI_SUCCESS);
}
/**
Display driver model information for a given handle.
@param[in] Handle The handle to display info on.
@param[in] BestName Use the best name?
@param[in] Language The language to output in.
**/
EFI_STATUS
DisplayDriverModelHandle (
IN EFI_HANDLE Handle,
IN BOOLEAN BestName,
IN CONST CHAR8 *Language OPTIONAL
)
{
EFI_STATUS Status;
BOOLEAN ConfigurationStatus;
BOOLEAN DiagnosticsStatus;
UINTN DriverBindingHandleCount;
EFI_HANDLE *DriverBindingHandleBuffer;
UINTN ParentControllerHandleCount;
EFI_HANDLE *ParentControllerHandleBuffer;
UINTN ChildControllerHandleCount;
EFI_HANDLE *ChildControllerHandleBuffer;
CHAR16 *TempStringPointer;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN Index;
CHAR16 *DriverName;
EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
UINTN NumberOfChildren;
UINTN HandleIndex;
UINTN ControllerHandleCount;
EFI_HANDLE *ControllerHandleBuffer;
UINTN ChildIndex;
BOOLEAN Image;
DriverName = NULL;
//
// See if Handle is a device handle and display its details.
//
DriverBindingHandleBuffer = NULL;
Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
Handle,
&DriverBindingHandleCount,
&DriverBindingHandleBuffer
);
ParentControllerHandleBuffer = NULL;
Status = PARSE_HANDLE_DATABASE_PARENTS (
Handle,
&ParentControllerHandleCount,
&ParentControllerHandleBuffer
);
ChildControllerHandleBuffer = NULL;
Status = ParseHandleDatabaseForChildControllers (
Handle,
&ChildControllerHandleCount,
&ChildControllerHandleBuffer
);
DiagnosticsStatus = FALSE;
ConfigurationStatus = FALSE;
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
ConfigurationStatus = TRUE;
}
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
ConfigurationStatus = TRUE;
}
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
DiagnosticsStatus = TRUE;
}
if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
DiagnosticsStatus = TRUE;
}
Status = EFI_SUCCESS;
if (DriverBindingHandleCount > 0 || ParentControllerHandleCount > 0 || ChildControllerHandleCount > 0) {
DevicePath = NULL;
TempStringPointer = NULL;
Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
Status = gEfiShellProtocol->GetDeviceName(Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer!=NULL?TempStringPointer:L"<Unknown>");
SHELL_FREE_NON_NULL(TempStringPointer);
TempStringPointer = ConvertDevicePathToText(DevicePath, TRUE, FALSE);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),
gShellDriver1HiiHandle,
TempStringPointer!=NULL?TempStringPointer:L"<None>",
ParentControllerHandleCount == 0?L"ROOT":(ChildControllerHandleCount > 0)?L"BUS":L"DEVICE",
ConfigurationStatus?L"YES":L"NO",
DiagnosticsStatus?L"YES":L"NO"
);
SHELL_FREE_NON_NULL(TempStringPointer);
if (DriverBindingHandleCount == 0) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
gShellDriver1HiiHandle,
L"<None>"
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
gShellDriver1HiiHandle,
L""
);
for (Index = 0; Index < DriverBindingHandleCount; Index++) {
Image = FALSE;
Status = GetDriverName (
DriverBindingHandleBuffer[Index],
Language,
&DriverName
);
if (EFI_ERROR (Status)) {
Status = GetDriverImageName (
DriverBindingHandleBuffer[Index],
&DriverName
);
if (EFI_ERROR (Status)) {
DriverName = NULL;
}
}
if (Image) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
DriverName!=NULL?DriverName:L"<Unknown>"
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
DriverName!=NULL?DriverName:L"<Unknown>"
);
}
SHELL_FREE_NON_NULL(DriverName);
}
}
if (ParentControllerHandleCount == 0) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
gShellDriver1HiiHandle,
L"<None>"
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
gShellDriver1HiiHandle,
L""
);
for (Index = 0; Index < ParentControllerHandleCount; Index++) {
Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
);
SHELL_FREE_NON_NULL(TempStringPointer);
}
}
if (ChildControllerHandleCount == 0) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
gShellDriver1HiiHandle,
L"<None>"
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
gShellDriver1HiiHandle,
L""
);
for (Index = 0; Index < ChildControllerHandleCount; Index++) {
Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
);
SHELL_FREE_NON_NULL(TempStringPointer);
}
}
}
SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
if (EFI_ERROR (Status)) {
return Status;
}
//
// See if Handle is a driver binding handle and display its details.
//
Status = gBS->OpenProtocol (
Handle,
&gEfiDriverBindingProtocolGuid,
(VOID **) &DriverBinding,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return EFI_SUCCESS;
}
NumberOfChildren = 0;
ControllerHandleBuffer = NULL;
Status = PARSE_HANDLE_DATABASE_DEVICES (
Handle,
&ControllerHandleCount,
&ControllerHandleBuffer
);
if (ControllerHandleCount > 0) {
for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
Handle,
ControllerHandleBuffer[HandleIndex],
&ChildControllerHandleCount,
NULL
);
NumberOfChildren += ChildControllerHandleCount;
}
}
Status = GetDriverName (Handle, Language, &DriverName);
if (EFI_ERROR (Status)) {
DriverName = NULL;
}
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER7),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(Handle),
DriverName!=NULL?DriverName:L"<Unknown>"
);
SHELL_FREE_NON_NULL(DriverName);
Status = GetDriverImageName (
Handle,
&DriverName
);
if (EFI_ERROR (Status)) {
DriverName = NULL;
}
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
gShellDriver1HiiHandle,
DriverName!=NULL?DriverName:L"<Unknown>"
);
SHELL_FREE_NON_NULL(DriverName);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
gShellDriver1HiiHandle,
DriverBinding->Version,
NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
ConfigurationStatus?L"YES":L"NO",
DiagnosticsStatus?L"YES":L"NO"
);
if (ControllerHandleCount == 0) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),
gShellDriver1HiiHandle,
L"None"
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9),
gShellDriver1HiiHandle,
L""
);
for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
);
SHELL_FREE_NON_NULL(TempStringPointer);
Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
Handle,
ControllerHandleBuffer[HandleIndex],
&ChildControllerHandleCount,
&ChildControllerHandleBuffer
);
if (!EFI_ERROR (Status)) {
for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_DRIVER6C),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
);
SHELL_FREE_NON_NULL(TempStringPointer);
}
SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
}
}
SHELL_FREE_NON_NULL (ControllerHandleBuffer);
}
return EFI_SUCCESS;
}
/**
Display information for a handle.
@param[in] TheHandle The handles to show info on.
@param[in] Verbose TRUE for extra info, FALSE otherwise.
@param[in] Sfo TRUE to output in standard format output (spec).
@param[in] Language Language string per UEFI specification.
@param[in] DriverInfo TRUE to show all info about the handle.
@param[in] Multiple TRUE indicates more than will be output,
FALSE for a single one.
**/
VOID
DoDhByHandle(
IN CONST EFI_HANDLE TheHandle,
IN CONST BOOLEAN Verbose,
IN CONST BOOLEAN Sfo,
IN CONST CHAR8 *Language,
IN CONST BOOLEAN DriverInfo,
IN CONST BOOLEAN Multiple
)
{
CHAR16 *ProtocolInfoString;
ProtocolInfoString = NULL;
if (!Sfo) {
if (Multiple) {
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(TheHandle),
ProtocolInfoString==NULL?L"":ProtocolInfoString
);
} else {
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, Verbose ? L"\r\n" : L" ", Verbose, TRUE);
if (Verbose) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(TheHandle),
TheHandle,
ProtocolInfoString==NULL?L"":ProtocolInfoString
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_SINGLE_D),
gShellDriver1HiiHandle,
ConvertHandleToHandleIndex(TheHandle),
ProtocolInfoString==NULL?L"":ProtocolInfoString
);
}
}
if (DriverInfo) {
DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
}
} else {
ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DH_OUTPUT_SFO),
gShellDriver1HiiHandle,
Multiple ?L"HandlesInfo":L"HandleInfo",
L"DriverName",
L"ControllerName",
ConvertHandleToHandleIndex(TheHandle),
L"DevPath",
ProtocolInfoString==NULL?L"":ProtocolInfoString
);
}
if (ProtocolInfoString != NULL) {
FreePool(ProtocolInfoString);
}
}
/**
Display information for all handles on a list.
@param[in] HandleList The NULL-terminated list of handles.
@param[in] Verbose TRUE for extra info, FALSE otherwise.
@param[in] Sfo TRUE to output in standard format output (spec).
@param[in] Language Language string per UEFI specification.
@param[in] DriverInfo TRUE to show all info about the handle.
@retval SHELL_SUCCESS The operation was successful.
@retval SHELL_ABORTED The operation was aborted.
**/
SHELL_STATUS
DoDhForHandleList(
IN CONST EFI_HANDLE *HandleList,
IN CONST BOOLEAN Verbose,
IN CONST BOOLEAN Sfo,
IN CONST CHAR8 *Language,
IN CONST BOOLEAN DriverInfo
)
{
CONST EFI_HANDLE *HandleWalker;
SHELL_STATUS ShellStatus;
ShellStatus = SHELL_SUCCESS;
for (HandleWalker = HandleList; HandleWalker != NULL && *HandleWalker != NULL; HandleWalker++) {
DoDhByHandle (*HandleWalker, Verbose, Sfo, Language, DriverInfo, TRUE);
if (ShellGetExecutionBreakFlag ()) {
ShellStatus = SHELL_ABORTED;
break;
}
}
return (ShellStatus);
}
/**
Display information for a GUID of protocol.
@param[in] Guid The pointer to the name of the protocol.
@param[in] Verbose TRUE for extra info, FALSE otherwise.
@param[in] Sfo TRUE to output in standard format output (spec).
@param[in] Language Language string per UEFI specification.
@param[in] DriverInfo TRUE to show all info about the handle.
@retval SHELL_SUCCESS The operation was successful.
@retval SHELL_NOT_FOUND The GUID was not found.
@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
**/
SHELL_STATUS
DoDhByProtocolGuid(
IN CONST GUID *Guid,
IN CONST BOOLEAN Verbose,
IN CONST BOOLEAN Sfo,
IN CONST CHAR8 *Language,
IN CONST BOOLEAN DriverInfo
)
{
CHAR16 *Name;
SHELL_STATUS ShellStatus;
EFI_HANDLE *HandleList;
if (!Sfo) {
if (Guid == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_ALL_HEADER), gShellDriver1HiiHandle);
} else {
Name = GetStringNameFromGuid (Guid, NULL);
if (Name == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_GUID_HEADER), gShellDriver1HiiHandle, Guid);
} else {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_NAME_HEADER), gShellDriver1HiiHandle, Name);
}
}
}
HandleList = GetHandleListByProtocol(Guid);
ShellStatus = DoDhForHandleList(HandleList, Verbose, Sfo, Language, DriverInfo);
SHELL_FREE_NON_NULL(HandleList);
return ShellStatus;
}
/**
Function to determine use which method to print information.
If Protocol is NULL, The function will print all information.
@param[in] Protocol The pointer to the name or GUID of protocol or NULL.
@param[in] Verbose TRUE for extra info, FALSE otherwise.
@param[in] Sfo TRUE to output in standard format output (spec).
@param[in] Language Language string per UEFI specification.
@param[in] DriverInfo TRUE to show all info about the handle.
@retval SHELL_SUCCESS The operation was successful.
@retval SHELL_NOT_FOUND The protocol was not found.
@retval SHELL_INVALID_PARAMETER Protocol is invalid parameter.
**/
SHELL_STATUS
DoDhByProtocol (
IN CONST CHAR16 *Protocol,
IN CONST BOOLEAN Verbose,
IN CONST BOOLEAN Sfo,
IN CONST CHAR8 *Language,
IN CONST BOOLEAN DriverInfo
)
{
EFI_GUID Guid;
EFI_GUID *GuidPtr;
EFI_STATUS Status;
if (Protocol == NULL) {
return DoDhByProtocolGuid (NULL, Verbose, Sfo, Language, DriverInfo);
} else {
Status = ConvertStrToGuid (Protocol, &Guid);
if (!EFI_ERROR (Status)) {
GuidPtr = &Guid;
} else {
//
// Protocol is a Name, convert it to GUID
//
Status = GetGuidFromStringName (Protocol, Language, &GuidPtr);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);
return (SHELL_NOT_FOUND);
}
}
return DoDhByProtocolGuid (GuidPtr, Verbose, Sfo, Language, DriverInfo);
}
}
/**
Function to display decode information by Protocol.
The parameter Protocol is either a GUID or the name of protocol.
If the parameter Protocol is NULL, the function will print all
decode information.
@param[in] Protocol The pointer to the name or GUID of protocol.
@param[in] Language Language string per UEFI specification.
@retval SHELL_SUCCESS The operation was successful.
@retval SHELL_OUT_OT_RESOURCES A memory allocation failed.
**/
SHELL_STATUS
DoDecodeByProtocol(
IN CONST CHAR16 *Protocol,
IN CONST CHAR8 *Language
)
{
EFI_STATUS Status;
EFI_GUID *Guids;
EFI_GUID Guid;
UINTN Counts;
UINTN Index;
CHAR16 *Name;
if (Protocol == NULL) {
Counts = 0;
Status = GetAllMappingGuids (NULL, &Counts);
if (Status == EFI_BUFFER_TOO_SMALL) {
Guids = AllocatePool (Counts * sizeof(EFI_GUID));
if (Guids == NULL) {
return SHELL_OUT_OF_RESOURCES;
}
Status = GetAllMappingGuids (Guids, &Counts);
if (Status == EFI_SUCCESS) {
for (Index = 0; Index < Counts; Index++) {
Name = GetStringNameFromGuid (&Guids[Index], Language);
if (Name != NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guids[Index]);
} else {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guids[Index]);
}
SHELL_FREE_NON_NULL (Name);
}
}
FreePool (Guids);
}
} else {
if (ConvertStrToGuid (Protocol, &Guid) == EFI_SUCCESS) {
Name = GetStringNameFromGuid (&Guid, Language);
if (Name != NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Name, &Guid);
} else {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, &Guid);
}
SHELL_FREE_NON_NULL(Name);
} else {
Status = GetGuidFromStringName (Protocol, Language, &Guids);
if (Status == EFI_SUCCESS) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DECODE), gShellDriver1HiiHandle, Protocol, Guids);
} else {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DH_NO_NAME_FOUND), gShellDriver1HiiHandle, Protocol);
}
}
}
return SHELL_SUCCESS;
}
/**
Function for 'dh' command.
@param[in] ImageHandle Handle to the Image (NULL if Internal).
@param[in] SystemTable Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunDh (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CHAR8 *Language;
CONST CHAR16 *Lang;
CONST CHAR16 *RawValue;
CONST CHAR16 *ProtocolVal;
BOOLEAN SfoFlag;
BOOLEAN DriverFlag;
BOOLEAN VerboseFlag;
UINT64 Intermediate;
EFI_HANDLE Handle;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
Language = NULL;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
Status = CommandInit();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR(Status)) {
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"dh", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) > 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
ShellCommandLineFreeVarList (Package);
return (SHELL_INVALID_PARAMETER);
}
if (ShellCommandLineGetFlag(Package, L"-l")) {
Lang = ShellCommandLineGetValue(Package, L"-l");
if (Lang != NULL) {
Language = AllocateZeroPool(StrSize(Lang));
AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
} else {
ASSERT(Language == NULL);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-l");
ShellCommandLineFreeVarList(Package);
return (SHELL_INVALID_PARAMETER);
}
} else {
Language = AllocateZeroPool(10);
AsciiSPrint(Language, 10, "en-us");
}
SfoFlag = ShellCommandLineGetFlag (Package, L"-sfo");
DriverFlag = ShellCommandLineGetFlag (Package, L"-d");
VerboseFlag = (BOOLEAN)(ShellCommandLineGetFlag (Package, L"-v") || ShellCommandLineGetFlag (Package, L"-verbose"));
RawValue = ShellCommandLineGetRawValue (Package, 1);
ProtocolVal = ShellCommandLineGetValue (Package, L"-p");
if (RawValue == NULL) {
if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// Print information by protocol, The ProtocolVal maybe is name or GUID or NULL.
//
ShellStatus = DoDhByProtocol (ProtocolVal, VerboseFlag, SfoFlag, Language, DriverFlag);
}
} else if ((RawValue != NULL) &&
(gUnicodeCollation->StriColl(gUnicodeCollation, L"decode", (CHAR16 *) RawValue) == 0)) {
if (ShellCommandLineGetFlag (Package, L"-p") && (ProtocolVal == NULL)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"dh", L"-p");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// Print decode informatino by protocol.
//
ShellStatus = DoDecodeByProtocol (ProtocolVal, Language);
}
} else {
if (ShellCommandLineGetFlag (Package, L"-p")) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"dh");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Status = ShellConvertStringToUint64 (RawValue, &Intermediate, TRUE, FALSE);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Handle = ConvertHandleIndexToHandle ((UINTN) Intermediate);
if (Handle == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"dh", RawValue);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// Print information by handle.
//
DoDhByHandle (Handle, VerboseFlag, SfoFlag, Language, DriverFlag, FALSE);
}
}
}
}
ShellCommandLineFreeVarList (Package);
SHELL_FREE_NON_NULL(Language);
}
return (ShellStatus);
}
Reference in New Issue View Git Blame Copy Permalink