/**
Clear the line at the specified Row.
@param[in] Row The row number to be cleared ( start from 1 )
@param[in] LastCol The last printable column.
@param[in] LastRow The last printable row.
**/
VOID
EFIAPI
EditorClearLine (
IN UINTN Row,
IN UINTN LastCol,
IN UINTN LastRow
)
{
CHAR16 Line[200];
if (Row == 0) {
Row = 1;
}
//
// prepare a blank line
//
SetMem16(Line, LastCol*sizeof(CHAR16), L' ');
if (Row == LastRow) {
//
// if CHAR_NULL is still at position 80, it will cause first line error
//
Line[LastCol - 1] = CHAR_NULL;
} else {
Line[LastCol] = CHAR_NULL;
}
//
// print out the blank line
//
ShellPrintEx (0, ((INT32)Row) - 1, Line);
}
/**
Display the prompt.
Do the requesting of input.
@param[in] LastColumn The last printable column.
@param[in] LastRow The last printable row.
**/
VOID
EFIAPI
InputBarPrintInput (
IN UINTN LastColumn,
IN UINTN LastRow
)
{
UINTN Limit;
UINTN Size;
CHAR16 *Buffer;
UINTN Index;
UINTN mPromptLen;
mPromptLen = StrLen (mPrompt);
Limit = LastColumn - mPromptLen - 1;
Size = StrLen (mReturnString);
//
// check whether the mPrompt length and input length will
// exceed limit
//
if (Size <= Limit) {
Buffer = mReturnString;
} else {
Buffer = mReturnString + Size - Limit;
}
gST->ConOut->EnableCursor (gST->ConOut, FALSE);
ShellPrintEx (((INT32)mPromptLen), ((INT32)LastRow) - 1, L"%s", Buffer);
Size = StrLen (Buffer);
//
// print " " after mPrompt
//
for (Index = Size; Index < Limit; Index++) {
ShellPrintEx ((INT32)(mPromptLen + Size), ((INT32)LastRow) - 1, L" ");
}
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
gST->ConOut->SetCursorPosition (gST->ConOut, Size + mPromptLen, LastRow - 1);
}
/**
Refresh function for the menu bar.
@param[in] LastRow The last printable row.
@param[in] LastCol The last printable column.
@retval EFI_SUCCESS The refresh was successful.
**/
EFI_STATUS
EFIAPI
MenuBarRefresh (
IN CONST UINTN LastRow,
IN CONST UINTN LastCol
)
{
EDITOR_MENU_ITEM *Item;
UINTN Col;
UINTN Row;
UINTN Width;
CHAR16 *NameString;
CHAR16 *FunctionKeyString;
//
// variable initialization
//
Col = 1;
Row = (LastRow - 2);
//
// clear menu bar rows
//
EditorClearLine (LastRow - 2, LastCol, LastRow);
EditorClearLine (LastRow - 1, LastCol, LastRow);
EditorClearLine (LastRow , LastCol, LastRow);
//
// print out the menu items
//
for (Item = MenuItems; Item != NULL && Item->Function != NULL; Item++) {
NameString = HiiGetString(gShellDebug1HiiHandle, Item->NameToken, NULL);
Width = MAX ((StrLen (NameString) + 6), 20);
if (((Col + Width) > LastCol)) {
Row++;
Col = 1;
}
FunctionKeyString = HiiGetString(gShellDebug1HiiHandle, Item->FunctionKeyToken, NULL);
ShellPrintEx ((INT32)(Col) - 1, (INT32)(Row) - 1, L"%E%s%N %H%s%N ", FunctionKeyString, NameString);
FreePool (NameString);
FreePool (FunctionKeyString);
Col += Width;
}
return EFI_SUCCESS;
}
/**
Function to dump LoadedImage info from TheHandle.
@param[in] TheHandle The handle to dump info from.
@retval EFI_SUCCESS The info was dumped.
@retval EFI_INVALID_PARAMETER The handle did not have LoadedImage
**/
EFI_STATUS
EFIAPI
DumpLoadedImageProtocolInfo (
IN EFI_HANDLE TheHandle
)
{
CHAR16 *TheString;
TheString = GetProtocolInformationDump(TheHandle, &gEfiLoadedImageProtocolGuid, TRUE);
ShellPrintEx(-1, -1, L"%s", TheString);
SHELL_FREE_NON_NULL(TheString);
return (EFI_SUCCESS);
}
/**
Dump some hexadecimal data to the screen.
@param[in] Indent How many spaces to indent the output.
@param[in] Offset The offset of the printing.
@param[in] DataSize The size in bytes of UserData.
@param[in] UserData The data to print out.
**/
VOID
DumpHex (
IN UINTN Indent,
IN UINTN Offset,
IN UINTN DataSize,
IN VOID *UserData
)
{
UINT8 *Data;
CHAR8 Val[50];
CHAR8 Str[20];
UINT8 TempByte;
UINTN Size;
UINTN Index;
Data = UserData;
while (DataSize != 0) {
Size = 16;
if (Size > DataSize) {
Size = DataSize;
}
for (Index = 0; Index < Size; Index += 1) {
TempByte = Data[Index];
Val[Index * 3 + 0] = Hex[TempByte >> 4];
Val[Index * 3 + 1] = Hex[TempByte & 0xF];
Val[Index * 3 + 2] = (CHAR8) ((Index == 7) ? '-' : ' ');
Str[Index] = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
}
Val[Index * 3] = 0;
Str[Index] = 0;
ShellPrintEx(-1, -1, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
Data += Size;
Offset += Size;
DataSize -= Size;
}
}
/**
Clear the line at the specified Row.
@param[in] Row The row number to be cleared ( start from 1 )
@param[in] LastCol The last printable column.
@param[in] LastRow The last printable row.
**/
VOID
EditorClearLine (
IN UINTN Row,
IN UINTN LastCol,
IN UINTN LastRow
)
{
UINTN Col;
CHAR16 Line[200];
if (Row == 0) {
Row = 1;
}
//
// prepare a blank line
// If max column is larger, split to multiple prints.
//
SetMem16 (Line, sizeof (Line), L' ');
Line[ARRAY_SIZE (Line) - 1] = CHAR_NULL;
for (Col = 1; Col <= LastCol; Col += ARRAY_SIZE (Line) - 1) {
if (Col + ARRAY_SIZE (Line) - 1 > LastCol) {
if (Row == LastRow) {
//
// if CHAR_NULL is still at position LastCol, it will cause first line error
//
Line[(LastCol - 1) % (ARRAY_SIZE (Line) - 1)] = CHAR_NULL;
} else {
Line[LastCol % (ARRAY_SIZE (Line) - 1)] = CHAR_NULL;
}
}
//
// print out the blank line
//
ShellPrintEx ((INT32) Col - 1, (INT32) Row - 1, Line);
}
}
/**
Function to print differnt point data.
@param[in] FileName File name.
@param[in] FileTag File tag name.
@param[in] Buffer Data buffer to be printed.
@param[in] BufferSize Size of the data to be printed.
@param[in] Address Address of the differnt point.
@param[in] DifferentBytes Total size of the buffer.
**/
VOID
PrintDifferentPoint(
CONST CHAR16 *FileName,
CHAR16 *FileTag,
UINT8 *Buffer,
UINT64 BufferSize,
UINTN Address,
UINT64 DifferentBytes
)
{
UINTN Index;
ShellPrintEx (-1, -1, L"%s: %s\r\n %08x:", FileTag, FileName, Address);
//
// Print data in hex-format.
//
for (Index = 0; Index < BufferSize; Index++) {
ShellPrintEx (-1, -1, L" %02x", Buffer[Index]);
}
if (BufferSize < DifferentBytes) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_COMP_END_OF_FILE), gShellDebug1HiiHandle);
}
ShellPrintEx (-1, -1, L" *");
//
// Print data in char-format.
//
for (Index = 0; Index < BufferSize; Index++) {
if (Buffer[Index] >= 0x20 && Buffer[Index] <= 0x7E) {
ShellPrintEx (-1, -1, L"%c", Buffer[Index]);
} else {
//
// Print dots for control characters
//
ShellPrintEx (-1, -1, L".");
}
}
ShellPrintEx (-1, -1, L"*\r\n");
}
/**
Display blocks to the screen.
@param[in] DevPath The device path to get the blocks from.
@param[in] Lba The Lba number to start from.
@param[in] BlockCount How many blocks to display.
@retval SHELL_SUCCESS The display was successful.
**/
SHELL_STATUS
EFIAPI
DisplayTheBlocks(
IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,
IN CONST UINT64 Lba,
IN CONST UINT8 BlockCount
)
{
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_HANDLE BlockIoHandle;
EFI_STATUS Status;
SHELL_STATUS ShellStatus;
UINT8 *Buffer;
UINTN BufferSize;
ShellStatus = SHELL_SUCCESS;
Status = gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, (EFI_DEVICE_PATH_PROTOCOL **)&DevPath, &BlockIoHandle);
if (EFI_ERROR(Status)) {
return (SHELL_NOT_FOUND);
}
Status = gBS->OpenProtocol(BlockIoHandle, &gEfiBlockIoProtocolGuid, (VOID**)&BlockIo, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (EFI_ERROR(Status)) {
return (SHELL_NOT_FOUND);
}
BufferSize = BlockIo->Media->BlockSize * BlockCount;
if (BufferSize > 0) {
Buffer = AllocateZeroPool(BufferSize);
} else {
ShellPrintEx(-1,-1,L" BlockSize: 0x%08x, BlockCount: 0x%08x\r\n", BlockIo->Media->BlockSize, BlockCount);
Buffer = NULL;
}
Status = BlockIo->ReadBlocks(BlockIo, BlockIo->Media->MediaId, Lba, BufferSize, Buffer);
if (!EFI_ERROR(Status) && Buffer != NULL) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DBLK_HEADER),
gShellDebug1HiiHandle,
Lba,
BufferSize,
BlockIo
);
DumpHex(2,0,BufferSize,Buffer);
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_READ_FAIL), gShellDebug1HiiHandle, L"BlockIo", Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
if (Buffer != NULL) {
FreePool(Buffer);
}
gBS->CloseProtocol(BlockIoHandle, &gEfiBlockIoProtocolGuid, gImageHandle, NULL);
return (ShellStatus);
}
/**
Update the progress of a file download
This procedure is called each time a new TFTP packet is received.
@param[in] This MTFTP4 protocol interface
@param[in] Token Parameters for the download of the file
@param[in] PacketLen Length of the packet
@param[in] Packet Address of the packet
@retval EFI_SUCCESS All packets are accepted.
**/
STATIC
EFI_STATUS
EFIAPI
CheckPacket (
IN EFI_MTFTP4_PROTOCOL *This,
IN EFI_MTFTP4_TOKEN *Token,
IN UINT16 PacketLen,
IN EFI_MTFTP4_PACKET *Packet
)
{
DOWNLOAD_CONTEXT *Context;
CHAR16 Progress[TFTP_PROGRESS_MESSAGE_SIZE];
UINTN NbOfKb;
UINTN Index;
UINTN LastStep;
UINTN Step;
EFI_STATUS Status;
if ((NTOHS (Packet->OpCode)) != EFI_MTFTP4_OPCODE_DATA) {
return EFI_SUCCESS;
}
Context = (DOWNLOAD_CONTEXT*)Token->Context;
if (Context->DownloadedNbOfBytes == 0) {
ShellPrintEx (-1, -1, L"%s 0 Kb", mTftpProgressFrame);
}
//
// The data in the packet are prepended with two UINT16 :
// . OpCode = EFI_MTFTP4_OPCODE_DATA
// . Block = the number of this block of data
//
Context->DownloadedNbOfBytes += PacketLen - sizeof (Packet->OpCode)
- sizeof (Packet->Data.Block);
NbOfKb = Context->DownloadedNbOfBytes / 1024;
Progress[0] = L'\0';
LastStep = (Context->LastReportedNbOfBytes * TFTP_PROGRESS_SLIDER_STEPS) / Context->FileSize;
Step = (Context->DownloadedNbOfBytes * TFTP_PROGRESS_SLIDER_STEPS) / Context->FileSize;
if (Step <= LastStep) {
return EFI_SUCCESS;
}
ShellPrintEx (-1, -1, L"%s", mTftpProgressDelete);
Status = StrCpyS (Progress, TFTP_PROGRESS_MESSAGE_SIZE, mTftpProgressFrame);
if (EFI_ERROR(Status)) {
return Status;
}
for (Index = 1; Index < Step; Index++) {
Progress[Index] = L'=';
}
Progress[Step] = L'>';
UnicodeSPrint (
Progress + (sizeof (mTftpProgressFrame) / sizeof (CHAR16)) - 1,
sizeof (Progress) - sizeof (mTftpProgressFrame),
L" %7d Kb",
NbOfKb
);
Context->LastReportedNbOfBytes = Context->DownloadedNbOfBytes;
ShellPrintEx (-1, -1, L"%s", Progress);
return EFI_SUCCESS;
}
/**
Function for 'setvar' 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
ShellCommandRunSetVar (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *VariableName;
CONST CHAR16 *Data;
EFI_GUID Guid;
CONST CHAR16 *StringGuid;
UINT32 Attributes;
UINT32 Attributes2;
VOID *Buffer;
UINTN Size;
UINTN LoopVar;
EFI_DEVICE_PATH_PROTOCOL *DevPath;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
Buffer = NULL;
Size = 0;
Attributes = 0;
DevPath = 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), gShellDebug1HiiHandle, ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) < 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetCount(Package) > 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
VariableName = ShellCommandLineGetRawValue(Package, 1);
Data = ShellCommandLineGetRawValue(Package, 2);
if (!ShellCommandLineGetFlag(Package, L"-guid")){
CopyGuid(&Guid, &gEfiGlobalVariableGuid);
} else {
StringGuid = ShellCommandLineGetValue(Package, L"-guid");
Status = ConvertStringToGuid(StringGuid, &Guid);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, StringGuid);
ShellStatus = SHELL_INVALID_PARAMETER;
}
}
if (Data == NULL) {
//
// Display what's there
//
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
}
if (!EFI_ERROR(Status)&& Buffer != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_PRINT), gShellDebug1HiiHandle, &Guid, VariableName, Size);
for (LoopVar = 0 ; LoopVar < Size ; LoopVar++) {
ShellPrintEx(-1, -1, L"%02x ", ((UINT8*)Buffer)[LoopVar]);
}
ShellPrintEx(-1, -1, L"\r\n");
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_GET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
}
} else if (StrCmp(Data, L"=") == 0) {
//
// Delete what's there!
//
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, 0, NULL);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
} else {
if (Data[0] == L'=') {
Data++;
}
//
// Change what's there
//
if (ShellCommandLineGetFlag(Package, L"-bs")) {
Attributes |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-rt")) {
Attributes |= EFI_VARIABLE_RUNTIME_ACCESS |
EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-nv")) {
Attributes |= EFI_VARIABLE_NON_VOLATILE;
}
if (ShellIsHexOrDecimalNumber(Data, TRUE, FALSE)) {
if (StrLen(Data) % 2 != 0) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellDebug1HiiHandle, Data);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// arbitrary buffer
//
Buffer = AllocateZeroPool((StrLen(Data) / 2));
if (Buffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
for (LoopVar = 0 ; LoopVar < (StrLen(Data) / 2) ; LoopVar++) {
((UINT8*)Buffer)[LoopVar] = (UINT8)(HexCharToUintn(Data[LoopVar*2]) * 16);
((UINT8*)Buffer)[LoopVar] = (UINT8)(((UINT8*)Buffer)[LoopVar] + HexCharToUintn(Data[LoopVar*2+1]));
}
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, StrLen(Data) / 2, Buffer);
}
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
}
} else if (StrnCmp(Data, L"\"", 1) == 0) {
Size = 0;
Attributes2 = 0;
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes2, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes2, &Size, Buffer);
if (Buffer != NULL) {
FreePool(Buffer);
}
Attributes = Attributes2;
}
//
// ascii text
//
Data++;
Buffer = AllocateZeroPool(StrSize(Data) / 2);
if (Buffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
AsciiSPrint(Buffer, StrSize(Data) / 2, "%s", Data);
((CHAR8*)Buffer)[AsciiStrLen(Buffer)-1] = CHAR_NULL;
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, AsciiStrSize(Buffer)-sizeof(CHAR8), Buffer);
}
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
} else if (StrnCmp(Data, L"L\"", 2) == 0) {
//
// ucs2 text
//
Data++;
Data++;
Buffer = AllocateZeroPool(StrSize(Data));
if (Buffer == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle);
ShellStatus = SHELL_OUT_OF_RESOURCES;
} else {
UnicodeSPrint(Buffer, StrSize(Data), L"%s", Data);
((CHAR16*)Buffer)[StrLen(Buffer)-1] = CHAR_NULL;
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, StrSize(Buffer)-sizeof(CHAR16), Buffer);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
}
} else if (StrnCmp(Data, L"--", 2) == 0) {
//
// device path in text format
//
Data++;
Data++;
DevPath = ConvertTextToDevicePath(Data);
if (DevPath == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, Status);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, GetDevicePathSize(DevPath), DevPath);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, &Guid, VariableName, Status);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
}
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Data);
ShellStatus = SHELL_INVALID_PARAMETER;
}
}
}
ShellCommandLineFreeVarList (Package);
}
if (Buffer != NULL) {
FreePool(Buffer);
}
if (DevPath != NULL) {
FreePool(DevPath);
}
return (ShellStatus);
}
/**
function to take a list of files to copy and a destination location and do
the verification and copying of those files to that location. This function
will report any errors to the user and halt.
The key is to have this function called ONLY once. this allows for the parameter
verification to happen correctly.
@param[in] FileList A LIST_ENTRY* based list of files to move.
@param[in] DestDir The destination location.
@param[in] SilentMode TRUE to eliminate screen output.
@param[in] RecursiveMode TRUE to copy directories.
@param[in] Resp The response to the overwrite query (if always).
@retval SHELL_SUCCESS the files were all moved.
@retval SHELL_INVALID_PARAMETER a parameter was invalid
@retval SHELL_SECURITY_VIOLATION a security violation ocurred
@retval SHELL_WRITE_PROTECTED the destination was write protected
@retval SHELL_OUT_OF_RESOURCES a memory allocation failed
**/
SHELL_STATUS
EFIAPI
ValidateAndCopyFiles(
IN CONST EFI_SHELL_FILE_INFO *FileList,
IN CONST CHAR16 *DestDir,
IN BOOLEAN SilentMode,
IN BOOLEAN RecursiveMode,
IN VOID **Resp
)
{
CHAR16 *HiiOutput;
CHAR16 *HiiResultOk;
CONST EFI_SHELL_FILE_INFO *Node;
SHELL_STATUS ShellStatus;
CHAR16 *DestPath;
VOID *Response;
UINTN PathLen;
CONST CHAR16 *Cwd;
CONST CHAR16 *TempLocation;
UINTN NewSize;
if (Resp == NULL) {
Response = NULL;
} else {
Response = *Resp;
}
DestPath = NULL;
ShellStatus = SHELL_SUCCESS;
PathLen = 0;
Cwd = ShellGetCurrentDir(NULL);
ASSERT(FileList != NULL);
ASSERT(DestDir != NULL);
//
// We already verified that this was present.
//
ASSERT(Cwd != NULL);
//
// If we are trying to copy multiple files... make sure we got a directory for the target...
//
if (EFI_ERROR(ShellIsDirectory(DestDir)) && FileList->Link.ForwardLink != FileList->Link.BackLink) {
//
// Error for destination not a directory
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
return (SHELL_INVALID_PARAMETER);
}
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
NewSize = StrSize(DestDir);
NewSize += StrSize(Node->FullName);
NewSize += StrSize(Cwd);
if (NewSize > PathLen) {
PathLen = NewSize;
}
//
// Make sure got -r if required
//
if (!RecursiveMode && !EFI_ERROR(ShellIsDirectory(Node->FullName))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_REQ), gShellLevel2HiiHandle);
return (SHELL_INVALID_PARAMETER);
}
//
// make sure got dest as dir if needed
//
if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(DestDir))) {
//
// Error for destination not a directory
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
return (SHELL_INVALID_PARAMETER);
}
}
HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_CP_OUTPUT), NULL);
HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
DestPath = AllocateZeroPool(PathLen);
if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) {
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
return (SHELL_OUT_OF_RESOURCES);
}
//
// Go through the list of files to copy...
//
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
if (ShellGetExecutionBreakFlag()) {
break;
}
ASSERT(Node->FileName != NULL);
ASSERT(Node->FullName != NULL);
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item
&& EFI_ERROR(ShellIsDirectory(DestDir)) // not an existing directory
) {
if (StrStr(DestDir, L":") == NULL) {
//
// simple copy of a single file
//
StrCpy(DestPath, Cwd);
if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, DestDir);
} else {
StrCpy(DestPath, DestDir);
}
} else {
//
// we have multiple files or a directory in the DestDir
//
//
// Check for leading slash
//
if (DestDir[0] == L'\\') {
//
// Copy to the root of CWD
//
StrCpy(DestPath, Cwd);
while (PathRemoveLastItem(DestPath));
StrCat(DestPath, DestDir+1);
StrCat(DestPath, Node->FileName);
} else if (StrStr(DestDir, L":") == NULL) {
StrCpy(DestPath, Cwd);
if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, DestDir);
if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, Node->FileName);
} else {
StrCpy(DestPath, DestDir);
if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
((CHAR16*)DestDir)[StrLen(DestDir)-1] = CHAR_NULL;
}
StrCat(DestPath, Node->FileName);
}
}
//
// Make sure the path exists
//
if (EFI_ERROR(VerifyIntermediateDirectories(DestPath))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_WNF), gShellLevel2HiiHandle);
ShellStatus = SHELL_DEVICE_ERROR;
break;
}
if ( !EFI_ERROR(ShellIsDirectory(Node->FullName))
&& !EFI_ERROR(ShellIsDirectory(DestPath))
&& StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
if (StringNoCaseCompare(&Node->FullName, &DestPath) == 0) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0
&& (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\')
) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
PathCleanUpDirectories(DestPath);
ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath);
//
// copy single file...
//
ShellStatus = CopySingleFile(Node->FullName, DestPath, &Response, SilentMode);
if (ShellStatus != SHELL_SUCCESS) {
break;
}
}
if (ShellStatus == SHELL_SUCCESS && Resp == NULL) {
ShellPrintEx(-1, -1, L"%s", HiiResultOk);
}
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
if (Resp == NULL) {
SHELL_FREE_NON_NULL(Response);
}
return (ShellStatus);
}
/**
Function to display the global mSmbios64BitStatisticsTable object.
@param[in] Option ECHO, NORMAL, or DETAIL control the amount of detail displayed.
@retval EFI_SUCCESS print is successful.
**/
EFI_STATUS
DisplaySmbios64BitStatisticsTable (
IN UINT8 Option
)
{
UINTN Index;
UINTN Num;
STRUCTURE_STATISTICS *StatisticsPointer;
SMBIOS_TABLE_3_0_ENTRY_POINT *SMBiosTable;
SMBiosTable = NULL;
if (Option < SHOW_OUTLINE) {
return EFI_SUCCESS;
}
//
// display EPS information firstly
//
LibSmbios64BitGetEPS (&SMBiosTable);
if (SMBiosTable == NULL) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_CANNOT_ACCESS_TABLE), gShellDebug1HiiHandle);
return EFI_UNSUPPORTED;
}
ShellPrintEx(-1,-1,L"\n============================================================\n");
Smbios64BitPrintEPSInfo (SMBiosTable, Option);
if (Option < SHOW_NORMAL) {
return EFI_SUCCESS;
}
if (mSmbios64BitStatisticsTable == NULL) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_CANNOT_ACCESS_STATS), gShellDebug1HiiHandle);
return EFI_NOT_FOUND;
}
ShellPrintEx(-1,-1,L"============================================================\n");
StatisticsPointer = &mSmbios64BitStatisticsTable[0];
Num = mNumberOfSmbios64BitStructures;
//
// display statistics table content
//
for (Index = 1; Index <= Num; Index++) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_INDEX), gShellDebug1HiiHandle, StatisticsPointer->Index);
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_TYPE), gShellDebug1HiiHandle, StatisticsPointer->Type);
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_HANDLE), gShellDebug1HiiHandle, StatisticsPointer->Handle);
if (Option >= SHOW_DETAIL) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_OFFSET), gShellDebug1HiiHandle, StatisticsPointer->Addr);
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_LENGTH), gShellDebug1HiiHandle, StatisticsPointer->Length);
}
ShellPrintEx(-1,-1,L"\n");
StatisticsPointer = &mSmbios64BitStatisticsTable[Index];
/*
//
// Display 20 lines and wait for a page break
//
if (Index % 20 == 0) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ENTER_CONTINUE), gShellDebug1HiiHandle);
Status = WaitEnter ();
if (EFI_ERROR (Status)) {
if (Status == EFI_ABORTED) {
return EFI_SUCCESS;
}
return Status;
}
}
*/
}
return EFI_SUCCESS;
}
/**
Query all structures Data from SMBIOS table and Display
the information to users as required display option.
@param[in] QueryType Structure type to view.
@param[in] QueryHandle Structure handle to view.
@param[in] Option Display option: none,outline,normal,detail.
@param[in] RandomView Support for -h parameter.
@retval EFI_SUCCESS print is successful.
@retval EFI_BAD_BUFFER_SIZE structure is out of the range of SMBIOS table.
**/
EFI_STATUS
SMBios64View (
IN UINT8 QueryType,
IN UINT16 QueryHandle,
IN UINT8 Option,
IN BOOLEAN RandomView
)
{
UINT16 Handle;
UINT8 *Buffer;
UINT16 Length;
UINTN Index;
SMBIOS_STRUCTURE_POINTER SmbiosStruct;
SMBIOS_TABLE_3_0_ENTRY_POINT *SMBiosTable;
SMBiosTable = NULL;
LibSmbios64BitGetEPS (&SMBiosTable);
if (SMBiosTable == NULL) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_CANNOT_ACCESS_TABLE), gShellDebug1HiiHandle);
return EFI_BAD_BUFFER_SIZE;
}
if (CompareMem (SMBiosTable->AnchorString, "_SM3_", 5) == 0) {
//
// Have got SMBIOS table
//
Smbios64BitPrintEPSInfo (SMBiosTable, Option);
SmbiosMajorVersion = SMBiosTable->MajorVersion;
SmbiosMinorVersion = SMBiosTable->MinorVersion;
ShellPrintEx(-1,-1,L"=========================================================\n");
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_QUERY_STRUCT_COND), gShellDebug1HiiHandle);
if (QueryType == STRUCTURE_TYPE_RANDOM) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_QUERYTYPE_RANDOM), gShellDebug1HiiHandle);
} else {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_QUERYTYPE), gShellDebug1HiiHandle, QueryType);
}
if (RandomView) {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_QUERYHANDLE_RANDOM), gShellDebug1HiiHandle);
} else {
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_QUERYHANDLE), gShellDebug1HiiHandle, QueryHandle);
}
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_SHOWTYPE), gShellDebug1HiiHandle);
ShellPrintEx(-1,-1,GetShowTypeString (gShowType));
ShellPrintEx(-1,-1,L"\n\n");
/*
//
// Get internal commands, such as change options.
//
Status = WaitEnter ();
if (EFI_ERROR (Status)) {
if (Status == EFI_ABORTED) {
return EFI_SUCCESS;
}
return Status;
}
*/
//
// Searching and display structure info
//
Handle = QueryHandle;
for (Index = 0; Index < mNumberOfSmbios64BitStructures; Index++) {
//
// if reach the end of table, break..
//
if (Handle == INVALID_HANDLE) {
break;
}
//
// handle then point to the next!
//
if (LibGetSmbios64BitStructure (&Handle, &Buffer, &Length) != DMI_SUCCESS) {
break;
}
SmbiosStruct.Raw = Buffer;
//
// if QueryType==Random, print this structure.
// if QueryType!=Random, but Hdr->Type==QueryType, also print it.
// only if QueryType != Random and Hdr->Type != QueryType, skiped it.
//
if (QueryType != STRUCTURE_TYPE_RANDOM && SmbiosStruct.Hdr->Type != QueryType) {
continue;
}
ShellPrintEx(-1,-1,L"\n=========================================================\n");
ShellPrintHiiEx(-1,-1,NULL,
STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_TYPE_HANDLE_DUMP_STRUCT),
gShellDebug1HiiHandle,
SmbiosStruct.Hdr->Type,
SmbiosStruct.Hdr->Handle
);
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_INDEX_LENGTH), gShellDebug1HiiHandle, Index, Length);
//
// Addr of structure in structure in table
//
ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ADDR), gShellDebug1HiiHandle, (UINTN) Buffer);
DumpHex (0, 0, Length, Buffer);
/*
//
// Get internal commands, such as change options.
//
Status = WaitEnter ();
if (EFI_ERROR (Status)) {
if (Status == EFI_ABORTED) {
return EFI_SUCCESS;
}
return Status;
}
*/
if (gShowType != SHOW_NONE) {
//
// Print structure information
//
SmbiosPrintStructure (&SmbiosStruct, gShowType);
ShellPrintEx(-1,-1,L"\n");
/*
//
// Get internal commands, such as change options.
//
Status = WaitEnter ();
if (EFI_ERROR (Status)) {
if (Status == EFI_ABORTED) {
return EFI_SUCCESS;
}
return Status;
}
*/
}
if (!RandomView) {
break;
}
//
// Support Execution Interrupt.
//
if (ShellGetExecutionBreakFlag ()) {
return EFI_ABORTED;
}
}
ShellPrintEx(-1,-1,L"\n=========================================================\n");
return EFI_SUCCESS;
}
return EFI_BAD_BUFFER_SIZE;
}
/**
Function for 'drivers' 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
ShellCommandRunDrivers (
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;
EFI_HANDLE *HandleList;
EFI_HANDLE *HandleWalker;
UINTN ChildCount;
UINTN DeviceCount;
CHAR16 *Temp2;
CHAR16 *FormatString;
UINT32 DriverVersion;
BOOLEAN DriverConfig;
BOOLEAN DriverDiag;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
Language = NULL;
FormatString = 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, ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) > 1) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Lang = ShellCommandLineGetValue(Package, L"-l");
if (Lang != NULL) {
Language = AllocateZeroPool(StrSize(Lang));
AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
} else if (!ShellCommandLineGetFlag(Package, L"-l")){
ASSERT(Language == NULL);
// Language = AllocateZeroPool(10);
// AsciiSPrint(Language, 10, "en-us");
} else {
ASSERT(Language == NULL);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
ShellCommandLineFreeVarList (Package);
return (SHELL_INVALID_PARAMETER);
}
if (ShellCommandLineGetFlag(Package, L"-sfo")) {
FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE_SFO), Language);
} else {
FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE), Language);
//
// print the header row
//
ShellPrintHiiEx(
-1,
-1,
Language,
STRING_TOKEN(STR_DRIVERS_HEADER_LINES),
gShellDriver1HiiHandle);
}
HandleList = GetHandleListByProtocol(&gEfiDriverBindingProtocolGuid);
for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL ; HandleWalker++){
ChildCount = 0;
DeviceCount = 0;
Status = ParseHandleDatabaseForChildDevices (*HandleWalker, &ChildCount , NULL);
Status = PARSE_HANDLE_DATABASE_DEVICES (*HandleWalker, &DeviceCount, NULL);
Temp2 = GetDevicePathTextForHandle(*HandleWalker);
DriverVersion = ReturnDriverVersion(*HandleWalker);
DriverConfig = ReturnDriverConfig(*HandleWalker);
DriverDiag = ReturnDriverDiag (*HandleWalker);
Lang = GetStringNameFromHandle(*HandleWalker, Language==NULL?"en":Language);
ShellPrintEx(
-1,
-1,
FormatString,
ConvertHandleToHandleIndex(*HandleWalker),
DriverVersion,
ChildCount > 0?L'B':(DeviceCount > 0?L'D':L'?'),
DriverConfig?L'Y':L'N',
DriverDiag?L'Y':L'N',
DeviceCount,
ChildCount,
Lang,
Temp2==NULL?L"":Temp2
);
if (Temp2 != NULL) {
FreePool(Temp2);
}
}
}
SHELL_FREE_NON_NULL(Language);
ShellCommandLineFreeVarList (Package);
SHELL_FREE_NON_NULL(FormatString);
}
return (ShellStatus);
}
/**
Cause the status bar to refresh it's printing on the screen.
@param[in] EditorFirst TRUE to indicate the first launch of the editor.
FALSE otherwise.
@param[in] LastRow LastPrintable row.
@param[in] LastCol Last printable column.
@param[in] FileRow Row in the file.
@param[in] FileCol Column in the file.
@param[in] InsertMode TRUE to indicate InsertMode. FALSE otherwise.
@retval EFI_SUCCESS The operation was successful.
**/
EFI_STATUS
EFIAPI
StatusBarRefresh (
IN BOOLEAN EditorFirst,
IN UINTN LastRow,
IN UINTN LastCol,
IN UINTN FileRow,
IN UINTN FileCol,
IN BOOLEAN InsertMode
)
{
STATUS_BAR_COLOR_UNION Orig;
STATUS_BAR_COLOR_UNION New;
if (!StatusStringChanged && StatusBarNeedRefresh) {
StatusBarSetStatusString (L"\0");
}
//
// when it's called first time after editor launch, so refresh is mandatory
//
if (!StatusBarNeedRefresh && !StatusStringChanged) {
return EFI_SUCCESS;
}
//
// back up the screen attributes
//
Orig.Data = gST->ConOut->Mode->Attribute;
New.Data = 0;
New.Colors.Foreground = Orig.Colors.Background;
New.Colors.Background = Orig.Colors.Foreground;
gST->ConOut->EnableCursor (gST->ConOut, FALSE);
gST->ConOut->SetAttribute (gST->ConOut, New.Data);
//
// clear status bar
//
EditorClearLine (LastRow, LastCol, LastRow);
//
// print row, column fields
//
if (FileRow != (UINTN)(-1) && FileCol != (UINTN)(-1)) {
ShellPrintEx (
0,
(INT32)(LastRow) - 1,
L" %d,%d %s",
FileRow,
FileCol,
StatusString
);
} else {
ShellPrintEx (
0,
(INT32)(LastRow) - 1,
L" %s",
StatusString
);
}
//
// print insert mode field
//
if (InsertMode) {
ShellPrintEx ((INT32)(LastCol) - 21, (INT32)(LastRow) - 1, L"|%s| Help: Ctrl-E", L"INS");
} else {
ShellPrintEx ((INT32)(LastCol) - 21, (INT32)(LastRow) - 1, L"|%s| Help: Ctrl-E", L"OVR");
}
//
// restore the old screen attributes
//
gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
//
// restore position in edit area
//
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
StatusBarNeedRefresh = FALSE;
StatusStringChanged = FALSE;
return EFI_SUCCESS;
}
/**
function to take a list of files to move and a destination location and do
the verification and moving of those files to that location. This function
will report any errors to the user and continue to move the rest of the files.
@param[in] FileList A LIST_ENTRY* based list of files to move
@param[out] Resp pointer to response from question. Pass back on looped calling
@param[in] DestParameter the originally specified destination location
@retval SHELL_SUCCESS the files were all moved.
@retval SHELL_INVALID_PARAMETER a parameter was invalid
@retval SHELL_SECURITY_VIOLATION a security violation ocurred
@retval SHELL_WRITE_PROTECTED the destination was write protected
@retval SHELL_OUT_OF_RESOURCES a memory allocation failed
**/
SHELL_STATUS
EFIAPI
ValidateAndMoveFiles(
IN EFI_SHELL_FILE_INFO *FileList,
OUT VOID **Resp,
IN CONST CHAR16 *DestParameter
)
{
EFI_STATUS Status;
CHAR16 *HiiOutput;
CHAR16 *HiiResultOk;
CHAR16 *DestPath;
CHAR16 *FullDestPath;
CONST CHAR16 *Cwd;
CHAR16 *FullCwd;
SHELL_STATUS ShellStatus;
EFI_SHELL_FILE_INFO *Node;
VOID *Response;
UINT64 Attr;
CHAR16 *CleanFilePathStr;
ASSERT(FileList != NULL);
ASSERT(DestParameter != NULL);
DestPath = NULL;
FullDestPath = NULL;
Cwd = ShellGetCurrentDir(NULL);
Response = *Resp;
Attr = 0;
CleanFilePathStr = NULL;
FullCwd = NULL;
if (Cwd != NULL) {
FullCwd = AllocateZeroPool(StrSize(Cwd) + sizeof(CHAR16));
if (FullCwd == NULL) {
return SHELL_OUT_OF_RESOURCES;
} else {
StrCpyS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, Cwd);
StrCatS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, L"\\");
}
}
Status = ShellLevel2StripQuotes (DestParameter, &CleanFilePathStr);
if (EFI_ERROR (Status)) {
SHELL_FREE_NON_NULL(FullCwd);
if (Status == EFI_OUT_OF_RESOURCES) {
return SHELL_OUT_OF_RESOURCES;
} else {
return SHELL_INVALID_PARAMETER;
}
}
ASSERT (CleanFilePathStr != NULL);
//
// Get and validate the destination location
//
ShellStatus = GetDestinationLocation(CleanFilePathStr, &DestPath, FullCwd, (BOOLEAN)(FileList->Link.ForwardLink == FileList->Link.BackLink), &Attr);
FreePool (CleanFilePathStr);
if (ShellStatus != SHELL_SUCCESS) {
SHELL_FREE_NON_NULL (FullCwd);
return (ShellStatus);
}
DestPath = PathCleanUpDirectories(DestPath);
if (DestPath == NULL) {
FreePool (FullCwd);
return (SHELL_OUT_OF_RESOURCES);
}
HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MV_OUTPUT), NULL);
HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
if (HiiOutput == NULL || HiiResultOk == NULL) {
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
SHELL_FREE_NON_NULL(FullCwd);
return (SHELL_OUT_OF_RESOURCES);
}
//
// Go through the list of files and directories to move...
//
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
if (ShellGetExecutionBreakFlag()) {
break;
}
//
// These should never be NULL
//
ASSERT(Node->FileName != NULL);
ASSERT(Node->FullName != NULL);
ASSERT(Node->Info != NULL);
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
SHELL_FREE_NON_NULL(FullDestPath);
FullDestPath = NULL;
if (ShellIsDirectory(DestPath)==EFI_SUCCESS) {
CreateFullDestPath((CONST CHAR16 **)&DestPath, &FullDestPath, Node->FileName);
}
//
// Validate that the move is valid
//
if (!IsValidMove(Node->FullName, FullCwd, FullDestPath!=NULL? FullDestPath:DestPath, Node->Info->Attribute, Attr, Node->Status)) {
ShellStatus = SHELL_INVALID_PARAMETER;
continue;
}
ShellPrintEx(-1, -1, HiiOutput, Node->FullName, FullDestPath!=NULL? FullDestPath:DestPath);
//
// See if destination exists
//
if (!EFI_ERROR(ShellFileExists(FullDestPath!=NULL? FullDestPath:DestPath))) {
if (Response == NULL) {
ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response);
}
switch (*(SHELL_PROMPT_RESPONSE*)Response) {
case ShellPromptResponseNo:
FreePool(Response);
Response = NULL;
continue;
case ShellPromptResponseCancel:
*Resp = Response;
//
// indicate to stop everything
//
SHELL_FREE_NON_NULL(FullCwd);
return (SHELL_ABORTED);
case ShellPromptResponseAll:
*Resp = Response;
break;
case ShellPromptResponseYes:
FreePool(Response);
Response = NULL;
break;
default:
FreePool(Response);
SHELL_FREE_NON_NULL(FullCwd);
return SHELL_ABORTED;
}
Status = ShellDeleteFileByName(FullDestPath!=NULL? FullDestPath:DestPath);
}
if (IsBetweenFileSystem(Node->FullName, FullCwd, DestPath)) {
while (FullDestPath == NULL && DestPath != NULL && DestPath[0] != CHAR_NULL && DestPath[StrLen(DestPath) - 1] == L'\\') {
DestPath[StrLen(DestPath) - 1] = CHAR_NULL;
}
Status = MoveBetweenFileSystems(Node, FullDestPath!=NULL? FullDestPath:DestPath, &Response);
} else {
Status = MoveWithinFileSystems(Node, DestPath, &Response);
//
// Display error status
//
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"mv", Status);
}
}
//
// Check our result
//
if (EFI_ERROR(Status)) {
ShellStatus = SHELL_INVALID_PARAMETER;
if (Status == EFI_SECURITY_VIOLATION) {
ShellStatus = SHELL_SECURITY_VIOLATION;
} else if (Status == EFI_WRITE_PROTECTED) {
ShellStatus = SHELL_WRITE_PROTECTED;
} else if (Status == EFI_OUT_OF_RESOURCES) {
ShellStatus = SHELL_OUT_OF_RESOURCES;
} else if (Status == EFI_DEVICE_ERROR) {
ShellStatus = SHELL_DEVICE_ERROR;
} else if (Status == EFI_ACCESS_DENIED) {
ShellStatus = SHELL_ACCESS_DENIED;
}
} else {
ShellPrintEx(-1, -1, L"%s", HiiResultOk);
}
} // main for loop
SHELL_FREE_NON_NULL(FullDestPath);
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
SHELL_FREE_NON_NULL(FullCwd);
return (ShellStatus);
}
/**
Function for 'hexedit' 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
ShellCommandRunHexEdit (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
CHAR16 *Buffer;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
LIST_ENTRY *Package;
CHAR16 *NewName;
CONST CHAR16 *Name;
UINTN Offset;
UINTN Size;
EDIT_FILE_TYPE WhatToDo;
Buffer = NULL;
ShellStatus = SHELL_SUCCESS;
NewName = NULL;
Buffer = NULL;
Name = NULL;
Offset = 0;
Size = 0;
WhatToDo = FileTypeNone;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
// ASSERT_EFI_ERROR(Status);
Status = CommandInit();
// ASSERT_EFI_ERROR(Status);
if (EFI_ERROR(Status)) {
return SHELL_UNSUPPORTED;
}
//
// 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), gShellDebug1HiiHandle, L"hexedit", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} /* else {
ASSERT(FALSE);
} */
} else {
//
// Check for -d
//
if (ShellCommandLineGetFlag(Package, L"-d")){
if (ShellCommandLineGetCount(Package) < 4) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetCount(Package) > 4) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
WhatToDo = FileTypeDiskBuffer;
Name = ShellCommandLineGetRawValue(Package, 1);
Offset = ShellStrToUintn(ShellCommandLineGetRawValue(Package, 2));
Size = ShellStrToUintn(ShellCommandLineGetRawValue(Package, 3));
}
if (Offset == (UINTN)-1 || Size == (UINTN)-1) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"hexedit", L"-d");
ShellStatus = SHELL_INVALID_PARAMETER;
}
}
//
// check for -f
//
if (ShellCommandLineGetFlag(Package, L"-f") && (WhatToDo == FileTypeNone)){
if (ShellCommandLineGetCount(Package) < 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetCount(Package) > 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Name = ShellCommandLineGetRawValue(Package, 1);
if (Name == NULL || !IsValidFileName(Name)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"hexedit", Name);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
WhatToDo = FileTypeFileBuffer;
}
}
}
//
// check for -m
//
if (ShellCommandLineGetFlag(Package, L"-m") && (WhatToDo == FileTypeNone)){
if (ShellCommandLineGetCount(Package) < 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetCount(Package) > 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
WhatToDo = FileTypeMemBuffer;
Offset = ShellStrToUintn(ShellCommandLineGetRawValue(Package, 1));
Size = ShellStrToUintn(ShellCommandLineGetRawValue(Package, 2));
}
}
Name = ShellCommandLineGetRawValue(Package, 1);
if (WhatToDo == FileTypeNone && Name != NULL) {
if (ShellCommandLineGetCount(Package) > 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (!IsValidFileName(Name)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"hexedit", Name);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
WhatToDo = FileTypeFileBuffer;
}
} else if (WhatToDo == FileTypeNone) {
if (gEfiShellProtocol->GetCurDir(NULL) == NULL) {
ShellStatus = SHELL_NOT_FOUND;
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellDebug1HiiHandle, L"hexedit");
} else {
NewName = EditGetDefaultFileName(L"bin");
Name = NewName;
WhatToDo = FileTypeFileBuffer;
}
}
if (ShellStatus == SHELL_SUCCESS && WhatToDo == FileTypeNone) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (WhatToDo == FileTypeFileBuffer && ShellGetCurrentDir(NULL) == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellDebug1HiiHandle, L"hexedit");
ShellStatus = SHELL_INVALID_PARAMETER;
}
if (ShellStatus == SHELL_SUCCESS) {
//
// Do the editor
//
Status = HMainEditorInit ();
if (EFI_ERROR (Status)) {
gST->ConOut->ClearScreen (gST->ConOut);
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HEXEDIT_INIT_FAILED), gShellDebug1HiiHandle);
} else {
HMainEditorBackup ();
switch (WhatToDo) {
case FileTypeFileBuffer:
Status = HBufferImageRead (
Name==NULL?L"":Name,
NULL,
0,
0,
0,
0,
FileTypeFileBuffer,
FALSE
);
break;
case FileTypeDiskBuffer:
Status = HBufferImageRead (
NULL,
Name==NULL?L"":Name,
Offset,
Size,
0,
0,
FileTypeDiskBuffer,
FALSE
);
break;
case FileTypeMemBuffer:
Status = HBufferImageRead (
NULL,
NULL,
0,
0,
(UINT32) Offset,
Size,
FileTypeMemBuffer,
FALSE
);
break;
default:
Status = EFI_NOT_FOUND;
break;
}
if (!EFI_ERROR (Status)) {
HMainEditorRefresh ();
Status = HMainEditorKeyInput ();
}
if (Status != EFI_OUT_OF_RESOURCES) {
//
// back up the status string
//
Buffer = CatSPrint (NULL, L"%s\r\n", StatusBarGetString());
}
}
//
// cleanup
//
HMainEditorCleanup ();
if (EFI_ERROR (Status)) {
if (ShellStatus == SHELL_SUCCESS) {
ShellStatus = SHELL_UNSUPPORTED;
}
}
//
// print editor exit code on screen
//
if (Status == EFI_OUT_OF_RESOURCES) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle, L"hexedit");
} else if (EFI_ERROR(Status)){
if (Buffer != NULL) {
if (StrCmp (Buffer, L"") != 0) {
//
// print out the status string
//
ShellPrintEx(-1, -1, L"%s", Buffer);
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HEXEDIT_UNKNOWN_EDITOR), gShellDebug1HiiHandle);
}
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HEXEDIT_UNKNOWN_EDITOR), gShellDebug1HiiHandle);
}
}
}
ShellCommandLineFreeVarList (Package);
}
SHELL_FREE_NON_NULL (Buffer);
SHELL_FREE_NON_NULL (NewName);
return ShellStatus;
}
/**
Function for 'setvar' 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
ShellCommandRunSetVar (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
RETURN_STATUS RStatus;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *VariableName;
EFI_GUID Guid;
CONST CHAR16 *StringGuid;
UINT32 Attributes;
VOID *Buffer;
UINTN Size;
UINTN LoopVar;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
Buffer = NULL;
Size = 0;
Attributes = 0;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
// ASSERT_EFI_ERROR(Status);
Status = CommandInit();
// ASSERT_EFI_ERROR(Status);
if (EFI_ERROR(Status)) {
return SHELL_UNSUPPORTED;
}
//
// 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), gShellDebug1HiiHandle, L"setvar", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} /* else {
ASSERT(FALSE);
} */
} else if (ShellCommandLineCheckDuplicate (Package,&ProblemParam) != EFI_SUCCESS) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DUPLICATE), gShellDebug1HiiHandle, L"setvar", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
if (ShellCommandLineGetCount(Package) < 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"setvar");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
VariableName = ShellCommandLineGetRawValue(Package, 1);
if (!ShellCommandLineGetFlag(Package, L"-guid")){
CopyGuid(&Guid, &gEfiGlobalVariableGuid);
} else {
StringGuid = ShellCommandLineGetValue(Package, L"-guid");
RStatus = StrToGuid (StringGuid, &Guid);
if (RETURN_ERROR (RStatus) || (StringGuid[GUID_STRING_LENGTH] != L'\0')) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", StringGuid);
ShellStatus = SHELL_INVALID_PARAMETER;
}
}
if (ShellCommandLineGetCount(Package) == 2) {
//
// Display
//
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
}
if (!EFI_ERROR(Status) && Buffer != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_SETVAR_PRINT), gShellDebug1HiiHandle, &Guid, VariableName, Size);
for (LoopVar = 0; LoopVar < Size; LoopVar++) {
ShellPrintEx(-1, -1, L"%02x ", ((UINT8*)Buffer)[LoopVar]);
}
ShellPrintEx(-1, -1, L"\r\n");
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_GET), gShellDebug1HiiHandle, L"setvar", &Guid, VariableName);
ShellStatus = SHELL_ACCESS_DENIED;
}
} else {
//
// Create, Delete or Modify.
//
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
}
if (EFI_ERROR(Status) || Buffer == NULL) {
//
// Creating a new variable. determine attributes from command line.
//
Attributes = 0;
if (ShellCommandLineGetFlag(Package, L"-bs")) {
Attributes |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-rt")) {
Attributes |= EFI_VARIABLE_RUNTIME_ACCESS |
EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-nv")) {
Attributes |= EFI_VARIABLE_NON_VOLATILE;
}
}
SHELL_FREE_NON_NULL(Buffer);
Size = 0;
Status = GetVariableDataFromParameter(Package, (UINT8 **)&Buffer, &Size);
if (!EFI_ERROR(Status)) {
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, Size, Buffer);
}
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, L"setvar", &Guid, VariableName);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
}
}
ShellCommandLineFreeVarList (Package);
}
if (Buffer != NULL) {
FreePool(Buffer);
}
return (ShellStatus);
}
/**
Do the diagnostics call for some set of handles.
@param[in] Mode The type of diagnostic test to run.
@param[in] Lang The language code to use.
@param[in] AllChilds Should the test be on all children.
@param[in] DriverHandle The driver handle to test with.
@param[in] ControllerHandle The specific controller handle to test.
@param[in] ChildHandle The specific child handle to test.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_INVALID_PARAMETER A parameter had an invalid value.
@retval EFI_NOT_FOUND No diagnostic handle could be found.
**/
EFI_STATUS
EFIAPI
DoDiagnostics (
IN CONST DRV_DIAG_TEST_MODE Mode,
IN CONST CHAR8 *Lang,
IN CONST BOOLEAN AllChilds,
IN CONST EFI_HANDLE DriverHandle,
IN CONST EFI_HANDLE ControllerHandle,
IN CONST EFI_HANDLE ChildHandle
)
{
EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics;
EFI_DRIVER_DIAGNOSTICS2_PROTOCOL *DriverDiagnostics2;
EFI_HANDLE *DriverHandleList;
EFI_HANDLE *ControllerHandleList;
EFI_HANDLE *ChildHandleList;
EFI_HANDLE *Walker;
UINTN DriverHandleListCount;
UINTN ControllerHandleListCount;
UINTN ChildHandleListCount;
UINTN DriverHandleListLoop;
UINTN ControllerHandleListLoop;
UINTN ChildHandleListLoop;
EFI_STATUS Status;
EFI_STATUS Status2;
EFI_GUID *ErrorType;
UINTN OutBufferSize;
CHAR16 *OutBuffer;
UINTN HandleIndex1;
UINTN HandleIndex2;
CHAR8 *Language;
BOOLEAN Found;
if ((ChildHandle != NULL && AllChilds) || (Mode >= TestModeMax)){
return (EFI_INVALID_PARAMETER);
}
DriverDiagnostics = NULL;
DriverDiagnostics2 = NULL;
Status = EFI_SUCCESS;
Status2 = EFI_SUCCESS;
DriverHandleList = NULL;
ControllerHandleList = NULL;
ChildHandleList = NULL;
Language = NULL;
OutBuffer = NULL;
ErrorType = NULL;
DriverHandleListCount = 0;
ControllerHandleListCount = 0;
ChildHandleListCount = 0;
if (DriverHandle != NULL) {
DriverHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
ASSERT(DriverHandleList!=NULL);
DriverHandleList[0] = DriverHandle;
DriverHandleListCount = 1;
} else {
DriverHandleList = GetHandleListByProtocolList(DiagGuidList);
if (DriverHandleList == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROTOCOL_NF), gShellDriver1HiiHandle, L"gEfiDriverDiagnosticsProtocolGuid", &gEfiDriverDiagnosticsProtocolGuid);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROTOCOL_NF), gShellDriver1HiiHandle, L"gEfiDriverDiagnostics2ProtocolGuid", &gEfiDriverDiagnostics2ProtocolGuid);
return (EFI_NOT_FOUND);
}
for (Walker = DriverHandleList ; Walker != NULL && *Walker != NULL ; DriverHandleListCount++, Walker++);
}
if (ControllerHandle != NULL) {
ControllerHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
ASSERT(ControllerHandleList!=NULL);
ControllerHandleList[0] = ControllerHandle;
ControllerHandleListCount = 1;
} else {
ControllerHandleList = NULL;
}
if (ChildHandle != NULL) {
ChildHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));
ASSERT(ChildHandleList!=NULL);
ChildHandleList[0] = ChildHandle;
ChildHandleListCount = 1;
} else if (AllChilds) {
ChildHandleList = NULL;
//
// This gets handled in the loop below.
//
} else {
ChildHandleList = NULL;
}
if (Mode == TestModeList) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_HEADER), gShellDriver1HiiHandle);
}
for (DriverHandleListLoop = 0
; DriverHandleListLoop < DriverHandleListCount
; DriverHandleListLoop++
){
if (Mode == TestModeList) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_DRIVER_HEADER), gShellDriver1HiiHandle, ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]));
}
if (ControllerHandle == NULL) {
PARSE_HANDLE_DATABASE_DEVICES(DriverHandleList[DriverHandleListLoop], &ControllerHandleListCount, &ControllerHandleList);
}
if (ControllerHandleListCount == 0) {
if (Mode == TestModeList) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVDIAG_DRIVER_NO_HANDLES), gShellDriver1HiiHandle);
}
} else {
if (Mode == TestModeList) {
ShellPrintEx(-1, -1, L"\r\n");
}
for (ControllerHandleListLoop = 0
; ControllerHandleListLoop < ControllerHandleListCount
; ControllerHandleListLoop++
){
if (AllChilds) {
ASSERT(ChildHandleList == NULL);
PARSE_HANDLE_DATABASE_MANAGED_CHILDREN(
DriverHandleList[DriverHandleListLoop],
ControllerHandleList[ControllerHandleListLoop],
&ChildHandleListCount,
&ChildHandleList);
}
for (ChildHandleListLoop = 0
; (ChildHandleListLoop < ChildHandleListCount || ChildHandleList == NULL)
; ChildHandleListLoop++
){
Found = FALSE;
if (Mode != TestModeList) {
if (Lang == NULL || Lang[2] == '-') {
//
// Get the protocol pointer and call the function
//
Status = gBS->OpenProtocol(
DriverHandleList[DriverHandleListLoop],
&gEfiDriverDiagnostics2ProtocolGuid,
(VOID**)&DriverDiagnostics2,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!EFI_ERROR(Status) && (DriverDiagnostics2 != NULL)) {
Language = GetBestLanguageForDriver(DriverDiagnostics2->SupportedLanguages, Lang, FALSE);
Found = TRUE;
Status = DriverDiagnostics2->RunDiagnostics(
DriverDiagnostics2,
ControllerHandleList[ControllerHandleListLoop],
ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],
(EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,
Language,
&ErrorType,
&OutBufferSize,
&OutBuffer);
FreePool(Language);
}
}
if (!Found && (Lang == NULL||(Lang!=NULL&&(Lang[2]!='-')))){
Status = gBS->OpenProtocol(
DriverHandleList[DriverHandleListLoop],
&gEfiDriverDiagnosticsProtocolGuid,
(VOID**)&DriverDiagnostics,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (!EFI_ERROR(Status)) {
Language = GetBestLanguageForDriver(DriverDiagnostics->SupportedLanguages, Lang, FALSE);
Status = DriverDiagnostics->RunDiagnostics(
DriverDiagnostics,
ControllerHandleList[ControllerHandleListLoop],
ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],
(EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,
Language,
&ErrorType,
&OutBufferSize,
&OutBuffer);
FreePool(Language);
}
}
if (EFI_ERROR(Status)) {
Status2 = Status;
}
HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);
HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_3P_RESULT),
gShellDriver1HiiHandle,
L"DrvDiag",
HandleIndex1,
HandleIndex2,
ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop]),
Status);
if (OutBuffer!=NULL) {
FreePool(OutBuffer);
OutBuffer = NULL;
}
if (ErrorType!=NULL) {
FreePool(ErrorType);
ErrorType = NULL;
}
} else {
HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);
HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);
//
// Print out the information that this set can be tested
//
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN (STR_DRV_DIAG_ITEM_LINE),
gShellDriver1HiiHandle,
HandleIndex1,
HandleIndex2,
ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop])
);
}
//
// If we are doing a single pass with NULL child jump out after a single loop
//
if (ChildHandleList == NULL) {
break;
}
}
if (AllChilds) {
SHELL_FREE_NON_NULL(ChildHandleList);
ChildHandleList = NULL;
ChildHandleListCount = 0;
}
}
if (ControllerHandle == NULL) {
SHELL_FREE_NON_NULL(ControllerHandleList);
ControllerHandleList = NULL;
ControllerHandleListCount = 0;
}
}
}
if (DriverHandleList != NULL) {
FreePool(DriverHandleList);
}
if (ControllerHandleList != NULL) {
FreePool(ControllerHandleList);
}
if (ChildHandleList != NULL) {
FreePool(ChildHandleList);
}
return (Status2);
}
/**
Display a single file to StdOut.
If both Ascii and UCS2 are FALSE attempt to discover the file type.
@param[in] Handle The handle to the file to display.
@param[in] Ascii TRUE to force ASCII, FALSE othewise.
@param[in] UCS2 TRUE to force UCS2, FALSE othewise.
@retval EFI_OUT_OF_RESOURCES A memory allocation failed.
@retval EFI_SUCCESS The operation was successful.
**/
EFI_STATUS
TypeFileByHandle (
IN SHELL_FILE_HANDLE Handle,
IN BOOLEAN Ascii,
IN BOOLEAN UCS2
)
{
UINTN ReadSize;
VOID *Buffer;
VOID *AllocatedBuffer;
EFI_STATUS Status;
UINTN LoopVar;
UINTN LoopSize;
CHAR16 AsciiChar;
CHAR16 Ucs2Char;
ReadSize = PcdGet32(PcdShellFileOperationSize);
AllocatedBuffer = AllocateZeroPool(ReadSize);
if (AllocatedBuffer == NULL) {
return (EFI_OUT_OF_RESOURCES);
}
Status = ShellSetFilePosition(Handle, 0);
ASSERT_EFI_ERROR(Status);
while (ReadSize == ((UINTN)PcdGet32(PcdShellFileOperationSize))) {
Buffer = AllocatedBuffer;
ZeroMem(Buffer, ReadSize);
Status = ShellReadFile(Handle, &ReadSize, Buffer);
if (EFI_ERROR(Status)){
break;
}
if (!(Ascii|UCS2)) {
if (*(UINT16*)Buffer == gUnicodeFileTag) {
UCS2 = TRUE;
} else {
Ascii = TRUE;
}
}
if (Ascii) {
LoopSize = ReadSize;
for (LoopVar = 0 ; LoopVar < LoopSize ; LoopVar++) {
//
// The valid range of ASCII characters is 0x20-0x7E.
// Display "." when there is an invalid character.
//
AsciiChar = CHAR_NULL;
AsciiChar = ((CHAR8*)Buffer)[LoopVar];
if (AsciiChar == '\r' || AsciiChar == '\n') {
//
// Allow Line Feed (LF) (0xA) & Carriage Return (CR) (0xD)
// characters to be displayed as is.
//
if (AsciiChar == '\n' && ((CHAR8*)Buffer)[LoopVar-1] != '\r') {
//
// In case Line Feed (0xA) is encountered & Carriage Return (0xD)
// was not the previous character, print CR and LF. This is because
// Shell 2.0 requires carriage return with line feed for displaying
// each new line from left.
//
ShellPrintEx (-1, -1, L"\r\n");
continue;
}
} else {
//
// For all other characters which are not printable, display '.'
//
if (AsciiChar < 0x20 || AsciiChar >= 0x7F) {
AsciiChar = '.';
}
}
ShellPrintEx (-1, -1, L"%c", AsciiChar);
}
} else {
if (*(UINT16*)Buffer == gUnicodeFileTag) {
//
// For unicode files, skip displaying the byte order marker.
//
Buffer = ((UINT16*)Buffer) + 1;
LoopSize = (ReadSize / (sizeof (CHAR16))) - 1;
} else {
LoopSize = ReadSize / (sizeof (CHAR16));
}
for (LoopVar = 0 ; LoopVar < LoopSize ; LoopVar++) {
//
// An invalid range of characters is 0x0-0x1F.
// Display "." when there is an invalid character.
//
Ucs2Char = CHAR_NULL;
Ucs2Char = ((CHAR16*)Buffer)[LoopVar];
if (Ucs2Char == '\r' || Ucs2Char == '\n') {
//
// Allow Line Feed (LF) (0xA) & Carriage Return (CR) (0xD)
// characters to be displayed as is.
//
if (Ucs2Char == '\n' && ((CHAR16*)Buffer)[LoopVar-1] != '\r') {
//
// In case Line Feed (0xA) is encountered & Carriage Return (0xD)
// was not the previous character, print CR and LF. This is because
// Shell 2.0 requires carriage return with line feed for displaying
// each new line from left.
//
ShellPrintEx (-1, -1, L"\r\n");
continue;
}
}
else if (Ucs2Char < 0x20) {
//
// For all other characters which are not printable, display '.'
//
Ucs2Char = L'.';
}
ShellPrintEx (-1, -1, L"%c", Ucs2Char);
}
}
if (ShellGetExecutionBreakFlag()) {
break;
}
}
FreePool (AllocatedBuffer);
ShellPrintEx (-1, -1, L"\r\n");
return (Status);
}
/**
Do the actual parsing of the file. the file should be SFO output from a
shell command or a similar format.
@param[in] FileName The filename to open.
@param[in] TableName The name of the table to find.
@param[in] ColumnIndex The column number to get.
@param[in] TableNameInstance Which instance of the table to get (row).
@param[in] ShellCommandInstance Which instance of the command to get.
@retval SHELL_NOT_FOUND The requested instance was not found.
@retval SHELL_SUCCESS The operation was successful.
**/
SHELL_STATUS
EFIAPI
PerformParsing(
IN CONST CHAR16 *FileName,
IN CONST CHAR16 *TableName,
IN CONST UINTN ColumnIndex,
IN CONST UINTN TableNameInstance,
IN CONST UINTN ShellCommandInstance
)
{
SHELL_FILE_HANDLE FileHandle;
EFI_STATUS Status;
BOOLEAN Ascii;
UINTN LoopVariable;
UINTN ColumnLoop;
CHAR16 *TempLine;
CHAR16 *ColumnPointer;
SHELL_STATUS ShellStatus;
CHAR16 *TempSpot;
ASSERT(FileName != NULL);
ASSERT(TableName != NULL);
ShellStatus = SHELL_SUCCESS;
Status = ShellOpenFileByName(FileName, &FileHandle, EFI_FILE_MODE_READ, 0);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellLevel2HiiHandle, FileName);
ShellStatus = SHELL_NOT_FOUND;
} else if (!EFI_ERROR (FileHandleIsDirectory (FileHandle))) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_FILE), gShellLevel2HiiHandle, FileName);
ShellStatus = SHELL_NOT_FOUND;
} else {
for (LoopVariable = 0 ; LoopVariable < ShellCommandInstance && !ShellFileHandleEof(FileHandle);) {
TempLine = ShellFileHandleReturnLine(FileHandle, &Ascii);
if (TempLine == NULL) {
break;
}
//
// Search for "ShellCommand," in the file to start the SFO table
// for a given ShellCommand. The UEFI Shell spec does not specify
// a space after the comma.
//
if (StrStr (TempLine, L"ShellCommand,") == TempLine) {
LoopVariable++;
}
SHELL_FREE_NON_NULL(TempLine);
}
if (LoopVariable == ShellCommandInstance) {
LoopVariable = 0;
while(1) {
TempLine = ShellFileHandleReturnLine(FileHandle, &Ascii);
if (TempLine == NULL
|| *TempLine == CHAR_NULL
|| StrStr (TempLine, L"ShellCommand,") == TempLine) {
SHELL_FREE_NON_NULL(TempLine);
break;
}
if (StrStr (TempLine, TableName) == TempLine) {
LoopVariable++;
if (LoopVariable == TableNameInstance
|| (TableNameInstance == (UINTN)-1)) {
for (ColumnLoop = 1, ColumnPointer = TempLine; ColumnLoop < ColumnIndex && ColumnPointer != NULL && *ColumnPointer != CHAR_NULL; ColumnLoop++) {
ColumnPointer = StrStr (ColumnPointer, L",\"");
if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL){
ColumnPointer++;
}
}
if (ColumnLoop == ColumnIndex) {
if (ColumnPointer == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellLevel2HiiHandle, L"Column Index");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
TempSpot = StrStr (ColumnPointer, L",\"");
if (TempSpot != NULL) {
*TempSpot = CHAR_NULL;
}
while (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L' '){
ColumnPointer++;
}
if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L'\"'){
ColumnPointer++;
}
if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[StrLen (ColumnPointer) - 1] == L'\"'){
ColumnPointer[StrLen (ColumnPointer) - 1] = CHAR_NULL;
}
ShellPrintEx (-1, -1, L"%s\r\n", ColumnPointer);
}
}
}
}
SHELL_FREE_NON_NULL(TempLine);
}
}
}
return (ShellStatus);
}
/**
Open the database and print out all the info about TheHandle.
@param[in] TheHandle The handle to print info on.
@retval EFI_SUCCESS The operation was successful.
@retval EFI_INVALID_PARAMETER TheHandle was NULL.
**/
EFI_STATUS
TraverseHandleDatabase (
IN CONST EFI_HANDLE TheHandle
)
{
EFI_STATUS Status;
EFI_GUID **ProtocolGuidArray;
UINTN ArrayCount;
UINTN ProtocolIndex;
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
UINTN OpenInfoCount;
UINTN OpenInfoIndex;
CONST CHAR16 *OpenTypeString;
CHAR16 *TempString;
UINTN HandleIndex;
CONST CHAR16 *Name;
UINTN ControllerIndex;
if (TheHandle == NULL) {
return (EFI_INVALID_PARAMETER);
}
//
// Retrieve the list of all the protocols on the handle
//
Status = gBS->ProtocolsPerHandle (
TheHandle,
&ProtocolGuidArray,
&ArrayCount
);
ASSERT_EFI_ERROR(Status);
if (!EFI_ERROR (Status)) {
for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
//
// print out the human readable name for this one.
//
TempString = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], NULL);
if (TempString == NULL) {
continue;
}
ShellPrintEx(-1, -1, L"%H%s%N\r\n", TempString);
FreePool(TempString);
//
// Retrieve the list of agents that have opened each protocol
//
Status = gBS->OpenProtocolInformation (
TheHandle,
ProtocolGuidArray[ProtocolIndex],
&OpenInfo,
&OpenInfoCount
);
ASSERT_EFI_ERROR(Status);
if (!EFI_ERROR (Status)) {
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
switch (OpenInfo[OpenInfoIndex].Attributes) {
case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: OpenTypeString = StringHandProt; break;
case EFI_OPEN_PROTOCOL_GET_PROTOCOL: OpenTypeString = StringGetProt; break;
case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: OpenTypeString = StringTestProt; break;
case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: OpenTypeString = StringChild; break;
case EFI_OPEN_PROTOCOL_BY_DRIVER: OpenTypeString = StringDriver; break;
case EFI_OPEN_PROTOCOL_EXCLUSIVE: OpenTypeString = StringExclusive; break;
case EFI_OPEN_PROTOCOL_BY_DRIVER|EFI_OPEN_PROTOCOL_EXCLUSIVE:
OpenTypeString = StringDriverEx; break;
default: OpenTypeString = StringUnknown; break;
}
HandleIndex = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].AgentHandle);
Name = GetStringNameFromHandle(OpenInfo[OpenInfoIndex].AgentHandle, NULL);
ControllerIndex = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].ControllerHandle);
if (ControllerIndex != 0) {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN(STR_OPENINFO_LINE),
gShellDriver1HiiHandle,
HandleIndex,
ControllerIndex,
OpenInfo[OpenInfoIndex].OpenCount,
OpenTypeString,
Name
);
} else {
ShellPrintHiiEx(
-1,
-1,
NULL,
STRING_TOKEN(STR_OPENINFO_MIN_LINE),
gShellDriver1HiiHandle,
HandleIndex,
OpenInfo[OpenInfoIndex].OpenCount,
OpenTypeString,
Name
);
}
}
FreePool (OpenInfo);
}
}
FreePool (ProtocolGuidArray);
}
return Status;
}
/**
Function for 'help' 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
ShellCommandRunHelp (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST COMMAND_LIST *CommandList;
CONST COMMAND_LIST *Node;
CHAR16 *CommandToGetHelpOn;
CHAR16 *SectionToGetHelpOn;
CHAR16 *HiiString;
BOOLEAN Found;
BOOLEAN PrintCommandText;
PrintCommandText = TRUE;
ProblemParam = NULL;
ShellStatus = SHELL_SUCCESS;
CommandToGetHelpOn = NULL;
SectionToGetHelpOn = NULL;
Found = FALSE;
//
// 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), gShellLevel3HiiHandle, L"help", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
//
// Check for conflicting parameters.
//
if (ShellCommandLineGetFlag(Package, L"-usage")
&&ShellCommandLineGetFlag(Package, L"-section")
&&(ShellCommandLineGetFlag(Package, L"-verbose") || ShellCommandLineGetFlag(Package, L"-v"))
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CON), gShellLevel3HiiHandle, L"help");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetRawValue(Package, 2) != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel3HiiHandle, L"help");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// Get the command name we are getting help on
//
ASSERT(CommandToGetHelpOn == NULL);
StrnCatGrow(&CommandToGetHelpOn, NULL, ShellCommandLineGetRawValue(Package, 1), 0);
if (CommandToGetHelpOn == NULL && ShellCommandLineGetFlag(Package, L"-?")) {
//
// If we dont have a command and we got a simple -?
// we are looking for help on help command.
//
StrnCatGrow(&CommandToGetHelpOn, NULL, L"help", 0);
}
if (CommandToGetHelpOn == NULL) {
StrnCatGrow(&CommandToGetHelpOn, NULL, L"*", 0);
ASSERT(SectionToGetHelpOn == NULL);
StrnCatGrow(&SectionToGetHelpOn, NULL, L"NAME", 0);
} else {
PrintCommandText = FALSE;
ASSERT(SectionToGetHelpOn == NULL);
//
// Get the section name for the given command name
//
if (ShellCommandLineGetFlag(Package, L"-section")) {
StrnCatGrow(&SectionToGetHelpOn, NULL, ShellCommandLineGetValue(Package, L"-section"), 0);
} else if (ShellCommandLineGetFlag(Package, L"-usage")) {
StrnCatGrow(&SectionToGetHelpOn, NULL, L"NAME,SYNOPSIS", 0);
} else if (ShellCommandLineGetFlag(Package, L"-verbose") || ShellCommandLineGetFlag(Package, L"-v")) {
} else {
//
// The output of help <command> will display NAME, SYNOPSIS, OPTIONS, DESCRIPTION, and EXAMPLES sections.
//
StrnCatGrow (&SectionToGetHelpOn, NULL, L"NAME,SYNOPSIS,OPTIONS,DESCRIPTION,EXAMPLES", 0);
}
}
if (gUnicodeCollation->StriColl(gUnicodeCollation, CommandToGetHelpOn, L"special") == 0) {
//
// we need info on the special characters
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_SC_HEADER), gShellLevel3HiiHandle);
HiiString = HiiGetString(gShellLevel3HiiHandle, STRING_TOKEN(STR_HELP_SC_DATA), NULL);
ShellPrintEx(-1, -1, L"%s", HiiString);
FreePool(HiiString);
Found = TRUE;
} else {
CommandList = ShellCommandGetCommandList(TRUE);
ASSERT(CommandList != NULL);
for ( Node = (COMMAND_LIST*)GetFirstNode(&CommandList->Link)
; CommandList != NULL && !IsListEmpty(&CommandList->Link) && !IsNull(&CommandList->Link, &Node->Link)
; Node = (COMMAND_LIST*)GetNextNode(&CommandList->Link, &Node->Link)
){
//
// Checking execution break flag when print multiple command help information.
//
if (ShellGetExecutionBreakFlag ()) {
break;
}
if ((gUnicodeCollation->MetaiMatch(gUnicodeCollation, Node->CommandString, CommandToGetHelpOn)) ||
(gEfiShellProtocol->GetAlias(CommandToGetHelpOn, NULL) != NULL && (gUnicodeCollation->MetaiMatch(gUnicodeCollation, Node->CommandString, (CHAR16*)(gEfiShellProtocol->GetAlias(CommandToGetHelpOn, NULL)))))) {
//
// We have a command to look for help on.
//
Status = ShellPrintHelp(Node->CommandString, SectionToGetHelpOn, PrintCommandText);
if (Status == EFI_DEVICE_ERROR) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, Node->CommandString);
} else if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, Node->CommandString);
} else {
Found = TRUE;
}
}
}
//
// now try to match against the dynamic command list and print help
//
Status = PrintDynamicCommandHelp (CommandToGetHelpOn, SectionToGetHelpOn,
PrintCommandText);
if (!EFI_ERROR(Status)) {
Found = TRUE;
}
//
// Search the .man file for Shell applications (Shell external commands).
//
if (!Found) {
Status = ShellPrintHelp(CommandToGetHelpOn, SectionToGetHelpOn, FALSE);
if (Status == EFI_DEVICE_ERROR) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, CommandToGetHelpOn);
} else if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);
} else {
Found = TRUE;
}
}
}
if (!Found) {
ShellStatus = SHELL_NOT_FOUND;
}
//
// free the command line package
//
ShellCommandLineFreeVarList (Package);
}
}
if (CommandToGetHelpOn != NULL && StrCmp(CommandToGetHelpOn, L"*") == 0){
//
// If '*' then the command entered was 'Help' without qualifiers, This footer
// provides additional info on help switches
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_FOOTER), gShellLevel3HiiHandle);
}
if (CommandToGetHelpOn != NULL) {
FreePool(CommandToGetHelpOn);
}
if (SectionToGetHelpOn != NULL) {
FreePool(SectionToGetHelpOn);
}
return (ShellStatus);
}
/**
Function for 'mm' 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
ShellCommandRunMm (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *IoDev;
UINT64 Address;
UINT64 PciEAddress;
UINT64 Value;
UINT32 SegmentNumber;
EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH Width;
EFI_ACCESS_TYPE AccessType;
UINT64 Buffer;
UINTN Index;
UINTN Size;
// CHAR16 *ValueStr;
BOOLEAN Complete;
CHAR16 *InputStr;
BOOLEAN Interactive;
EFI_HANDLE *HandleBuffer;
UINTN BufferSize;
UINTN ItemValue;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *Temp;
Value = 0;
Address = 0;
PciEAddress = 0;
IoDev = NULL;
HandleBuffer = NULL;
BufferSize = 0;
SegmentNumber = 0;
ShellStatus = SHELL_SUCCESS;
InputStr = NULL;
//
// Parse arguments
//
Width = EfiPciWidthUint8;
Size = 1;
AccessType = EfiMemory;
// ValueStr = NULL;
Interactive = TRUE;
Package = NULL;
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), gShellDebug1HiiHandle, ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) < 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
} else if (ShellCommandLineGetCount(Package) > 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
} else if (ShellCommandLineGetFlag(Package, L"-w") && ShellCommandLineGetValue(Package, L"-w") == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"-w");
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
} else {
if (ShellCommandLineGetFlag(Package, L"-mmio")) {
AccessType = EFIMemoryMappedIo;
if (ShellCommandLineGetFlag(Package, L"-mem")
||ShellCommandLineGetFlag(Package, L"-io")
||ShellCommandLineGetFlag(Package, L"-pci")
||ShellCommandLineGetFlag(Package, L"-pcie")
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
} else if (ShellCommandLineGetFlag(Package, L"-mem")) {
AccessType = EfiMemory;
if (ShellCommandLineGetFlag(Package, L"-io")
||ShellCommandLineGetFlag(Package, L"-pci")
||ShellCommandLineGetFlag(Package, L"-pcie")
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
} else if (ShellCommandLineGetFlag(Package, L"-io")) {
AccessType = EfiIo;
if (ShellCommandLineGetFlag(Package, L"-pci")
||ShellCommandLineGetFlag(Package, L"-pcie")
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
} else if (ShellCommandLineGetFlag(Package, L"-pci")) {
AccessType = EfiPciConfig;
if (ShellCommandLineGetFlag(Package, L"-pcie")
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
} else if (ShellCommandLineGetFlag(Package, L"-pcie")) {
AccessType = EfiPciEConfig;
}
}
//
// Non interactive for a script file or for the specific parameter
//
if (gEfiShellProtocol->BatchIsActive() || ShellCommandLineGetFlag (Package, L"-n")) {
Interactive = FALSE;
}
Temp = ShellCommandLineGetValue(Package, L"-w");
if (Temp != NULL) {
ItemValue = ShellStrToUintn (Temp);
switch (ItemValue) {
case 1:
Width = EfiPciWidthUint8;
Size = 1;
break;
case 2:
Width = EfiPciWidthUint16;
Size = 2;
break;
case 4:
Width = EfiPciWidthUint32;
Size = 4;
break;
case 8:
Width = EfiPciWidthUint64;
Size = 8;
break;
default:
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellDebug1HiiHandle, L"-w");
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
}
Temp = ShellCommandLineGetRawValue(Package, 1);
if (!ShellIsHexOrDecimalNumber(Temp, TRUE, FALSE) || EFI_ERROR(ShellConvertStringToUint64(Temp, (UINT64*)&Address, TRUE, FALSE))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
Temp = ShellCommandLineGetRawValue(Package, 2);
if (Temp != NULL) {
//
// Per spec if value is specified, then -n is assumed.
//
Interactive = FALSE;
if (!ShellIsHexOrDecimalNumber(Temp, TRUE, FALSE) || EFI_ERROR(ShellConvertStringToUint64(Temp, &Value, TRUE, FALSE))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
switch (Size) {
case 1:
if (Value > 0xFF) {
ShellStatus = SHELL_INVALID_PARAMETER;
}
break;
case 2:
if (Value > 0xFFFF) {
ShellStatus = SHELL_INVALID_PARAMETER;
}
break;
case 4:
if (Value > 0xFFFFFFFF) {
ShellStatus = SHELL_INVALID_PARAMETER;
}
break;
default:
break;
}
if (ShellStatus != SHELL_SUCCESS) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
}
if ((Address & (Size - 1)) != 0) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_NOT_ALIGNED), gShellDebug1HiiHandle, Address);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
//
// locate DeviceIO protocol interface
//
if (AccessType != EfiMemory) {
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiPciRootBridgeIoProtocolGuid,
NULL,
&BufferSize,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PCIRBIO_NF), gShellDebug1HiiHandle);
ShellStatus = SHELL_NOT_FOUND;
goto Done;
}
//
// In the case of PCI or PCIE
// Get segment number and mask the segment bits in Address
//
if (AccessType == EfiPciEConfig) {
SegmentNumber = (UINT32) RShiftU64 (Address, 36) & 0xff;
Address &= 0xfffffffffULL;
} else {
if (AccessType == EfiPciConfig) {
SegmentNumber = (UINT32) RShiftU64 (Address, 32) & 0xff;
Address &= 0xffffffff;
}
}
//
// Find the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL of the specified segment number
//
for (Index = 0; Index < BufferSize; Index++) {
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiPciRootBridgeIoProtocolGuid,
(VOID *) &IoDev
);
if (EFI_ERROR (Status)) {
continue;
}
if (IoDev->SegmentNumber != SegmentNumber) {
IoDev = NULL;
}
}
if (IoDev == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_SEGMENT_NOT_FOUND), gShellDebug1HiiHandle, SegmentNumber);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
}
if (AccessType == EfiIo && Address + Size > 0x10000) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS_RANGE), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
goto Done;
}
if (AccessType == EfiPciEConfig) {
GetPciEAddressFromInputAddress (Address, &PciEAddress);
}
//
// Set value
//
if (ShellCommandLineGetRawValue(Package, 2) != NULL) {
if (AccessType == EFIMemoryMappedIo) {
IoDev->Mem.Write (IoDev, Width, Address, 1, &Value);
} else if (AccessType == EfiIo) {
IoDev->Io.Write (IoDev, Width, Address, 1, &Value);
} else if (AccessType == EfiPciConfig) {
IoDev->Pci.Write (IoDev, Width, Address, 1, &Value);
} else if (AccessType == EfiPciEConfig) {
IoDev->Pci.Write (IoDev, Width, PciEAddress, 1, &Value);
} else {
WriteMem (Width, Address, 1, &Value);
}
ASSERT(ShellStatus == SHELL_SUCCESS);
goto Done;
}
//
// non-interactive mode
//
if (!Interactive) {
Buffer = 0;
if (AccessType == EFIMemoryMappedIo) {
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MMIO), gShellDebug1HiiHandle);
}
IoDev->Mem.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiIo) {
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_IO), gShellDebug1HiiHandle);
}
IoDev->Io.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciConfig) {
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCI), gShellDebug1HiiHandle);
}
IoDev->Pci.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciEConfig) {
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCIE), gShellDebug1HiiHandle);
}
IoDev->Pci.Read (IoDev, Width, PciEAddress, 1, &Buffer);
} else {
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MEM), gShellDebug1HiiHandle);
}
ReadMem (Width, Address, 1, &Buffer);
}
if (!gEfiShellProtocol->BatchIsActive()) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS), gShellDebug1HiiHandle, Address);
}
if (Size == 1) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 4) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 8) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF16), gShellDebug1HiiHandle, Buffer);
}
ShellPrintEx(-1, -1, L"\r\n");
ASSERT(ShellStatus == SHELL_SUCCESS);
goto Done;
}
//
// interactive mode
//
Complete = FALSE;
do {
if (AccessType == EfiIo && Address + Size > 0x10000) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS_RANGE2), gShellDebug1HiiHandle);
break;
}
Buffer = 0;
if (AccessType == EFIMemoryMappedIo) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MMIO), gShellDebug1HiiHandle);
IoDev->Mem.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiIo) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_IO), gShellDebug1HiiHandle);
IoDev->Io.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciConfig) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCI), gShellDebug1HiiHandle);
IoDev->Pci.Read (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciEConfig) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCIE), gShellDebug1HiiHandle);
IoDev->Pci.Read (IoDev, Width, PciEAddress, 1, &Buffer);
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MEM), gShellDebug1HiiHandle);
ReadMem (Width, Address, 1, &Buffer);
}
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS), gShellDebug1HiiHandle, Address);
if (Size == 1) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 4) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, (UINTN)Buffer);
} else if (Size == 8) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF16), gShellDebug1HiiHandle, Buffer);
}
ShellPrintEx(-1, -1, L" > ");
//
// wait user input to modify
//
if (InputStr != NULL) {
FreePool(InputStr);
InputStr = NULL;
}
ShellPromptForResponse(ShellPromptResponseTypeFreeform, NULL, (VOID**)&InputStr);
//
// skip space characters
//
for (Index = 0; InputStr != NULL && InputStr[Index] == ' '; Index++);
//
// parse input string
//
if (InputStr != NULL && (InputStr[Index] == '.' || InputStr[Index] == 'q' || InputStr[Index] == 'Q')) {
Complete = TRUE;
} else if (InputStr == NULL || InputStr[Index] == CHAR_NULL) {
//
// Continue to next address
//
} else if (GetHex (InputStr + Index, &Buffer) && Buffer <= MaxNum[Width]) {
if (AccessType == EFIMemoryMappedIo) {
IoDev->Mem.Write (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiIo) {
IoDev->Io.Write (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciConfig) {
IoDev->Pci.Write (IoDev, Width, Address, 1, &Buffer);
} else if (AccessType == EfiPciEConfig) {
IoDev->Pci.Write (IoDev, Width, PciEAddress, 1, &Buffer);
} else {
WriteMem (Width, Address, 1, &Buffer);
}
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ERROR), gShellDebug1HiiHandle);
continue;
// PrintToken (STRING_TOKEN (STR_IOMOD_ERROR), HiiHandle);
}
Address += Size;
if (AccessType == EfiPciEConfig) {
GetPciEAddressFromInputAddress (Address, &PciEAddress);
}
ShellPrintEx(-1, -1, L"\r\n");
// Print (L"\n");
} while (!Complete);
}
ASSERT(ShellStatus == SHELL_SUCCESS);
Done:
if (InputStr != NULL) {
FreePool(InputStr);
}
if (HandleBuffer != NULL) {
FreePool (HandleBuffer);
}
if (Package != NULL) {
ShellCommandLineFreeVarList (Package);
}
return ShellStatus;
}
/**
Function for 'reset' 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
ShellCommandRunReset (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CONST CHAR16 *String;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
UINT64 OsIndications;
UINT32 Attr;
UINTN DataSize;
ShellStatus = SHELL_SUCCESS;
ProblemParam = NULL;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (ResetParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR(Status)) {
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"reset", ProblemParam);
FreePool(ProblemParam);
return (SHELL_INVALID_PARAMETER);
} else {
ASSERT(FALSE);
}
} else {
//
// check for "-?"
//
if (ShellCommandLineGetFlag(Package, L"-?")) {
ASSERT(FALSE);
} else if (ShellCommandLineGetRawValue(Package, 1) != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"reset");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
if (ShellCommandLineGetFlag (Package, L"-fwui")) {
DataSize = sizeof (OsIndications);
Status = gRT->GetVariable (
EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME, &gEfiGlobalVariableGuid,
&Attr, &DataSize, &OsIndications
);
if (!EFI_ERROR (Status)) {
if ((OsIndications & EFI_OS_INDICATIONS_BOOT_TO_FW_UI) != 0) {
DataSize = sizeof (OsIndications);
Status = gRT->GetVariable (
EFI_OS_INDICATIONS_VARIABLE_NAME, &gEfiGlobalVariableGuid,
&Attr, &DataSize, &OsIndications
);
if (!EFI_ERROR (Status)) {
OsIndications |= EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
} else {
OsIndications = EFI_OS_INDICATIONS_BOOT_TO_FW_UI;
}
Status = gRT->SetVariable (
EFI_OS_INDICATIONS_VARIABLE_NAME, &gEfiGlobalVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof (OsIndications), &OsIndications
);
}
}
if (EFI_ERROR (Status)) {
ShellStatus = SHELL_UNSUPPORTED;
goto Error;
}
}
//
// check for warm reset flag, then shutdown reset flag, then cold (default) reset flag
//
if (ShellCommandLineGetFlag(Package, L"-w")) {
if (ShellCommandLineGetFlag(Package, L"-s") || ShellCommandLineGetFlag(Package, L"-c")) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"reset");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
String = ShellCommandLineGetValue(Package, L"-w");
if (String != NULL) {
gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, StrSize(String), (VOID*)String);
} else {
gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
}
}
} else if (ShellCommandLineGetFlag(Package, L"-s")) {
if (ShellCommandLineGetFlag(Package, L"-c")) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"reset");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
String = ShellCommandLineGetValue(Package, L"-s");
DEBUG_CODE(ShellPrintEx(-1,-1,L"Reset with %s (%d bytes)", String, String!=NULL?StrSize(String):0););
if (String != NULL) {
gRT->ResetSystem(EfiResetShutdown, EFI_SUCCESS, StrSize(String), (VOID*)String);
} else {
gRT->ResetSystem(EfiResetShutdown, EFI_SUCCESS, 0, NULL);
}
}
} else {
//
// this is default so dont worry about flag...
//
String = ShellCommandLineGetValue(Package, L"-c");
if (String != NULL) {
gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, StrSize(String), (VOID*)String);
} else {
gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
}
}
}
