IDontCode
/
Voyager
2
2
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '40090957c4'
${ noResults }
Voyager/Voyager 1/edk2/ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

1198 lines
36 KiB
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>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#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