sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ea628f28e59849ee7b91e6660c0ecd1a5c6e0884
system76-edk2/ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c
Michael D Kinney e4c1d8d231 ShellPkg/Library: Fix 32-bit truncation of pointer values 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=4366

Update C and UNI files that are incorrectly using %x or %08x
instead of %p for pointer values.  On 64-bit systems, this is
truncating pointer values above 4GB.

In reviewing ShellPkg for this issue some unused UNI strings
with incorrect format specifiers were removed instead of being
fixed.

Cc: Ray Ni <ray.ni@intel.com>
Cc: Zhichao Gao <zhichao.gao@intel.com>
Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
Reviewed-by: Ray Ni <ray.ni@intel.com>
2023-03-13 22:11:55 +00:00

1215 lines
38 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"%p", 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