/** 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); }
EFI_STATUS SEnvCmdEcho ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) /*++ Routine Description: Shell command "echo". Arguments: ImageHandle - The image handle SystemTable - The system table Returns: --*/ { EFI_STATUS Status; SHELL_VAR_CHECK_CODE RetCode; CHAR16 *Useful; SHELL_VAR_CHECK_PACKAGE ChkPck; SHELL_ARG_LIST *Item; BOOLEAN PageBreak; EFI_SHELL_APP_INIT (ImageHandle, SystemTable); if (!EFI_PROPER_VERSION (0, 99)) { PrintToken ( STRING_TOKEN (STR_SHELLENV_GNC_COMMAND_NOT_SUPPORT), HiiEnvHandle, L"echo", EFI_VERSION_0_99 ); Status = EFI_UNSUPPORTED; goto Done; } Status = EFI_SUCCESS; PageBreak = FALSE; ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE)); // // No args: print status // One arg, either -on or -off: set console echo flag // Otherwise: echo all the args. Shell parser will expand any args or vars. // RetCode = LibCheckVariables (SI, EchoCheckList, &ChkPck, &Useful); if (VarCheckOk != RetCode) { switch (RetCode) { case VarCheckDuplicate: PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiEnvHandle, L"echo", Useful); break; case VarCheckUnknown: PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiEnvHandle, L"echo", Useful); break; case VarCheckConflict: PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiEnvHandle, L"echo", Useful); break; default: break; } Status = EFI_INVALID_PARAMETER; goto Done; } if (LibCheckVarGetFlag (&ChkPck, L"-b") != NULL) { EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF); PageBreak = TRUE; } // // Out put help. // if (LibCheckVarGetFlag (&ChkPck, L"-?") != NULL) { if (IS_OLD_SHELL) { PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle); } else if (ChkPck.ValueCount > 0 || ChkPck.FlagCount > 2 || (2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b")) ) { PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo"); Status = EFI_INVALID_PARAMETER; } else { PrintToken (STRING_TOKEN (STR_SHELLENV_ECHO_VERBOSE_HELP), HiiEnvHandle); } goto Done; } if (LibCheckVarGetFlag (&ChkPck, L"-on") != NULL) { if (ChkPck.ValueCount != 0) { PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo"); Status = EFI_INVALID_PARAMETER; goto Done; } else { SEnvBatchSetEcho (TRUE); } } else if (LibCheckVarGetFlag (&ChkPck, L"-off") != NULL) { if (ChkPck.ValueCount != 0) { PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiEnvHandle, L"echo"); Status = EFI_INVALID_PARAMETER; goto Done; } else { SEnvBatchSetEcho (FALSE); } } if ((ChkPck.FlagCount == 0 || (1 == ChkPck.FlagCount && PageBreak)) && ChkPck.ValueCount == 0) { PrintToken (STRING_TOKEN (STR_SHELLENV_ECHO_ECHO_IS), HiiEnvHandle, (SEnvBatchGetEcho () ? L"on" : L"off")); } else if (ChkPck.ValueCount > 0) { Item = GetFirstArg (&ChkPck); for (;;) { Print (L"%s", Item->VarStr); Item = GetNextArg (Item); if (!Item) { break; } Print (L" "); } Print (L"\n"); } Done: LibCheckVarFreeVarList (&ChkPck); return Status; }
/** 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; 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 to parse the Data by the type of Data, and save in the Buffer. @param[in] Data A pointer to a buffer to be parsed. @param[out] Buffer A pointer to a buffer to hold the return data. @param[in,out] BufferSize On input, indicates the size of Buffer in bytes. On output,indicates the size of data return in Buffer. Or the size in bytes of the buffer needed to obtain. @retval EFI_INVALID_PARAMETER The Buffer or BufferSize is NULL. @retval EFI_BUFFER_TOO_SMALL The Buffer is too small to hold the data. @retval EFI_OUT_OF_RESOURCES A memory allcation failed. @retval EFI_SUCCESS The Data parsed successful and save in the Buffer. **/ EFI_STATUS ParseParameterData ( IN CONST CHAR16 *Data, OUT VOID *Buffer, IN OUT UINTN *BufferSize ) { UINT64 HexNumber; UINTN HexNumberLen; UINTN Size; CHAR8 *AsciiBuffer; DATA_TYPE DataType; EFI_DEVICE_PATH_PROTOCOL *DevPath; EFI_STATUS Status; HexNumber = 0; HexNumberLen = 0; Size = 0; AsciiBuffer = NULL; DevPath = NULL; Status = EFI_SUCCESS; if (Data == NULL || BufferSize == NULL) { return EFI_INVALID_PARAMETER; } DataType = TestDataType (Data); if (DataType == DataTypeHexNumber) { // // hex number // StrHexToUint64S (Data + 2, NULL, &HexNumber); HexNumberLen = StrLen (Data + 2); if (HexNumberLen >= 1 && HexNumberLen <= 2) { Size = 1; } else if (HexNumberLen >= 3 && HexNumberLen <= 4) { Size = 2; } else if (HexNumberLen >= 5 && HexNumberLen <= 8) { Size = 4; } else if (HexNumberLen >= 9 && HexNumberLen <= 16) { Size = 8; } if (Buffer != NULL && *BufferSize >= Size) { CopyMem(Buffer, (VOID *)&HexNumber, Size); } else { Status = EFI_BUFFER_TOO_SMALL; } *BufferSize = Size; } else if (DataType == DataTypeHexArray) { // // hex array // if (*Data == L'H') { Data = Data + 1; } Size = StrLen (Data) / 2; if (Buffer != NULL && *BufferSize >= Size) { StrHexToBytes(Data, StrLen (Data), (UINT8 *)Buffer, Size); } else { Status = EFI_BUFFER_TOO_SMALL; } *BufferSize = Size; } else if (DataType == DataTypeAscii) { // // ascii text // if (*Data == L'S') { Data = Data + 1; } AsciiBuffer = AllocateZeroPool (StrSize (Data) / 2); if (AsciiBuffer == NULL) { Status = EFI_OUT_OF_RESOURCES; } else { AsciiSPrint (AsciiBuffer, StrSize (Data) / 2, "%s", (CHAR8 *)Data); Size = StrSize (Data) / 2 - 1; if (Buffer != NULL && *BufferSize >= Size) { CopyMem (Buffer, AsciiBuffer, Size); } else { Status = EFI_BUFFER_TOO_SMALL; } *BufferSize = Size; } SHELL_FREE_NON_NULL (AsciiBuffer); } else if (DataType == DataTypeUnicode) { // // unicode text // if (*Data == L'L') { Data = Data + 1; } Size = StrSize (Data) - sizeof (CHAR16); if (Buffer != NULL && *BufferSize >= Size) { CopyMem (Buffer, Data, Size); } else { Status = EFI_BUFFER_TOO_SMALL; } *BufferSize = Size; } else if (DataType == DataTypeDevicePath) { if (*Data == L'P') { Data = Data + 1; } else if (StrnCmp (Data, L"--", 2) == 0) { Data = Data + 2; } DevPath = ConvertTextToDevicePath (Data); if (DevPath == NULL) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, L"setvar"); Status = EFI_INVALID_PARAMETER; } else { Size = GetDevicePathSize (DevPath); if (Buffer != NULL && *BufferSize >= Size) { CopyMem (Buffer, DevPath, Size); } else { Status = EFI_BUFFER_TOO_SMALL; } *BufferSize = Size; } SHELL_FREE_NON_NULL (DevPath); } else { Status = EFI_INVALID_PARAMETER; } return Status; }
/** 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); }
/// Timer Specific Information. TIMER_INFO TimerInfo; /// Items for which to gather cumulative statistics. PERF_CUM_DATA CumData[] = { PERF_INIT_CUM_DATA (LOAD_IMAGE_TOK), PERF_INIT_CUM_DATA (START_IMAGE_TOK), PERF_INIT_CUM_DATA (DRIVERBINDING_START_TOK), PERF_INIT_CUM_DATA (DRIVERBINDING_SUPPORT_TOK) }; /// Number of items for which we are gathering cumulative statistics. UINT32 const NumCum = sizeof(CumData) / sizeof(PERF_CUM_DATA); PARAM_ITEM_LIST ParamList[] = { {STRING_TOKEN (STR_DP_OPTION_QH), TypeFlag}, // -? Help {STRING_TOKEN (STR_DP_OPTION_LH), TypeFlag}, // -h Help {STRING_TOKEN (STR_DP_OPTION_UH), TypeFlag}, // -H Help {STRING_TOKEN (STR_DP_OPTION_LV), TypeFlag}, // -v Verbose Mode {STRING_TOKEN (STR_DP_OPTION_UA), TypeFlag}, // -A All, Cooked {STRING_TOKEN (STR_DP_OPTION_UR), TypeFlag}, // -R RAW All {STRING_TOKEN (STR_DP_OPTION_LS), TypeFlag}, // -s Summary #if PROFILING_IMPLEMENTED {STRING_TOKEN (STR_DP_OPTION_UP), TypeFlag}, // -P Dump Profile Data {STRING_TOKEN (STR_DP_OPTION_UT), TypeFlag}, // -T Dump Trace Data #endif {STRING_TOKEN (STR_DP_OPTION_LX), TypeFlag}, // -x eXclude Cumulative Items {STRING_TOKEN (STR_DP_OPTION_LI), TypeFlag}, // -i Display Identifier {STRING_TOKEN (STR_DP_OPTION_LC), TypeValue}, // -c Display cumulative data. {STRING_TOKEN (STR_DP_OPTION_LN), TypeValue}, // -n # Number of records to display for A and R {STRING_TOKEN (STR_DP_OPTION_LT), TypeValue} // -t # Threshold of interest
/** Dump performance data. @param[in] ImageHandle The image handle. @param[in] SystemTable The system table. @retval EFI_SUCCESS Command completed successfully. @retval EFI_INVALID_PARAMETER Command usage error. @retval EFI_ABORTED The user aborts the operation. @retval value Unknown error. **/ EFI_STATUS EFIAPI InitializeDp ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { UINT64 Freq; UINT64 Ticker; UINT32 ListIndex; LIST_ENTRY *ParamPackage; CONST CHAR16 *CmdLineArg; EFI_STRING StringPtr; UINTN Number2Display; EFI_STATUS Status; BOOLEAN SummaryMode; BOOLEAN VerboseMode; BOOLEAN AllMode; BOOLEAN RawMode; BOOLEAN TraceMode; BOOLEAN ProfileMode; BOOLEAN ExcludeMode; BOOLEAN CumulativeMode; CONST CHAR16 *CustomCumulativeToken; PERF_CUM_DATA *CustomCumulativeData; EFI_STRING StringDpOptionQh; EFI_STRING StringDpOptionLh; EFI_STRING StringDpOptionUh; EFI_STRING StringDpOptionLv; EFI_STRING StringDpOptionUs; EFI_STRING StringDpOptionLs; EFI_STRING StringDpOptionUa; EFI_STRING StringDpOptionUr; EFI_STRING StringDpOptionUt; EFI_STRING StringDpOptionUp; EFI_STRING StringDpOptionLx; EFI_STRING StringDpOptionLn; EFI_STRING StringDpOptionLt; EFI_STRING StringDpOptionLi; EFI_STRING StringDpOptionLc; SummaryMode = FALSE; VerboseMode = FALSE; AllMode = FALSE; RawMode = FALSE; TraceMode = FALSE; ProfileMode = FALSE; ExcludeMode = FALSE; CumulativeMode = FALSE; CustomCumulativeData = NULL; StringDpOptionQh = NULL; StringDpOptionLh = NULL; StringDpOptionUh = NULL; StringDpOptionLv = NULL; StringDpOptionUs = NULL; StringDpOptionLs = NULL; StringDpOptionUa = NULL; StringDpOptionUr = NULL; StringDpOptionUt = NULL; StringDpOptionUp = NULL; StringDpOptionLx = NULL; StringDpOptionLn = NULL; StringDpOptionLt = NULL; StringDpOptionLi = NULL; StringDpOptionLc = NULL; StringPtr = NULL; // Get DP's entry time as soon as possible. // This is used as the Shell-Phase end time. // Ticker = GetPerformanceCounter (); // Register our string package with HII and return the handle to it. // gHiiHandle = HiiAddPackages (&gEfiCallerIdGuid, ImageHandle, DPStrings, NULL); ASSERT (gHiiHandle != NULL); // Initial the command list // InitialShellParamList (); /**************************************************************************** **** Process Command Line arguments **** ****************************************************************************/ Status = ShellCommandLineParse (DpParamList, &ParamPackage, NULL, TRUE); if (EFI_ERROR(Status)) { PrintToken (STRING_TOKEN (STR_DP_INVALID_ARG)); ShowHelp(); } else { StringDpOptionQh = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_QH), NULL); StringDpOptionLh = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LH), NULL); StringDpOptionUh = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_UH), NULL); if (ShellCommandLineGetFlag (ParamPackage, StringDpOptionQh) || ShellCommandLineGetFlag (ParamPackage, StringDpOptionLh) || ShellCommandLineGetFlag (ParamPackage, StringDpOptionUh)) { ShowHelp(); } else { StringDpOptionLv = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LV), NULL); StringDpOptionUs = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_US), NULL); StringDpOptionLs = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LS), NULL); StringDpOptionUa = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_UA), NULL); StringDpOptionUr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_UR), NULL); StringDpOptionUt = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_UT), NULL); StringDpOptionUp = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_UP), NULL); StringDpOptionLx = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LX), NULL); StringDpOptionLn = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LN), NULL); StringDpOptionLt = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LT), NULL); StringDpOptionLi = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LI), NULL); StringDpOptionLc = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_OPTION_LC), NULL); // Boolean Options // VerboseMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionLv); SummaryMode = (BOOLEAN) (ShellCommandLineGetFlag (ParamPackage, StringDpOptionUs) || ShellCommandLineGetFlag (ParamPackage, StringDpOptionLs)); AllMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionUa); RawMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionUr); #if PROFILING_IMPLEMENTED TraceMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionUt); ProfileMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionUp); #endif // PROFILING_IMPLEMENTED ExcludeMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionLx); mShowId = ShellCommandLineGetFlag (ParamPackage, StringDpOptionLi); CumulativeMode = ShellCommandLineGetFlag (ParamPackage, StringDpOptionLc); // Options with Values CmdLineArg = ShellCommandLineGetValue (ParamPackage, StringDpOptionLn); if (CmdLineArg == NULL) { Number2Display = DEFAULT_DISPLAYCOUNT; } else { Number2Display = StrDecimalToUintn(CmdLineArg); if (Number2Display == 0) { Number2Display = MAXIMUM_DISPLAYCOUNT; } } CmdLineArg = ShellCommandLineGetValue (ParamPackage, StringDpOptionLt); if (CmdLineArg == NULL) { mInterestThreshold = DEFAULT_THRESHOLD; // 1ms := 1,000 us } else { mInterestThreshold = StrDecimalToUint64(CmdLineArg); } // Handle Flag combinations and default behaviors // If both TraceMode and ProfileMode are FALSE, set them both to TRUE if ((! TraceMode) && (! ProfileMode)) { TraceMode = TRUE; #if PROFILING_IMPLEMENTED ProfileMode = TRUE; #endif // PROFILING_IMPLEMENTED } // // Init the custom cumulative data. // CustomCumulativeToken = ShellCommandLineGetValue (ParamPackage, StringDpOptionLc); if (CustomCumulativeToken != NULL) { CustomCumulativeData = AllocateZeroPool (sizeof (PERF_CUM_DATA)); ASSERT (CustomCumulativeData != NULL); CustomCumulativeData->MinDur = 0; CustomCumulativeData->MaxDur = 0; CustomCumulativeData->Count = 0; CustomCumulativeData->Duration = 0; CustomCumulativeData->Name = AllocateZeroPool (StrLen (CustomCumulativeToken) + 1); UnicodeStrToAsciiStr (CustomCumulativeToken, CustomCumulativeData->Name); } /**************************************************************************** **** Timer specific processing **** ****************************************************************************/ // Get the Performance counter characteristics: // Freq = Frequency in Hz // StartCount = Value loaded into the counter when it starts counting // EndCount = Value counter counts to before it needs to be reset // Freq = GetPerformanceCounterProperties (&TimerInfo.StartCount, &TimerInfo.EndCount); // Convert the Frequency from Hz to KHz TimerInfo.Frequency = (UINT32)DivU64x32 (Freq, 1000); // Determine in which direction the performance counter counts. TimerInfo.CountUp = (BOOLEAN) (TimerInfo.EndCount >= TimerInfo.StartCount); /**************************************************************************** **** Print heading **** ****************************************************************************/ // print DP's build version PrintToken (STRING_TOKEN (STR_DP_BUILD_REVISION), DP_MAJOR_VERSION, DP_MINOR_VERSION); // print performance timer characteristics PrintToken (STRING_TOKEN (STR_DP_KHZ), TimerInfo.Frequency); // Print Timer frequency in KHz if ((VerboseMode) && (! RawMode) ) { StringPtr = HiiGetString (gHiiHandle, (EFI_STRING_ID) (TimerInfo.CountUp ? STRING_TOKEN (STR_DP_UP) : STRING_TOKEN (STR_DP_DOWN)), NULL); ASSERT (StringPtr != NULL); PrintToken (STRING_TOKEN (STR_DP_TIMER_PROPERTIES), // Print Timer count range and direction StringPtr, TimerInfo.StartCount, TimerInfo.EndCount ); PrintToken (STRING_TOKEN (STR_DP_VERBOSE_THRESHOLD), mInterestThreshold); } /* ************************************************************************** **** Print Sections based on command line options **** **** Option modes have the following priority: **** v Verbose -- Valid in combination with any other options **** t Threshold -- Modifies All, Raw, and Cooked output **** Default is 0 for All and Raw mode **** Default is DEFAULT_THRESHOLD for "Cooked" mode **** n Number2Display Used by All and Raw mode. Otherwise ignored. **** A All -- R and S options are ignored **** R Raw -- S option is ignored **** s Summary -- Modifies "Cooked" output only **** Cooked (Default) **** **** The All, Raw, and Cooked modes are modified by the Trace and Profile **** options. **** !T && !P := (0) Default, Both are displayed **** T && !P := (1) Only Trace records are displayed **** !T && P := (2) Only Profile records are displayed **** T && P := (3) Same as Default, both are displayed ****************************************************************************/ GatherStatistics (CustomCumulativeData); if (CumulativeMode) { ProcessCumulative (CustomCumulativeData); } else if (AllMode) { if (TraceMode) { Status = DumpAllTrace( Number2Display, ExcludeMode); if (Status == EFI_ABORTED) { goto Done; } } if (ProfileMode) { DumpAllProfile( Number2Display, ExcludeMode); } } else if (RawMode) { if (TraceMode) { Status = DumpRawTrace( Number2Display, ExcludeMode); if (Status == EFI_ABORTED) { goto Done; } } if (ProfileMode) { DumpRawProfile( Number2Display, ExcludeMode); } } else { //------------- Begin Cooked Mode Processing if (TraceMode) { ProcessPhases ( Ticker ); if ( ! SummaryMode) { Status = ProcessHandles ( ExcludeMode); if (Status == EFI_ABORTED) { goto Done; } Status = ProcessPeims (); if (Status == EFI_ABORTED) { goto Done; } Status = ProcessGlobal (); if (Status == EFI_ABORTED) { goto Done; } ProcessCumulative (NULL); } } if (ProfileMode) { DumpAllProfile( Number2Display, ExcludeMode); } } //------------- End of Cooked Mode Processing if ( VerboseMode || SummaryMode) { DumpStatistics(); } } } Done: // // Free the memory allocate from HiiGetString // ListIndex = 0; while (DpParamList[ListIndex].Name != NULL) { FreePool (DpParamList[ListIndex].Name); ListIndex ++; } FreePool (DpParamList); SafeFreePool (StringDpOptionQh); SafeFreePool (StringDpOptionLh); SafeFreePool (StringDpOptionUh); SafeFreePool (StringDpOptionLv); SafeFreePool (StringDpOptionUs); SafeFreePool (StringDpOptionLs); SafeFreePool (StringDpOptionUa); SafeFreePool (StringDpOptionUr); SafeFreePool (StringDpOptionUt); SafeFreePool (StringDpOptionUp); SafeFreePool (StringDpOptionLx); SafeFreePool (StringDpOptionLn); SafeFreePool (StringDpOptionLt); SafeFreePool (StringDpOptionLi); SafeFreePool (StringDpOptionLc); SafeFreePool (StringPtr); SafeFreePool (mPrintTokenBuffer); if (CustomCumulativeData != NULL) { SafeFreePool (CustomCumulativeData->Name); } SafeFreePool (CustomCumulativeData); HiiRemovePackages (gHiiHandle); return Status; }
/** Function for 'mkdir' 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 ShellCommandRunMkDir ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; CONST CHAR16 *NewDirName; UINTN DirCreateCount; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_FILE_HANDLE FileHandle; SHELL_STATUS ShellStatus; ShellStatus = SHELL_SUCCESS; // // initialize the shell lib (we must be in non-auto-init...) // Status = ShellInitialize(); ASSERT_EFI_ERROR(Status); // // parse the command line // Status = ShellCommandLineParse (EmptyParamList, &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"mkdir", ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { // // check for "-?" // if (ShellCommandLineGetFlag(Package, L"-?")) { ASSERT(FALSE); } // // create a set of directories // if (ShellCommandLineGetRawValue(Package, 1) == NULL) { // // we didnt get a single parameter // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"mkdir"); ShellStatus = SHELL_INVALID_PARAMETER; } else { for ( DirCreateCount = 1 ; ; DirCreateCount++ ){ // // loop through each directory specified // NewDirName = ShellCommandLineGetRawValue(Package, DirCreateCount); if (NewDirName == NULL) { break; } // // check if that already exists... if yes fail // FileHandle = NULL; Status = ShellOpenFileByName(NewDirName, &FileHandle, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE, EFI_FILE_DIRECTORY ); if (!EFI_ERROR(Status)) { ShellCloseFile(&FileHandle); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MKDIR_ALREADY), gShellLevel2HiiHandle, NewDirName); ShellStatus = SHELL_INVALID_PARAMETER; break; } else { ASSERT(FileHandle == NULL); // // create the directory named NewDirName // Status = ShellCreateDirectory(NewDirName, &FileHandle); if (FileHandle != NULL) { gEfiShellProtocol->CloseFile(FileHandle); } if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MKDIR_CREATEFAIL), gShellLevel2HiiHandle, NewDirName); ShellStatus = SHELL_ACCESS_DENIED; break; } } } } } // // free the command line package // ShellCommandLineFreeVarList (Package); return (ShellStatus); }
EFI_STATUS EFIAPI SEnvCmdGoto ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) /*++ Routine Description: Transfers execution of batch file to location following a label (:labelname). Arguments: ImageHandle The image handle SystemTable The system table Returns: EFI_SUCCESS The command finished sucessfully EFI_UNSUPPORTED Unsupported EFI_INVALID_PARAMETER Invalid parameter EFI_OUT_OF_RESOURCES Out of resources --*/ { EFI_STATUS Status; EFI_SHELL_APP_INIT (ImageHandle, SystemTable); // // Output help // if (SI->Argc == 2) { if (StriCmp (SI->Argv[1], L"-?") == 0) { if (IS_OLD_SHELL) { PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle); } else { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_VERBOSE_HELP), HiiEnvHandle); } return EFI_SUCCESS; } } else if (SI->Argc == 3) { if ((StriCmp (SI->Argv[1], L"-?") == 0 && StriCmp (SI->Argv[2], L"-b") == 0) || (StriCmp (SI->Argv[2], L"-?") == 0 && StriCmp (SI->Argv[1], L"-b") == 0) ) { EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF); if (IS_OLD_SHELL) { PrintToken (STRING_TOKEN (STR_NO_HELP), HiiEnvHandle); } else { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_VERBOSE_HELP), HiiEnvHandle); } return EFI_SUCCESS; } } if (!SEnvBatchIsActive ()) { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_ONLY_SUPPORTED_SCRIPT), HiiEnvHandle); return EFI_UNSUPPORTED; } if (SI->Argc > 2) { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_TOO_MANY_ARGS), HiiEnvHandle, SEnvGetLineNumber ()); SEnvSetBatchAbort (); return EFI_INVALID_PARAMETER; } if (SI->Argc < 2) { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_TOO_FEW_ARGS), HiiEnvHandle, SEnvGetLineNumber ()); SEnvSetBatchAbort (); return EFI_INVALID_PARAMETER; } TargetLabel = StrDuplicate (SI->Argv[1]); if (TargetLabel == NULL) { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_OUT_OF_RESOURCES), HiiEnvHandle); SEnvSetBatchAbort (); return EFI_OUT_OF_RESOURCES; } SEnvBatchSetGotoActive (); Status = SEnvBatchResetJumpStmt (); if (EFI_ERROR (Status)) { PrintToken (STRING_TOKEN (STR_SHELLENV_GOTO_CANNOT_EXECUTE_SCRIPT), HiiEnvHandle, Status); SEnvSetBatchAbort (); return Status; } return Status; }
VOID UpdateFileExplorePage ( IN BMM_CALLBACK_DATA *CallbackData, BM_MENU_OPTION *MenuOption ) /*++ Routine Description: Update the File Explore page. Arguments: MenuOption - Pointer to menu options to display. Returns: None. --*/ { UINT8 *Location; UINTN Index; BM_MENU_ENTRY *NewMenuEntry; BM_FILE_CONTEXT *NewFileContext; FORM_ID FormId; NewMenuEntry = NULL; NewFileContext = NULL; FormId = 0; // // Clean up file explore page. // RefreshUpdateData (FALSE, 0, FALSE, 0, 0xff); // // Remove all op-codes from dynamic page // CallbackData->Hii->UpdateForm ( CallbackData->Hii, CallbackData->FeHiiHandle, FORM_FILE_EXPLORER_ID, FALSE, UpdateData ); RefreshUpdateData (TRUE, (EFI_PHYSICAL_ADDRESS) (UINTN) CallbackData->FeCallbackHandle, FALSE, 0, 0); Location = (UINT8 *) &UpdateData->Data; for (Index = 0; Index < MenuOption->MenuNumber; Index++) { NewMenuEntry = BOpt_GetMenuEntry (MenuOption, Index); NewFileContext = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext; if (NewFileContext->IsBootLegacy) { continue; } if ((NewFileContext->IsDir) || (BOOT_FROM_FILE_STATE == CallbackData->FeCurrentState)) { // // Create Text opcode for directory, also create Text opcode for file in BOOT_FROM_FILE_STATE. // CreateTextOpCode ( NewMenuEntry->DisplayStringToken, STR_NULL_STRING, STR_NULL_STRING, EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS, (UINT16) (FILE_OPTION_OFFSET + Index), Location ); } else { // // Create Goto opcode for file in ADD_BOOT_OPTION_STATE or ADD_DRIVER_OPTION_STATE. // if (ADD_BOOT_OPTION_STATE == CallbackData->FeCurrentState) { FormId = FORM_BOOT_ADD_DESCRIPTION_ID; } else if (ADD_DRIVER_OPTION_STATE == CallbackData->FeCurrentState) { FormId = FORM_DRIVER_ADD_FILE_DESCRIPTION_ID; } CreateGotoOpCode ( FormId, NewMenuEntry->DisplayStringToken, STRING_TOKEN (STR_NULL_STRING), EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS, (UINT16) (FILE_OPTION_OFFSET + Index), Location ); } UpdateData->DataCount++; Location = Location + ((EFI_IFR_OP_HEADER *) Location)->Length; } CallbackData->Hii->UpdateForm ( CallbackData->Hii, CallbackData->FeHiiHandle, FORM_FILE_EXPLORER_ID, TRUE, UpdateData ); }
/** Perform the memory test base on the memory test intensive level, and update the memory resource. @param Level The memory test intensive level. @retval EFI_STATUS Success test all the system memory and update the memory resource **/ EFI_STATUS EFIAPI BdsMemoryTest ( IN EXTENDMEM_COVERAGE_LEVEL Level ) { EFI_STATUS Status; EFI_STATUS KeyStatus; EFI_STATUS InitStatus; EFI_STATUS ReturnStatus; BOOLEAN RequireSoftECCInit; EFI_GENERIC_MEMORY_TEST_PROTOCOL *GenMemoryTest; UINT64 TestedMemorySize; UINT64 TotalMemorySize; UINTN TestPercent; UINT64 PreviousValue; BOOLEAN ErrorOut; BOOLEAN TestAbort; EFI_INPUT_KEY Key; CHAR16 StrPercent[80]; CHAR16 *StrTotalMemory; CHAR16 *Pos; CHAR16 *TmpStr; EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground; EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background; EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color; BOOLEAN IsFirstBoot; UINT32 TempData; UINTN StrTotalMemorySize; ReturnStatus = EFI_SUCCESS; ZeroMem (&Key, sizeof (EFI_INPUT_KEY)); StrTotalMemorySize = 128; Pos = AllocateZeroPool (StrTotalMemorySize); if (Pos == NULL) { return ReturnStatus; } StrTotalMemory = Pos; TestedMemorySize = 0; TotalMemorySize = 0; PreviousValue = 0; ErrorOut = FALSE; TestAbort = FALSE; SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff); SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0); SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff); RequireSoftECCInit = FALSE; Status = gBS->LocateProtocol ( &gEfiGenericMemTestProtocolGuid, NULL, (VOID **) &GenMemoryTest ); if (EFI_ERROR (Status)) { FreePool (Pos); return EFI_SUCCESS; } InitStatus = GenMemoryTest->MemoryTestInit ( GenMemoryTest, Level, &RequireSoftECCInit ); if (InitStatus == EFI_NO_MEDIA) { // // The PEI codes also have the relevant memory test code to check the memory, // it can select to test some range of the memory or all of them. If PEI code // checks all the memory, this BDS memory test will has no not-test memory to // do the test, and then the status of EFI_NO_MEDIA will be returned by // "MemoryTestInit". So it does not need to test memory again, just return. // FreePool (Pos); return EFI_SUCCESS; } if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) { TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST)); if (TmpStr != NULL) { PrintXY (10, 10, NULL, NULL, TmpStr); FreePool (TmpStr); } } else { DEBUG ((EFI_D_INFO, "Enter memory test.\n")); } do { Status = GenMemoryTest->PerformMemoryTest ( GenMemoryTest, &TestedMemorySize, &TotalMemorySize, &ErrorOut, TestAbort ); if (ErrorOut && (Status == EFI_DEVICE_ERROR)) { TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR)); if (TmpStr != NULL) { PrintXY (10, 10, NULL, NULL, TmpStr); FreePool (TmpStr); } ASSERT (0); } if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) { TempData = (UINT32) DivU64x32 (TotalMemorySize, 16); TestPercent = (UINTN) DivU64x32 ( DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16), TempData ); if (TestPercent != PreviousValue) { UnicodeValueToString (StrPercent, 0, TestPercent, 0); TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT)); if (TmpStr != NULL) { // // TmpStr size is 64, StrPercent is reserved to 16. // StrnCatS ( StrPercent, sizeof (StrPercent) / sizeof (CHAR16), TmpStr, sizeof (StrPercent) / sizeof (CHAR16) - StrLen (StrPercent) - 1 ); PrintXY (10, 10, NULL, NULL, StrPercent); FreePool (TmpStr); } TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST)); if (TmpStr != NULL) { PlatformBdsShowProgress ( Foreground, Background, TmpStr, Color, TestPercent, (UINTN) PreviousValue ); FreePool (TmpStr); } } PreviousValue = TestPercent; } else { DEBUG ((EFI_D_INFO, "Perform memory test (ESC to skip).\n")); } if (!PcdGetBool (PcdConInConnectOnDemand)) { KeyStatus = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key); if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) { if (!RequireSoftECCInit) { if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) { TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST)); if (TmpStr != NULL) { PlatformBdsShowProgress ( Foreground, Background, TmpStr, Color, 100, (UINTN) PreviousValue ); FreePool (TmpStr); } PrintXY (10, 10, NULL, NULL, L"100"); } Status = GenMemoryTest->Finished (GenMemoryTest); goto Done; } TestAbort = TRUE; } } } while (Status != EFI_NOT_FOUND); Status = GenMemoryTest->Finished (GenMemoryTest); Done: if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) { UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0); if (StrTotalMemory[0] == L',') { StrTotalMemory++; StrTotalMemorySize -= sizeof (CHAR16); } TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED)); if (TmpStr != NULL) { StrnCatS ( StrTotalMemory, StrTotalMemorySize / sizeof (CHAR16), TmpStr, StrTotalMemorySize / sizeof (CHAR16) - StrLen (StrTotalMemory) - 1 ); FreePool (TmpStr); } PrintXY (10, 10, NULL, NULL, StrTotalMemory); PlatformBdsShowProgress ( Foreground, Background, StrTotalMemory, Color, 100, (UINTN) PreviousValue ); } else { DEBUG ((EFI_D_INFO, "%d bytes of system memory tested OK\r\n", TotalMemorySize)); } FreePool (Pos); // // Use a DynamicHii type pcd to save the boot status, which is used to // control configuration mode, such as FULL/MINIMAL/NO_CHANGES configuration. // IsFirstBoot = PcdGetBool(PcdBootState); if (IsFirstBoot) { Status = PcdSetBoolS(PcdBootState, FALSE); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Set PcdBootState to FALSE failed.\n")); } } return ReturnStatus; }
/** Function for 'cp' 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 ShellCommandRunCp ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; UINTN ParamCount; UINTN LoopCounter; EFI_SHELL_FILE_INFO *FileList; BOOLEAN SilentMode; BOOLEAN RecursiveMode; CONST CHAR16 *Cwd; CHAR16 *FullCwd; ProblemParam = NULL; ShellStatus = SHELL_SUCCESS; ParamCount = 0; FileList = 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), gShellLevel2HiiHandle, L"cp", ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { // // check for "-?" // if (ShellCommandLineGetFlag(Package, L"-?")) { ASSERT(FALSE); } // // Initialize SilentMode and RecursiveMode // if (gEfiShellProtocol->BatchIsActive()) { SilentMode = TRUE; } else { SilentMode = ShellCommandLineGetFlag(Package, L"-q"); } RecursiveMode = ShellCommandLineGetFlag(Package, L"-r"); switch (ParamCount = ShellCommandLineGetCount(Package)) { case 0: case 1: // // we have insufficient parameters // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"cp"); ShellStatus = SHELL_INVALID_PARAMETER; break; case 2: // // must have valid CWD for single parameter... // Cwd = ShellGetCurrentDir(NULL); if (Cwd == NULL){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle, L"cp"); ShellStatus = SHELL_INVALID_PARAMETER; } else { Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, 1), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList); if (FileList == NULL || IsListEmpty(&FileList->Link) || EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, L"cp", ShellCommandLineGetRawValue(Package, 1)); ShellStatus = SHELL_NOT_FOUND; } else { FullCwd = AllocateZeroPool(StrSize(Cwd) + sizeof(CHAR16)); if (FullCwd == NULL) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellLevel2HiiHandle, L"cp"); ShellStatus = SHELL_OUT_OF_RESOURCES; } else { StrCpyS (FullCwd, StrSize (Cwd) / sizeof (CHAR16) + 1, Cwd); ShellStatus = ProcessValidateAndCopyFiles (FileList, FullCwd, SilentMode, RecursiveMode); FreePool (FullCwd); } } } break; default: // // Make a big list of all the files... // for (ParamCount--, LoopCounter = 1 ; LoopCounter < ParamCount && ShellStatus == SHELL_SUCCESS ; LoopCounter++) { if (ShellGetExecutionBreakFlag()) { break; } Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, LoopCounter), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList); if (EFI_ERROR(Status) || FileList == NULL || IsListEmpty(&FileList->Link)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, L"cp", ShellCommandLineGetRawValue(Package, LoopCounter)); ShellStatus = SHELL_NOT_FOUND; } } if (ShellStatus != SHELL_SUCCESS) { Status = ShellCloseFileMetaArg(&FileList); } else { // // now copy them all... // if (FileList != NULL && !IsListEmpty(&FileList->Link)) { ShellStatus = ProcessValidateAndCopyFiles(FileList, PathCleanUpDirectories((CHAR16*)ShellCommandLineGetRawValue(Package, ParamCount)), SilentMode, RecursiveMode); Status = ShellCloseFileMetaArg(&FileList); if (EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_FILE), gShellLevel2HiiHandle, L"cp", ShellCommandLineGetRawValue(Package, ParamCount), ShellStatus|MAX_BIT); ShellStatus = SHELL_ACCESS_DENIED; } } } break; } // switch on parameter count if (FileList != NULL) { ShellCloseFileMetaArg(&FileList); } // // free the command line package // ShellCommandLineFreeVarList (Package); } if (ShellGetExecutionBreakFlag()) { return (SHELL_ABORTED); } return (ShellStatus); }
/** Function to Copy one file to another location If the destination exists the user will be prompted and the result put into *resp @param[in] Source pointer to source file name @param[in] Dest pointer to destination file name @param[out] Resp pointer to response from question. Pass back on looped calling @param[in] SilentMode whether to run in quiet mode or not @param[in] CmdName Source command name requesting single file copy @retval SHELL_SUCCESS The source file was copied to the destination **/ SHELL_STATUS CopySingleFile( IN CONST CHAR16 *Source, IN CONST CHAR16 *Dest, OUT VOID **Resp, IN BOOLEAN SilentMode, IN CONST CHAR16 *CmdName ) { VOID *Response; UINTN ReadSize; SHELL_FILE_HANDLE SourceHandle; SHELL_FILE_HANDLE DestHandle; EFI_STATUS Status; VOID *Buffer; CHAR16 *TempName; UINTN Size; EFI_SHELL_FILE_INFO *List; SHELL_STATUS ShellStatus; UINT64 SourceFileSize; UINT64 DestFileSize; EFI_FILE_PROTOCOL *DestVolumeFP; EFI_FILE_SYSTEM_INFO *DestVolumeInfo; UINTN DestVolumeInfoSize; ASSERT(Resp != NULL); SourceHandle = NULL; DestHandle = NULL; Response = *Resp; List = NULL; DestVolumeInfo = NULL; ShellStatus = SHELL_SUCCESS; ReadSize = PcdGet32(PcdShellFileOperationSize); // Why bother copying a file to itself if (StrCmp(Source, Dest) == 0) { return (SHELL_SUCCESS); } // // if the destination file existed check response and possibly prompt user // if (ShellFileExists(Dest) == EFI_SUCCESS) { if (Response == NULL && !SilentMode) { Status = ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response); } // // possibly return based on response // if (!SilentMode) { switch (*(SHELL_PROMPT_RESPONSE*)Response) { case ShellPromptResponseNo: // // return success here so we dont stop the process // return (SHELL_SUCCESS); case ShellPromptResponseCancel: *Resp = Response; // // indicate to stop everything // return (SHELL_ABORTED); case ShellPromptResponseAll: *Resp = Response; case ShellPromptResponseYes: break; default: return SHELL_ABORTED; } } } if (ShellIsDirectory(Source) == EFI_SUCCESS) { Status = ShellCreateDirectory(Dest, &DestHandle); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_DIR_FAIL), gShellLevel2HiiHandle, CmdName, Dest); return (SHELL_ACCESS_DENIED); } // // Now copy all the files under the directory... // TempName = NULL; Size = 0; StrnCatGrow(&TempName, &Size, Source, 0); StrnCatGrow(&TempName, &Size, L"\\*", 0); if (TempName != NULL) { ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List); *TempName = CHAR_NULL; StrnCatGrow(&TempName, &Size, Dest, 0); StrnCatGrow(&TempName, &Size, L"\\", 0); ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp); ShellCloseFileMetaArg(&List); SHELL_FREE_NON_NULL(TempName); Size = 0; } } else { Status = ShellDeleteFileByName(Dest); // // open file with create enabled // Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_OPEN_FAIL), gShellLevel2HiiHandle, CmdName, Dest); return (SHELL_ACCESS_DENIED); } // // open source file // Status = ShellOpenFileByName (Source, &SourceHandle, EFI_FILE_MODE_READ, 0); if (EFI_ERROR (Status)) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_CP_SRC_OPEN_FAIL), gShellLevel2HiiHandle, CmdName, Source); return (SHELL_ACCESS_DENIED); } // //get file size of source file and freespace available on destination volume // ShellGetFileSize(SourceHandle, &SourceFileSize); ShellGetFileSize(DestHandle, &DestFileSize); // //if the destination file already exists then it will be replaced, meaning the sourcefile effectively needs less storage space // if(DestFileSize < SourceFileSize){ SourceFileSize -= DestFileSize; } else { SourceFileSize = 0; } // //get the system volume info to check the free space // DestVolumeFP = ConvertShellHandleToEfiFileProtocol(DestHandle); DestVolumeInfo = NULL; DestVolumeInfoSize = 0; Status = DestVolumeFP->GetInfo( DestVolumeFP, &gEfiFileSystemInfoGuid, &DestVolumeInfoSize, DestVolumeInfo ); if (Status == EFI_BUFFER_TOO_SMALL) { DestVolumeInfo = AllocateZeroPool(DestVolumeInfoSize); Status = DestVolumeFP->GetInfo( DestVolumeFP, &gEfiFileSystemInfoGuid, &DestVolumeInfoSize, DestVolumeInfo ); } // //check if enough space available on destination drive to complete copy // if (DestVolumeInfo!= NULL && (DestVolumeInfo->FreeSpace < SourceFileSize)) { // //not enough space on destination directory to copy file // SHELL_FREE_NON_NULL(DestVolumeInfo); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_FAIL), gShellLevel2HiiHandle, CmdName); return(SHELL_VOLUME_FULL); } else { // // copy data between files // Buffer = AllocateZeroPool(ReadSize); if (Buffer == NULL) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellLevel2HiiHandle, CmdName); return SHELL_OUT_OF_RESOURCES; } while (ReadSize == PcdGet32(PcdShellFileOperationSize) && !EFI_ERROR(Status)) { Status = ShellReadFile(SourceHandle, &ReadSize, Buffer); if (!EFI_ERROR(Status)) { Status = ShellWriteFile(DestHandle, &ReadSize, Buffer); if (EFI_ERROR(Status)) { ShellStatus = (SHELL_STATUS) (Status & (~MAX_BIT)); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_WRITE_ERROR), gShellLevel2HiiHandle, CmdName, Dest); break; } } else { ShellStatus = (SHELL_STATUS) (Status & (~MAX_BIT)); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_READ_ERROR), gShellLevel2HiiHandle, CmdName, Source); break; } } } SHELL_FREE_NON_NULL(DestVolumeInfo); } // // close files // if (DestHandle != NULL) { ShellCloseFile(&DestHandle); DestHandle = NULL; } if (SourceHandle != NULL) { ShellCloseFile(&SourceHandle); SourceHandle = NULL; } // // return // 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 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; EFI_STATUS Status; CHAR16 *DestPath; VOID *Response; UINTN PathSize; CONST CHAR16 *Cwd; UINTN NewSize; CHAR16 *CleanFilePathStr; if (Resp == NULL) { Response = NULL; } else { Response = *Resp; } DestPath = NULL; ShellStatus = SHELL_SUCCESS; PathSize = 0; Cwd = ShellGetCurrentDir(NULL); CleanFilePathStr = NULL; ASSERT(FileList != NULL); ASSERT(DestDir != NULL); Status = ShellLevel2StripQuotes (DestDir, &CleanFilePathStr); if (EFI_ERROR (Status)) { if (Status == EFI_OUT_OF_RESOURCES) { return SHELL_OUT_OF_RESOURCES; } else { return SHELL_INVALID_PARAMETER; } } ASSERT (CleanFilePathStr != NULL); // // If we are trying to copy multiple files... make sure we got a directory for the target... // if (EFI_ERROR(ShellIsDirectory(CleanFilePathStr)) && FileList->Link.ForwardLink != FileList->Link.BackLink) { // // Error for destination not a directory // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, L"cp", CleanFilePathStr); FreePool (CleanFilePathStr); 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(CleanFilePathStr); NewSize += StrSize(Node->FullName); NewSize += (Cwd == NULL)? 0 : (StrSize(Cwd) + sizeof(CHAR16)); if (NewSize > PathSize) { PathSize = 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, L"cp"); FreePool (CleanFilePathStr); return (SHELL_INVALID_PARAMETER); } // // make sure got dest as dir if needed // if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(CleanFilePathStr))) { // // Error for destination not a directory // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, L"cp", CleanFilePathStr); FreePool (CleanFilePathStr); 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(PathSize); if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) { SHELL_FREE_NON_NULL(DestPath); SHELL_FREE_NON_NULL(HiiOutput); SHELL_FREE_NON_NULL(HiiResultOk); FreePool (CleanFilePathStr); 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(CleanFilePathStr)) // not an existing directory ) { if (StrStr(CleanFilePathStr, L":") == NULL) { // // simple copy of a single file // if (Cwd != NULL) { StrCpyS(DestPath, PathSize / sizeof(CHAR16), Cwd); StrCatS(DestPath, PathSize / sizeof(CHAR16), L"\\"); } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, L"cp", CleanFilePathStr); FreePool (CleanFilePathStr); return (SHELL_INVALID_PARAMETER); } if (DestPath[StrLen(DestPath)-1] != L'\\' && CleanFilePathStr[0] != L'\\') { StrCatS(DestPath, PathSize / sizeof(CHAR16), L"\\"); } else if (DestPath[StrLen(DestPath)-1] == L'\\' && CleanFilePathStr[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCatS(DestPath, PathSize/sizeof(CHAR16), CleanFilePathStr); } else { StrCpyS(DestPath, PathSize/sizeof(CHAR16), CleanFilePathStr); } } else { // // we have multiple files or a directory in the DestDir // // // Check for leading slash // if (CleanFilePathStr[0] == L'\\') { // // Copy to the root of CWD // if (Cwd != NULL) { StrCpyS(DestPath, PathSize/sizeof(CHAR16), Cwd); StrCatS(DestPath, PathSize/sizeof(CHAR16), L"\\"); } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, L"cp", CleanFilePathStr); FreePool(CleanFilePathStr); return (SHELL_INVALID_PARAMETER); } while (PathRemoveLastItem(DestPath)); StrCatS(DestPath, PathSize/sizeof(CHAR16), CleanFilePathStr+1); StrCatS(DestPath, PathSize/sizeof(CHAR16), Node->FileName); } else if (StrStr(CleanFilePathStr, L":") == NULL) { if (Cwd != NULL) { StrCpyS(DestPath, PathSize/sizeof(CHAR16), Cwd); StrCatS(DestPath, PathSize/sizeof(CHAR16), L"\\"); } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, L"cp", CleanFilePathStr); FreePool(CleanFilePathStr); return (SHELL_INVALID_PARAMETER); } if (DestPath[StrLen(DestPath)-1] != L'\\' && CleanFilePathStr[0] != L'\\') { StrCatS(DestPath, PathSize/sizeof(CHAR16), L"\\"); } else if (DestPath[StrLen(DestPath)-1] == L'\\' && CleanFilePathStr[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCatS(DestPath, PathSize/sizeof(CHAR16), CleanFilePathStr); if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] != L'\\' && Node->FileName[0] != L'\\') { StrCatS(DestPath, PathSize/sizeof(CHAR16), L"\\"); } else if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] == L'\\' && Node->FileName[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCatS(DestPath, PathSize/sizeof(CHAR16), Node->FileName); } else { StrCpyS(DestPath, PathSize/sizeof(CHAR16), CleanFilePathStr); if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] != L'\\' && Node->FileName[0] != L'\\') { StrCatS(DestPath, PathSize/sizeof(CHAR16), L"\\"); } else if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] == L'\\' && Node->FileName[0] == L'\\') { ((CHAR16*)CleanFilePathStr)[StrLen(CleanFilePathStr)-1] = CHAR_NULL; } StrCatS(DestPath, PathSize/sizeof(CHAR16), Node->FileName); } } // // Make sure the path exists // if (EFI_ERROR(VerifyIntermediateDirectories(DestPath))) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_WNF), gShellLevel2HiiHandle, L"cp", DestPath); 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, L"cp"); ShellStatus = SHELL_INVALID_PARAMETER; break; } if (StringNoCaseCompare(&Node->FullName, &DestPath) == 0) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle, L"cp"); ShellStatus = SHELL_INVALID_PARAMETER; break; } if ((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, L"cp"); ShellStatus = SHELL_INVALID_PARAMETER; break; } PathCleanUpDirectories(DestPath); if (!SilentMode) { ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath); } // // copy single file... // ShellStatus = CopySingleFile(Node->FullName, DestPath, &Response, SilentMode, L"cp"); 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); SHELL_FREE_NON_NULL(CleanFilePathStr); if (Resp == NULL) { SHELL_FREE_NON_NULL(Response); } return (ShellStatus); }
/** Function for 'decompress' 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 ShellCommandRunEfiDecompress ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; SHELL_FILE_HANDLE InFileHandle; SHELL_FILE_HANDLE OutFileHandle; UINT32 OutSize; UINTN OutSizeTemp; VOID *OutBuffer; UINTN InSize; VOID *InBuffer; CHAR16 *InFileName; CONST CHAR16 *OutFileName; UINT64 Temp64Bit; UINT32 ScratchSize; VOID *ScratchBuffer; EFI_DECOMPRESS_PROTOCOL *Decompress; CONST CHAR16 *TempParam; InFileName = NULL; OutFileName = NULL; OutSize = 0; ShellStatus = SHELL_SUCCESS; Status = EFI_SUCCESS; OutBuffer = NULL; InBuffer = NULL; ScratchBuffer = NULL; InFileHandle = NULL; OutFileHandle = 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 (EmptyParamList, &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) > 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) < 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else { TempParam = ShellCommandLineGetRawValue(Package, 1); ASSERT(TempParam != NULL); InFileName = ShellFindFilePath(TempParam); OutFileName = ShellCommandLineGetRawValue(Package, 2); if (InFileName == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_FIND_FAIL), gShellDebug1HiiHandle, TempParam); ShellStatus = SHELL_NOT_FOUND; } else { if (ShellIsDirectory(InFileName) == EFI_SUCCESS){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_DIR), gShellDebug1HiiHandle, InFileName); ShellStatus = SHELL_INVALID_PARAMETER; } if (ShellIsDirectory(OutFileName) == EFI_SUCCESS){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_DIR), gShellDebug1HiiHandle, OutFileName); ShellStatus = SHELL_INVALID_PARAMETER; } if (ShellStatus == SHELL_SUCCESS) { Status = ShellOpenFileByName(InFileName, &InFileHandle, EFI_FILE_MODE_READ, 0); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 1), Status); ShellStatus = SHELL_NOT_FOUND; } Status = ShellOpenFileByName(OutFileName, &OutFileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 2), Status); ShellStatus = SHELL_NOT_FOUND; } } if (ShellStatus == SHELL_SUCCESS) { Status = FileHandleGetSize(InFileHandle, &Temp64Bit); ASSERT(Temp64Bit <= (UINT32)(-1)); InSize = (UINTN)Temp64Bit; ASSERT_EFI_ERROR(Status); InBuffer = AllocateZeroPool(InSize); ASSERT(InBuffer != NULL); Status = gEfiShellProtocol->ReadFile(InFileHandle, &InSize, InBuffer); ASSERT_EFI_ERROR(Status); Status = gBS->LocateProtocol(&gEfiDecompressProtocolGuid, NULL, (VOID**)&Decompress); ASSERT_EFI_ERROR(Status); Status = Decompress->GetInfo(Decompress, InBuffer, (UINT32)InSize, &OutSize, &ScratchSize); ASSERT_EFI_ERROR(Status); OutBuffer = AllocateZeroPool(OutSize); ScratchBuffer = AllocateZeroPool(ScratchSize); ASSERT(OutBuffer != NULL); ASSERT(ScratchBuffer != NULL); Status = Decompress->Decompress(Decompress, InBuffer, (UINT32)InSize, OutBuffer, OutSize, ScratchBuffer, ScratchSize); ASSERT_EFI_ERROR(Status); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_EFI_DECOMPRESS_FAIL), gShellDebug1HiiHandle, Status); ShellStatus = SHELL_DEVICE_ERROR; } else { OutSizeTemp = OutSize; Status = gEfiShellProtocol->WriteFile(OutFileHandle, &OutSizeTemp, OutBuffer); OutSize = (UINT32)OutSizeTemp; if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_WRITE_FAIL), gShellDebug1HiiHandle, OutFileName, Status); ShellStatus = SHELL_DEVICE_ERROR; } } } } } ShellCommandLineFreeVarList (Package); } if (InFileHandle != NULL) { gEfiShellProtocol->CloseFile(InFileHandle); } if (OutFileHandle != NULL) { gEfiShellProtocol->CloseFile(OutFileHandle); } SHELL_FREE_NON_NULL(InFileName); SHELL_FREE_NON_NULL(InBuffer); SHELL_FREE_NON_NULL(OutBuffer); SHELL_FREE_NON_NULL(ScratchBuffer); 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); // // 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 { // // Check for -d // if (ShellCommandLineGetFlag(Package, L"-d")){ if (ShellCommandLineGetCount(Package) < 4) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) > 4) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle); 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_PROBLEM_VAL), gShellDebug1HiiHandle, 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); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) > 2) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else { Name = ShellCommandLineGetRawValue(Package, 1); if (Name == NULL || !IsValidFileName(Name)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, 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); 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 { 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); ShellStatus = SHELL_INVALID_PARAMETER; } else if (!IsValidFileName(Name)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, 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); } 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); ShellStatus = SHELL_INVALID_PARAMETER; } else if (WhatToDo == FileTypeFileBuffer && ShellGetCurrentDir(NULL) == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellDebug1HiiHandle); 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); } 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 'getmtc' 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 ShellCommandRunGetMtc ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; UINT64 Mtc; ProblemParam = NULL; ShellStatus = SHELL_SUCCESS; // // initialize the shell lib (we must be in non-auto-init...) // Status = ShellInitialize(); ASSERT_EFI_ERROR(Status); // // parse the command line // Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE); if (EFI_ERROR(Status)) { if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel3HiiHandle, ProblemParam); FreePool(ProblemParam); ShellStatus = 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), gShellLevel3HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else { // // Get the monotonic counter count // Status = gBS->GetNextMonotonicCount(&Mtc); switch(Status) { case EFI_DEVICE_ERROR: ShellStatus = SHELL_DEVICE_ERROR; break; case EFI_SECURITY_VIOLATION: ShellStatus = SHELL_SECURITY_VIOLATION; break; default: if (EFI_ERROR(Status)) { ShellStatus = SHELL_DEVICE_ERROR; } } // // print it... // if (ShellStatus == SHELL_SUCCESS) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GET_MTC_OUTPUT), gShellLevel3HiiHandle, Mtc); } } // // free the command line package // ShellCommandLineFreeVarList (Package); } return (ShellStatus); }
/** Populate the form identified by the (PackageList, FormSetGuid, FormId) triplet. The drop down list of video resolutions is generated from (NumGopModes, GopModes). @retval EFI_SUCESS Form successfully updated. @return Status codes from underlying functions. **/ STATIC EFI_STATUS EFIAPI PopulateForm ( IN EFI_HII_HANDLE *PackageList, IN EFI_GUID *FormSetGuid, IN EFI_FORM_ID FormId, IN UINTN NumGopModes, IN GOP_MODE *GopModes ) { EFI_STATUS Status; VOID *OpCodeBuffer; VOID *OpCode; EFI_IFR_GUID_LABEL *Anchor; VOID *OpCodeBuffer2; OpCodeBuffer2 = NULL; // // 1. Allocate an empty opcode buffer. // OpCodeBuffer = HiiAllocateOpCodeHandle (); if (OpCodeBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } // // 2. Create a label opcode (which is a Tiano extension) inside the buffer. // The label's number must match the "anchor" label in the form. // OpCode = HiiCreateGuidOpCode (OpCodeBuffer, &gEfiIfrTianoGuid, NULL /* optional copy origin */, sizeof *Anchor); if (OpCode == NULL) { Status = EFI_OUT_OF_RESOURCES; goto FreeOpCodeBuffer; } Anchor = OpCode; Anchor->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; Anchor->Number = LABEL_RES_NEXT; // // 3. Create the opcodes inside the buffer that are to be inserted into the // form. // // 3.1. Get a list of resolutions. // Status = CreateResolutionOptions (PackageList, &OpCodeBuffer2, NumGopModes, GopModes); if (EFI_ERROR (Status)) { goto FreeOpCodeBuffer; } // // 3.2. Create a one-of-many question with the above options. // OpCode = HiiCreateOneOfOpCode ( OpCodeBuffer, // create opcode inside this // opcode buffer, QUESTION_RES_NEXT, // ID of question, FORMSTATEID_MAIN_FORM, // identifies form state // storage, (UINT16) OFFSET_OF (MAIN_FORM_STATE, // value of question stored NextPreferredResolution), // at this offset, STRING_TOKEN (STR_RES_NEXT), // Prompt, STRING_TOKEN (STR_RES_NEXT_HELP), // Help, 0, // QuestionFlags, EFI_IFR_NUMERIC_SIZE_4, // see sizeof // NextPreferredResolution, OpCodeBuffer2, // buffer with possible // choices, NULL // DEFAULT opcodes ); if (OpCode == NULL) { Status = EFI_OUT_OF_RESOURCES; goto FreeOpCodeBuffer2; } // // 4. Update the form with the opcode buffer. // Status = HiiUpdateForm (PackageList, FormSetGuid, FormId, OpCodeBuffer, // buffer with head anchor, and new contents to be // inserted at it NULL // buffer with tail anchor, for deleting old // contents up to it ); FreeOpCodeBuffer2: HiiFreeOpCodeHandle (OpCodeBuffer2); FreeOpCodeBuffer: HiiFreeOpCodeHandle (OpCodeBuffer); return Status; }
/** Display Usage and Help information. **/ VOID ShowHelp( void ) { PrintToken (STRING_TOKEN (STR_DP_HELP_HEAD)); #if PROFILING_IMPLEMENTED PrintToken (STRING_TOKEN (STR_DP_HELP_FLAGS)); #else PrintToken (STRING_TOKEN (STR_DP_HELP_FLAGS_2)); #endif // PROFILING_IMPLEMENTED PrintToken (STRING_TOKEN (STR_DP_HELP_PAGINATE)); PrintToken (STRING_TOKEN (STR_DP_HELP_VERBOSE)); PrintToken (STRING_TOKEN (STR_DP_HELP_EXCLUDE)); PrintToken (STRING_TOKEN (STR_DP_HELP_STAT)); PrintToken (STRING_TOKEN (STR_DP_HELP_ALL)); PrintToken (STRING_TOKEN (STR_DP_HELP_RAW)); #if PROFILING_IMPLEMENTED PrintToken (STRING_TOKEN (STR_DP_HELP_TRACE)); PrintToken (STRING_TOKEN (STR_DP_HELP_PROFILE)); #endif // PROFILING_IMPLEMENTED PrintToken (STRING_TOKEN (STR_DP_HELP_THRESHOLD)); PrintToken (STRING_TOKEN (STR_DP_HELP_COUNT)); PrintToken (STRING_TOKEN (STR_DP_HELP_ID)); PrintToken (STRING_TOKEN (STR_DP_HELP_CUM_DATA)); PrintToken (STRING_TOKEN (STR_DP_HELP_HELP)); Print(L"\n"); }
/** Initialize the Boot Maintenance Utitliy. @retval EFI_SUCCESS utility ended successfully @retval others contain some errors **/ EFI_STATUS InitializeBM ( VOID ) { EFI_LEGACY_BIOS_PROTOCOL *LegacyBios; BMM_CALLBACK_DATA *BmmCallbackInfo; EFI_STATUS Status; UINT8 *Ptr; Status = EFI_SUCCESS; // // Create CallbackData structures for Driver Callback // BmmCallbackInfo = AllocateZeroPool (sizeof (BMM_CALLBACK_DATA)); if (BmmCallbackInfo == NULL) { return EFI_OUT_OF_RESOURCES; } // // Create LoadOption in BmmCallbackInfo for Driver Callback // Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY)); if (Ptr == NULL) { FreePool (BmmCallbackInfo); return EFI_OUT_OF_RESOURCES; } // // Initialize Bmm callback data. // BmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr; Ptr += sizeof (BM_LOAD_CONTEXT); BmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr; Ptr += sizeof (BM_FILE_CONTEXT); BmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr; Ptr += sizeof (BM_HANDLE_CONTEXT); BmmCallbackInfo->MenuEntry = (BM_MENU_ENTRY *) Ptr; BmmCallbackInfo->Signature = BMM_CALLBACK_DATA_SIGNATURE; BmmCallbackInfo->BmmConfigAccess.ExtractConfig = BootMaintExtractConfig; BmmCallbackInfo->BmmConfigAccess.RouteConfig = FakeRouteConfig; BmmCallbackInfo->BmmConfigAccess.Callback = BootMaintCallback; BmmCallbackInfo->BmmPreviousPageId = FORM_MAIN_ID; BmmCallbackInfo->BmmCurrentPageId = FORM_MAIN_ID; BmmCallbackInfo->FeConfigAccess.ExtractConfig = FakeExtractConfig; BmmCallbackInfo->FeConfigAccess.RouteConfig = FakeRouteConfig; BmmCallbackInfo->FeConfigAccess.Callback = FileExplorerCallback; BmmCallbackInfo->FeCurrentState = FileExplorerStateInActive; BmmCallbackInfo->FeDisplayContext = FileExplorerDisplayUnknown; // // Install Device Path Protocol and Config Access protocol to driver handle // Status = gBS->InstallMultipleProtocolInterfaces ( &BmmCallbackInfo->BmmDriverHandle, &gEfiDevicePathProtocolGuid, &mBmmHiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, &BmmCallbackInfo->BmmConfigAccess, NULL ); if (EFI_ERROR (Status)) { goto Exit; } // // Install Device Path Protocol and Config Access protocol to driver handle // Status = gBS->InstallMultipleProtocolInterfaces ( &BmmCallbackInfo->FeDriverHandle, &gEfiDevicePathProtocolGuid, &mFeHiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, &BmmCallbackInfo->FeConfigAccess, NULL ); if (EFI_ERROR (Status)) { goto Exit; } // // Post our Boot Maint VFR binary to the HII database. // BmmCallbackInfo->BmmHiiHandle = HiiAddPackages ( &gBootMaintFormSetGuid, BmmCallbackInfo->BmmDriverHandle, BmBin, BdsDxeStrings, NULL ); ASSERT (BmmCallbackInfo->BmmHiiHandle != NULL); // // Post our File Explorer VFR binary to the HII database. // BmmCallbackInfo->FeHiiHandle = HiiAddPackages ( &gFileExploreFormSetGuid, BmmCallbackInfo->FeDriverHandle, FEBin, BdsDxeStrings, NULL ); ASSERT (BmmCallbackInfo->FeHiiHandle != NULL); // // Init OpCode Handle and Allocate space for creation of Buffer // mStartOpCodeHandle = HiiAllocateOpCodeHandle (); if (mStartOpCodeHandle == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Exit; } mEndOpCodeHandle = HiiAllocateOpCodeHandle (); if (mEndOpCodeHandle == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Exit; } // // Create Hii Extend Label OpCode as the start opcode // mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; // // Create Hii Extend Label OpCode as the end opcode // mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mEndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; mEndLabel->Number = LABEL_END; InitializeStringDepository (); InitAllMenu (BmmCallbackInfo); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleInpMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleOutMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &ConsoleErrMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &BootOptionMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &DriverOptionMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &TerminalMenu); CreateMenuStringToken (BmmCallbackInfo, BmmCallbackInfo->BmmHiiHandle, &DriverMenu); UpdateBootDelPage (BmmCallbackInfo); UpdateDrvDelPage (BmmCallbackInfo); if (TerminalMenu.MenuNumber > 0) { BmmCallbackInfo->CurrentTerminal = 0; UpdateTerminalPage (BmmCallbackInfo); } Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios); if (!EFI_ERROR (Status)) { RefreshUpdateData (); mStartLabel->Number = FORM_BOOT_LEGACY_DEVICE_ID; // // If LegacyBios Protocol is installed, add 3 tags about legacy boot option // in BootOption form: legacy FD/HD/CD/NET/BEV // HiiCreateGotoOpCode ( mStartOpCodeHandle, FORM_SET_FD_ORDER_ID, STRING_TOKEN (STR_FORM_SET_FD_ORDER_TITLE), STRING_TOKEN (STR_FORM_SET_FD_ORDER_TITLE), EFI_IFR_FLAG_CALLBACK, FORM_SET_FD_ORDER_ID ); HiiCreateGotoOpCode ( mStartOpCodeHandle, FORM_SET_HD_ORDER_ID, STRING_TOKEN (STR_FORM_SET_HD_ORDER_TITLE), STRING_TOKEN (STR_FORM_SET_HD_ORDER_TITLE), EFI_IFR_FLAG_CALLBACK, FORM_SET_HD_ORDER_ID ); HiiCreateGotoOpCode ( mStartOpCodeHandle, FORM_SET_CD_ORDER_ID, STRING_TOKEN (STR_FORM_SET_CD_ORDER_TITLE), STRING_TOKEN (STR_FORM_SET_CD_ORDER_TITLE), EFI_IFR_FLAG_CALLBACK, FORM_SET_CD_ORDER_ID ); HiiCreateGotoOpCode ( mStartOpCodeHandle, FORM_SET_NET_ORDER_ID, STRING_TOKEN (STR_FORM_SET_NET_ORDER_TITLE), STRING_TOKEN (STR_FORM_SET_NET_ORDER_TITLE), EFI_IFR_FLAG_CALLBACK, FORM_SET_NET_ORDER_ID ); HiiCreateGotoOpCode ( mStartOpCodeHandle, FORM_SET_BEV_ORDER_ID, STRING_TOKEN (STR_FORM_SET_BEV_ORDER_TITLE), STRING_TOKEN (STR_FORM_SET_BEV_ORDER_TITLE), EFI_IFR_FLAG_CALLBACK, FORM_SET_BEV_ORDER_ID ); HiiUpdateForm ( BmmCallbackInfo->BmmHiiHandle, &gBootMaintFormSetGuid, FORM_BOOT_SETUP_ID, mStartOpCodeHandle, // Label FORM_BOOT_LEGACY_DEVICE_ID mEndOpCodeHandle // LABEL_END ); } // // Dispatch BMM main formset and File Explorer formset. // FormSetDispatcher (BmmCallbackInfo); // // Remove our IFR data from HII database // HiiRemovePackages (BmmCallbackInfo->BmmHiiHandle); HiiRemovePackages (BmmCallbackInfo->FeHiiHandle); CleanUpStringDepository (); FreeAllMenu (); Exit: if (mStartOpCodeHandle != NULL) { HiiFreeOpCodeHandle (mStartOpCodeHandle); } if (mEndOpCodeHandle != NULL) { HiiFreeOpCodeHandle (mEndOpCodeHandle); } if (BmmCallbackInfo->FeDriverHandle != NULL) { gBS->UninstallMultipleProtocolInterfaces ( BmmCallbackInfo->FeDriverHandle, &gEfiDevicePathProtocolGuid, &mFeHiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, &BmmCallbackInfo->FeConfigAccess, NULL ); } if (BmmCallbackInfo->BmmDriverHandle != NULL) { gBS->UninstallMultipleProtocolInterfaces ( BmmCallbackInfo->BmmDriverHandle, &gEfiDevicePathProtocolGuid, &mBmmHiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, &BmmCallbackInfo->BmmConfigAccess, NULL ); } FreePool (BmmCallbackInfo->LoadContext); FreePool (BmmCallbackInfo); return Status; }
/** Function for 'setsize' 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 ShellCommandRunSetSize ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; CONST CHAR16 *Temp1; UINTN NewSize; UINTN LoopVar; SHELL_FILE_HANDLE FileHandle; ShellStatus = SHELL_SUCCESS; Status = EFI_SUCCESS; // // 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 (EmptyParamList, &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"setsize", ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { if (ShellCommandLineGetCount(Package) < 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"setsize"); ShellStatus = SHELL_INVALID_PARAMETER; NewSize = 0; } else { Temp1 = ShellCommandLineGetRawValue(Package, 1); if (!ShellIsHexOrDecimalNumber(Temp1, FALSE, FALSE)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SIZE_NOT_SPEC), gShellDebug1HiiHandle, L"setsize"); ShellStatus = SHELL_INVALID_PARAMETER; NewSize = 0; } else { NewSize = ShellStrToUintn(Temp1); } } for (LoopVar = 2 ; LoopVar < ShellCommandLineGetCount(Package) && ShellStatus == SHELL_SUCCESS ; LoopVar++) { Status = ShellOpenFileByName(ShellCommandLineGetRawValue(Package, LoopVar), &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, 0); if (EFI_ERROR(Status)) { Status = ShellOpenFileByName(ShellCommandLineGetRawValue(Package, LoopVar), &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0); } if (EFI_ERROR(Status) && LoopVar == 2) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_SPEC), gShellDebug1HiiHandle, L"setsize"); ShellStatus = SHELL_INVALID_PARAMETER; } else if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"setsize", ShellCommandLineGetRawValue(Package, LoopVar)); ShellStatus = SHELL_INVALID_PARAMETER; break; } else { Status = FileHandleSetSize(FileHandle, NewSize); if (Status == EFI_VOLUME_FULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_VOLUME_FULL), gShellDebug1HiiHandle, L"setsize"); ShellStatus = SHELL_VOLUME_FULL; } else if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SET_SIZE_FAIL), gShellDebug1HiiHandle, L"setsize", ShellCommandLineGetRawValue(Package, LoopVar)); ShellStatus = SHELL_INVALID_PARAMETER; } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SET_SIZE_DONE), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, LoopVar)); } ShellCloseFile(&FileHandle); } } ShellCommandLineFreeVarList (Package); } return (ShellStatus); }
/** Constructor for the Shell Level 3 Commands library. Install the handlers for level 3 UEFI Shell 2.0 commands. @param ImageHandle the image handle of the process @param SystemTable the EFI System Table pointer @retval EFI_SUCCESS the shell command handlers were installed sucessfully @retval EFI_UNSUPPORTED the shell level required was not found. **/ EFI_STATUS EFIAPI ShellLevel3CommandsLibConstructor ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { gShellLevel3HiiHandle = NULL; // // if shell level is less than 3 do nothing // if (PcdGet8(PcdShellSupportLevel) < 3) { return (EFI_SUCCESS); } gShellLevel3HiiHandle = HiiAddPackages (&gShellLevel3HiiGuid, gImageHandle, UefiShellLevel3CommandsLibStrings, NULL); if (gShellLevel3HiiHandle == NULL) { return (EFI_DEVICE_ERROR); } // // install our shell command handlers that are always installed // // Note: that Time, Timezone, and Date are part of level 2 library // ShellCommandRegisterCommandName(L"type", ShellCommandRunType , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_TYPE)); ShellCommandRegisterCommandName(L"touch", ShellCommandRunTouch , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_TOUCH)); ShellCommandRegisterCommandName(L"ver", ShellCommandRunVer , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_VER)); ShellCommandRegisterCommandName(L"alias", ShellCommandRunAlias , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_ALIAS)); ShellCommandRegisterCommandName(L"cls", ShellCommandRunCls , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_CLS)); ShellCommandRegisterCommandName(L"echo", ShellCommandRunEcho , ShellCommandGetManFileNameLevel3, 3, L"", FALSE, gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_ECHO)); ShellCommandRegisterCommandName(L"pause", ShellCommandRunPause , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_PAUSE)); ShellCommandRegisterCommandName(L"getmtc", ShellCommandRunGetMtc , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_GETMTC)); ShellCommandRegisterCommandName(L"help", ShellCommandRunHelp , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_HELP)); ShellCommandRegisterAlias(L"type", L"cat"); return (EFI_SUCCESS); }
/** Function to get each data from parameters. @param[in] Package The package of checked values. @param[out] Buffer A pointer to a buffer to hold the return data. @param[out] BufferSize Indicates the size of data in bytes return in Buffer. @retval EFI_INVALID_PARAMETER Buffer or BufferSize is NULL. @retval EFI_OUT_OF_RESOURCES A memory allcation failed. @retval EFI_SUCCESS Get each parameter data was successful. **/ EFI_STATUS GetVariableDataFromParameter ( IN CONST LIST_ENTRY *Package, OUT UINT8 **Buffer, OUT UINTN *BufferSize ) { CONST CHAR16 *TempData; UINTN Index; UINTN TotalSize; UINTN Size; UINT8 *BufferWalker; EFI_STATUS Status; TotalSize = 0; Size = 0; Status = EFI_SUCCESS; if (BufferSize == NULL || Buffer == NULL || ShellCommandLineGetCount (Package) < 3) { return EFI_INVALID_PARAMETER; } for (Index = 2; Index < ShellCommandLineGetCount (Package); Index++) { TempData = ShellCommandLineGetRawValue (Package, Index); ASSERT (TempData != NULL); if (TempData[0] != L'=') { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", TempData); return EFI_INVALID_PARAMETER; } TempData = TempData + 1; Size = 0; Status = ParseParameterData (TempData, NULL, &Size); if (EFI_ERROR (Status)) { if (Status == EFI_BUFFER_TOO_SMALL) { // // We expect return EFI_BUFFER_TOO_SMALL when pass 'NULL' as second parameter to the function ParseParameterData. // TotalSize += Size; } else { if (Status == EFI_INVALID_PARAMETER) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", TempData); } else if (Status == EFI_NOT_FOUND) { ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, L"setvar"); } return Status; } } } *BufferSize = TotalSize; *Buffer = AllocateZeroPool (TotalSize); if (*Buffer == NULL) { Status = EFI_OUT_OF_RESOURCES; } else { BufferWalker = *Buffer; for (Index = 2; Index < ShellCommandLineGetCount (Package); Index++) { TempData = ShellCommandLineGetRawValue (Package, Index); TempData = TempData + 1; Size = TotalSize; Status = ParseParameterData (TempData, (VOID *)BufferWalker, &Size); if (!EFI_ERROR (Status)) { BufferWalker = BufferWalker + Size; TotalSize = TotalSize - Size; } else { return Status; } } } return EFI_SUCCESS; }
/** Function for 'comp' 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 ShellCommandRunComp ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; UINTN LoopVar; SHELL_FILE_HANDLE FileHandle1; SHELL_FILE_HANDLE FileHandle2; UINT8 ErrorCount; UINT64 Size1; UINT64 Size2; UINT8 DataFromFile1; UINT8 DataFromFile2; UINT8 ADF_File11; UINT8 ADF_File12; UINT8 ADF_File13; UINT8 ADF_File21; UINT8 ADF_File22; UINT8 ADF_File23; UINTN DataSizeFromFile1; UINTN DataSizeFromFile2; CHAR16 *FileName1; CHAR16 *FileName2; CONST CHAR16 *TempParam; UINTN ErrorAddress; ErrorCount = 0; ShellStatus = SHELL_SUCCESS; Status = EFI_SUCCESS; FileName1 = NULL; FileName2 = NULL; FileHandle1 = NULL; FileHandle2 = NULL; Size1 = 0; // // 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 (EmptyParamList, &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"comp", ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { if (ShellCommandLineGetCount(Package) > 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"comp"); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) < 3) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"comp"); ShellStatus = SHELL_INVALID_PARAMETER; } else { TempParam = ShellCommandLineGetRawValue(Package, 1); ASSERT(TempParam != NULL); FileName1 = ShellFindFilePath(TempParam); if (FileName1 == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_FIND_FAIL), gShellDebug1HiiHandle, L"comp", TempParam); ShellStatus = SHELL_NOT_FOUND; } else { Status = ShellOpenFileByName(FileName1, &FileHandle1, EFI_FILE_MODE_READ, 0); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"comp", TempParam); ShellStatus = SHELL_NOT_FOUND; } } TempParam = ShellCommandLineGetRawValue(Package, 2); ASSERT(TempParam != NULL); FileName2 = ShellFindFilePath(TempParam); if (FileName2 == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_FIND_FAIL), gShellDebug1HiiHandle, L"comp", TempParam); ShellStatus = SHELL_NOT_FOUND; } else { Status = ShellOpenFileByName(FileName2, &FileHandle2, EFI_FILE_MODE_READ, 0); if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"comp", TempParam); ShellStatus = SHELL_NOT_FOUND; } } if (ShellStatus == SHELL_SUCCESS) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_COMP_HEADER), gShellDebug1HiiHandle, FileName1, FileName2); Status = gEfiShellProtocol->GetFileSize(FileHandle1, &Size1); ASSERT_EFI_ERROR(Status); Status = gEfiShellProtocol->GetFileSize(FileHandle2, &Size2); ASSERT_EFI_ERROR(Status); if (Size1 != Size2) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_COMP_SIZE_FAIL), gShellDebug1HiiHandle); ErrorCount++; ShellStatus = SHELL_NOT_EQUAL; } } if (ShellStatus == SHELL_SUCCESS) { for (LoopVar = 0 ; LoopVar < Size1 && ErrorCount <= 10 ; LoopVar++) { DataSizeFromFile1 = 1; DataSizeFromFile2 = 1; Status = gEfiShellProtocol->ReadFile(FileHandle1, &DataSizeFromFile1, &DataFromFile1); ASSERT_EFI_ERROR(Status); Status = gEfiShellProtocol->ReadFile(FileHandle2, &DataSizeFromFile2, &DataFromFile2); ASSERT_EFI_ERROR(Status); if (DataFromFile1 != DataFromFile2) { ErrorAddress = LoopVar; ADF_File11 = 0; ADF_File12 = 0; ADF_File13 = 0; ADF_File21 = 0; ADF_File22 = 0; ADF_File23 = 0; // // Now check the next 3 bytes if possible. This will make output // cleaner when there are a sequence of differences. // if (LoopVar + 1 < Size1) { LoopVar++; DataSizeFromFile1 = 1; DataSizeFromFile2 = 1; Status = gEfiShellProtocol->ReadFile(FileHandle1, &DataSizeFromFile1, &ADF_File11); ASSERT_EFI_ERROR(Status); Status = gEfiShellProtocol->ReadFile(FileHandle2, &DataSizeFromFile2, &ADF_File21); ASSERT_EFI_ERROR(Status); if (LoopVar + 1 < Size1) { LoopVar++; DataSizeFromFile1 = 1; DataSizeFromFile2 = 1; Status = gEfiShellProtocol->ReadFile(FileHandle1, &DataSizeFromFile1, &ADF_File12); ASSERT_EFI_ERROR(Status); Status = gEfiShellProtocol->ReadFile(FileHandle2, &DataSizeFromFile2, &ADF_File22); ASSERT_EFI_ERROR(Status); if (LoopVar + 1 < Size1) { LoopVar++; DataSizeFromFile1 = 1; DataSizeFromFile2 = 1; Status = gEfiShellProtocol->ReadFile(FileHandle1, &DataSizeFromFile1, &ADF_File13); ASSERT_EFI_ERROR(Status); Status = gEfiShellProtocol->ReadFile(FileHandle2, &DataSizeFromFile2, &ADF_File23); ASSERT_EFI_ERROR(Status); } } } // // Print out based on highest of the 4 bytes that are different. // if (ADF_File13 != ADF_File23) { ShellPrintHiiEx( -1, -1, NULL, STRING_TOKEN (STR_COMP_SPOT_FAIL4), gShellDebug1HiiHandle, ++ErrorCount, FileName1, ErrorAddress, DataFromFile1, ADF_File11, ADF_File12, ADF_File13, DataFromFile1, ADF_File11, ADF_File12, ADF_File13, FileName2, ErrorAddress, DataFromFile2, ADF_File21, ADF_File22, ADF_File23, DataFromFile2, ADF_File21, ADF_File22, ADF_File23 ); } else if (ADF_File12 != ADF_File22) { ShellPrintHiiEx( -1, -1, NULL, STRING_TOKEN (STR_COMP_SPOT_FAIL3), gShellDebug1HiiHandle, ++ErrorCount, FileName1, ErrorAddress, DataFromFile1, ADF_File11, ADF_File12, DataFromFile1, ADF_File11, ADF_File12, FileName2, ErrorAddress, DataFromFile2, ADF_File21, ADF_File22, DataFromFile2, ADF_File21, ADF_File22 ); } else if (ADF_File11 != ADF_File21) { ShellPrintHiiEx( -1, -1, NULL, STRING_TOKEN (STR_COMP_SPOT_FAIL2), gShellDebug1HiiHandle, ++ErrorCount, FileName1, ErrorAddress, DataFromFile1, ADF_File11, DataFromFile1, ADF_File11, FileName2, ErrorAddress, DataFromFile2, ADF_File21, DataFromFile2, ADF_File21 ); } else { ShellPrintHiiEx( -1, -1, NULL, STRING_TOKEN (STR_COMP_SPOT_FAIL1), gShellDebug1HiiHandle, ++ErrorCount, FileName1, ErrorAddress, DataFromFile1, DataFromFile1, FileName2, ErrorAddress, DataFromFile2, DataFromFile2 ); } ShellStatus = SHELL_NOT_EQUAL; } } if (ErrorCount == 0) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_COMP_FOOTER_PASS), gShellDebug1HiiHandle); } else { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_COMP_FOOTER_FAIL), gShellDebug1HiiHandle); } } } ShellCommandLineFreeVarList (Package); } SHELL_FREE_NON_NULL(FileName1); SHELL_FREE_NON_NULL(FileName2); if (FileHandle1 != NULL) { gEfiShellProtocol->CloseFile(FileHandle1); } if (FileHandle2 != NULL) { gEfiShellProtocol->CloseFile(FileHandle2); } return (ShellStatus); }
/** Constructor for the Shell Debug1 Commands library. @param ImageHandle the image handle of the process @param SystemTable the EFI System Table pointer @retval EFI_SUCCESS the shell command handlers were installed sucessfully @retval EFI_UNSUPPORTED the shell level required was not found. **/ EFI_STATUS EFIAPI UefiShellDebug1CommandsLibConstructor ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { // // check our bit of the profiles mask // if ((PcdGet8(PcdShellProfileMask) & BIT1) == 0) { return (EFI_SUCCESS); } // // install the HII stuff. // gShellDebug1HiiHandle = HiiAddPackages (&gShellDebug1HiiGuid, gImageHandle, UefiShellDebug1CommandsLibStrings, NULL); if (gShellDebug1HiiHandle == NULL) { return (EFI_DEVICE_ERROR); } // // install our shell command handlers that are always installed // ShellCommandRegisterCommandName(L"setsize", ShellCommandRunSetSize , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SETSIZE) ); ShellCommandRegisterCommandName(L"comp", ShellCommandRunComp , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_COMP) ); ShellCommandRegisterCommandName(L"mode", ShellCommandRunMode , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MODE) ); ShellCommandRegisterCommandName(L"memmap", ShellCommandRunMemMap , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MEMMAP) ); ShellCommandRegisterCommandName(L"eficompress", ShellCommandRunEfiCompress , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EFICOMPRESS) ); ShellCommandRegisterCommandName(L"efidecompress", ShellCommandRunEfiDecompress , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EFIDCOMPRESS) ); ShellCommandRegisterCommandName(L"dmem", ShellCommandRunDmem , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DMEM) ); ShellCommandRegisterCommandName(L"loadpcirom", ShellCommandRunLoadPciRom , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_LOAD_PCI_ROM) ); ShellCommandRegisterCommandName(L"mm", ShellCommandRunMm , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MM) ); ShellCommandRegisterCommandName(L"setvar", ShellCommandRunSetVar , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SETVAR) ); ShellCommandRegisterCommandName(L"sermode", ShellCommandRunSerMode , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SERMODE) ); ShellCommandRegisterCommandName(L"pci", ShellCommandRunPci , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_PCI) ); ShellCommandRegisterCommandName(L"smbiosview", ShellCommandRunSmbiosView , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SMBIOSVIEW) ); ShellCommandRegisterCommandName(L"dmpstore", ShellCommandRunDmpStore , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DMPSTORE) ); ShellCommandRegisterCommandName(L"dblk", ShellCommandRunDblk , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DBLK) ); ShellCommandRegisterCommandName(L"edit", ShellCommandRunEdit , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EDIT) ); ShellCommandRegisterCommandName(L"hexedit", ShellCommandRunHexEdit , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_HEXEDIT) ); ShellCommandRegisterAlias(L"dmem", L"mem"); BcfgLibraryRegisterBcfgCommand(ImageHandle, SystemTable, L"Debug1"); return (EFI_SUCCESS); }
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. Module Name: MiscSystemLanguageStringData.c Abstract: Static data of System language string information. System language string information is Misc. subclass type 12 and SMBIOS type 13. **/ #include "CommonHeader.h" #include "MiscSubclassDriver.h" // // Static (possibly build generated) Bios Vendor data. // MISC_SMBIOS_TABLE_DATA(EFI_MISC_SYSTEM_LANGUAGE_STRING_DATA, SystemLanguageString) = { 0, STRING_TOKEN(STR_MISC_SYSTEM_LANGUAGE_EN_US) };
/** Connect controller(s) and driver(s). @param[in] ControllerHandle The handle to the controller. Should have driver binding on it. @param[in] DriverHandle The handle to the driver. Should have driver binding. @param[in] Recursive TRUE to connect recursively, FALSE otherwise. @param[in] Output TRUE to have info on the screen, FALSE otherwise. @param[in] AlwaysOutput Override Output for errors. @retval EFI_SUCCESS The operation was successful. **/ EFI_STATUS ConnectControllers ( IN CONST EFI_HANDLE ControllerHandle OPTIONAL, IN CONST EFI_HANDLE DriverHandle OPTIONAL, IN CONST BOOLEAN Recursive, IN CONST BOOLEAN Output, IN CONST BOOLEAN AlwaysOutput ) { EFI_STATUS Status; EFI_STATUS Status2; EFI_HANDLE *ControllerHandleList; EFI_HANDLE *DriverHandleList; EFI_HANDLE *HandleWalker; ControllerHandleList = NULL; Status = EFI_NOT_FOUND; Status2 = EFI_NOT_FOUND; // // If we have a single handle to connect make that a 'list' // if (DriverHandle == NULL) { DriverHandleList = NULL; } else { DriverHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE)); if (DriverHandleList == NULL) { return (EFI_OUT_OF_RESOURCES); } DriverHandleList[0] = DriverHandle; DriverHandleList[1] = NULL; } // // do we connect all controllers (with a loop) or a single one... // This is where we call the gBS->ConnectController function. // if (ControllerHandle == NULL) { ControllerHandleList = GetHandleListByProtocol(&gEfiDevicePathProtocolGuid); for (HandleWalker = ControllerHandleList ; HandleWalker != NULL && *HandleWalker != NULL ; HandleWalker++ ){ Status = gBS->ConnectController(*HandleWalker, DriverHandleList, NULL, Recursive); if (!EFI_ERROR(Status)) { Status2 = EFI_SUCCESS; } if ((Output && !EFI_ERROR(Status)) || AlwaysOutput) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex(*HandleWalker), Status); } } } else { Status = gBS->ConnectController(ControllerHandle, DriverHandleList, NULL, Recursive); if (!EFI_ERROR(Status)) { Status2 = EFI_SUCCESS; } if ((Output && !EFI_ERROR(Status)) || AlwaysOutput) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex(ControllerHandle), Status); } } // // Free any memory we allocated. // if (ControllerHandleList != NULL) { FreePool(ControllerHandleList); } if (DriverHandleList != NULL) { FreePool(DriverHandleList); } return (Status2); }
/** Function for 'disconnect' 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 ShellCommandRunDisconnect ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; CONST CHAR16 *Param1; CONST CHAR16 *Param2; CONST CHAR16 *Param3; EFI_HANDLE Handle1; EFI_HANDLE Handle2; EFI_HANDLE Handle3; UINT64 Intermediate1; UINT64 Intermediate2; UINT64 Intermediate3; ShellStatus = SHELL_SUCCESS; // // 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"disconnect", ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { if (ShellCommandLineGetFlag(Package, L"-r")){ if (ShellCommandLineGetCount(Package) > 1){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"disconnect"); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) < 1) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle, L"disconnect"); ShellStatus = SHELL_INVALID_PARAMETER; } else { Status = DisconnectAll (); // // Reconnect all consoles if -nc is not provided // if (!ShellCommandLineGetFlag (Package, L"-nc")){ ShellConnectFromDevPaths (L"ConInDev"); ShellConnectFromDevPaths (L"ConOutDev"); ShellConnectFromDevPaths (L"ErrOutDev"); ShellConnectFromDevPaths (L"ErrOut"); ShellConnectFromDevPaths (L"ConIn"); ShellConnectFromDevPaths (L"ConOut"); } } } else if (ShellCommandLineGetFlag (Package, L"-nc")) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle, L"disconnect"); ShellStatus = SHELL_INVALID_PARAMETER; } else { if (ShellCommandLineGetCount(Package) > 4){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"disconnect"); ShellStatus = SHELL_INVALID_PARAMETER; } else if (ShellCommandLineGetCount(Package) < 2) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle, L"disconnect"); ShellStatus = SHELL_INVALID_PARAMETER; } else { // // must have between 1 and 3 handles passed in ... // Param1 = ShellCommandLineGetRawValue(Package, 1); Param2 = ShellCommandLineGetRawValue(Package, 2); Param3 = ShellCommandLineGetRawValue(Package, 3); ShellConvertStringToUint64(Param1, &Intermediate1, TRUE, FALSE); Handle1 = Param1!=NULL?ConvertHandleIndexToHandle((UINTN)Intermediate1):NULL; ShellConvertStringToUint64(Param2, &Intermediate2, TRUE, FALSE); Handle2 = Param2!=NULL?ConvertHandleIndexToHandle((UINTN)Intermediate2):NULL; ShellConvertStringToUint64(Param3, &Intermediate3, TRUE, FALSE); Handle3 = Param3!=NULL?ConvertHandleIndexToHandle((UINTN)Intermediate3):NULL; if (Param1 != NULL && Handle1 == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"disconnect", Param1); ShellStatus = SHELL_INVALID_PARAMETER; } else if (Param2 != NULL && Handle2 == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"disconnect", Param2); ShellStatus = SHELL_INVALID_PARAMETER; } else if (Param3 != NULL && Handle3 == NULL) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"disconnect", Param3); ShellStatus = SHELL_INVALID_PARAMETER; } else if (Handle2 != NULL && EFI_ERROR(gBS->OpenProtocol(Handle2, &gEfiDriverBindingProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) { ASSERT(Param2 != NULL); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_NOT), gShellDriver1HiiHandle, L"disconnect", ShellStrToUintn(Param2), L"driver handle"); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(Param1 != NULL); Status = gBS->DisconnectController(Handle1, Handle2, Handle3); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_3P_RESULT), gShellDriver1HiiHandle, L"Disconnect", (UINTN)Intermediate1, (UINTN)Intermediate2, (UINTN)Intermediate3, Status); } } } } if (ShellStatus == SHELL_SUCCESS) { if (Status == EFI_SECURITY_VIOLATION) { ShellStatus = SHELL_SECURITY_VIOLATION; } else if (Status == EFI_INVALID_PARAMETER) { ShellStatus = SHELL_INVALID_PARAMETER; } else if (EFI_ERROR(Status)) { ShellStatus = SHELL_NOT_FOUND; } } return (ShellStatus); }
/** Get a human readable name for an image handle. The following methods will be tried orderly: 1. Image PDB 2. ComponentName2 protocol 3. FFS UI section 4. Image GUID 5. Image DevicePath 6. Unknown Driver Name @param[in] Handle @post The resulting Unicode name string is stored in the mGaugeString global array. **/ VOID DpGetNameFromHandle ( IN EFI_HANDLE Handle ) { EFI_STATUS Status; EFI_LOADED_IMAGE_PROTOCOL *Image; CHAR8 *PdbFileName; EFI_DRIVER_BINDING_PROTOCOL *DriverBinding; EFI_STRING StringPtr; EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_GUID *NameGuid; CHAR16 *NameString; UINTN StringSize; CHAR8 *PlatformLanguage; EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2; Image = NULL; LoadedImageDevicePath = NULL; DevicePath = NULL; // // Method 1: Get the name string from image PDB // Status = gBS->HandleProtocol ( Handle, &gEfiLoadedImageProtocolGuid, (VOID **) &Image ); if (EFI_ERROR (Status)) { Status = gBS->OpenProtocol ( Handle, &gEfiDriverBindingProtocolGuid, (VOID **) &DriverBinding, NULL, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); if (!EFI_ERROR (Status)) { Status = gBS->HandleProtocol ( DriverBinding->ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &Image ); } } if (!EFI_ERROR (Status)) { PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase); if (PdbFileName != NULL) { DpGetShortPdbFileName (PdbFileName, mGaugeString); return; } } // // Method 2: Get the name string from ComponentName2 protocol // Status = gBS->HandleProtocol ( Handle, &gEfiComponentName2ProtocolGuid, (VOID **) &ComponentName2 ); if (!EFI_ERROR (Status)) { // // Get the current platform language setting // PlatformLanguage = GetBestLanguageForDriver(ComponentName2->SupportedLanguages, NULL, FALSE); Status = ComponentName2->GetDriverName ( ComponentName2, PlatformLanguage != NULL ? PlatformLanguage : "en-US", &StringPtr ); if (!EFI_ERROR (Status)) { SHELL_FREE_NON_NULL (PlatformLanguage); StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH); mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; return; } } Status = gBS->HandleProtocol ( Handle, &gEfiLoadedImageDevicePathProtocolGuid, (VOID **) &LoadedImageDevicePath ); if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) { DevicePath = LoadedImageDevicePath; } else if (Image != NULL) { DevicePath = Image->FilePath; } if (DevicePath != NULL) { // // Try to get image GUID from image DevicePath // NameGuid = NULL; while (!IsDevicePathEndType (DevicePath)) { NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath); if (NameGuid != NULL) { break; } DevicePath = NextDevicePathNode (DevicePath); } if (NameGuid != NULL) { // // Try to get the image's FFS UI section by image GUID // NameString = NULL; StringSize = 0; Status = GetSectionFromAnyFv ( NameGuid, EFI_SECTION_USER_INTERFACE, 0, (VOID **) &NameString, &StringSize ); if (!EFI_ERROR (Status)) { // // Method 3. Get the name string from FFS UI section // StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH); mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; FreePool (NameString); } else { // // Method 4: Get the name string from image GUID // UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid); } return; } else { // // Method 5: Get the name string from image DevicePath // NameString = ConvertDevicePathToText (DevicePath, TRUE, FALSE); if (NameString != NULL) { StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH); mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; FreePool (NameString); return; } } } // // Method 6: Unknown Driver Name // StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL); ASSERT (StringPtr != NULL); StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH); FreePool (StringPtr); }
/** Function for 'drvdiag' 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 ShellCommandRunDrvDiag ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; LIST_ENTRY *Package; CHAR16 *ProblemParam; SHELL_STATUS ShellStatus; DRV_DIAG_TEST_MODE Mode; CHAR8 *Language; CONST CHAR16 *DriverHandleStr; CONST CHAR16 *ControllerHandleStr; CONST CHAR16 *ChildHandleStr; CONST CHAR16 *Lang; EFI_HANDLE Handle1; EFI_HANDLE Handle2; EFI_HANDLE Handle3; UINT64 Intermediate; ShellStatus = SHELL_SUCCESS; Mode = TestModeMax; 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, ProblemParam); FreePool(ProblemParam); ShellStatus = SHELL_INVALID_PARAMETER; } else { ASSERT(FALSE); } } else { // // if more than 3 'value' parameters (plus the name one) or we have any 2 mode flags // if ((ShellCommandLineGetCount(Package) > 4) ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-e")) ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-m")) ||(ShellCommandLineGetFlag(Package, L"-e") && ShellCommandLineGetFlag(Package, L"-m")) ){ // // error for too many parameters // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; } else if ((ShellCommandLineGetFlag(Package, L"-s")) || (ShellCommandLineGetFlag(Package, L"-e")) || (ShellCommandLineGetFlag(Package, L"-m")) ){ // // Run the apropriate test // if (ShellCommandLineGetFlag(Package, L"-s")) { Mode = TestModeStandard; } else if (ShellCommandLineGetFlag(Package, L"-e")) { Mode = TestModeExtended; } else if (ShellCommandLineGetFlag(Package, L"-m")) { Mode = TestModeManufacturing; } else { ASSERT(FALSE); } } else { // // Do a listing of what's available to test // Mode = TestModeList; } Lang = ShellCommandLineGetValue(Package, L"-l"); if (ShellCommandLineGetFlag(Package, L"-l") && Lang == NULL) { ASSERT(Language == NULL); ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l"); ShellCommandLineFreeVarList (Package); return (SHELL_INVALID_PARAMETER); } else if (Lang != NULL) { Language = AllocateZeroPool(StrSize(Lang)); AsciiSPrint(Language, StrSize(Lang), "%S", Lang); } DriverHandleStr = ShellCommandLineGetRawValue(Package, 1); ControllerHandleStr = ShellCommandLineGetRawValue(Package, 2); ChildHandleStr = ShellCommandLineGetRawValue(Package, 3); if (DriverHandleStr == NULL) { Handle1 = NULL; } else { ShellConvertStringToUint64(DriverHandleStr, &Intermediate, TRUE, FALSE); Handle1 = ConvertHandleIndexToHandle((UINTN)Intermediate); } if (ControllerHandleStr == NULL) { Handle2 = NULL; } else { ShellConvertStringToUint64(ControllerHandleStr, &Intermediate, TRUE, FALSE); Handle2 = ConvertHandleIndexToHandle((UINTN)Intermediate); } if (ChildHandleStr == NULL) { Handle3 = NULL; } else { ShellConvertStringToUint64(ChildHandleStr, &Intermediate, TRUE, FALSE); Handle3 = ConvertHandleIndexToHandle((UINTN)Intermediate); } Status = DoDiagnostics ( Mode, Language, ShellCommandLineGetFlag(Package, L"-c"), Handle1, Handle2, Handle3 ); SHELL_FREE_NON_NULL(Language); ShellCommandLineFreeVarList (Package); } if (ShellStatus == SHELL_SUCCESS) { if (Status == EFI_SECURITY_VIOLATION) { ShellStatus = SHELL_SECURITY_VIOLATION; } else if (Status == EFI_INVALID_PARAMETER) { ShellStatus = SHELL_INVALID_PARAMETER; } else if (Status == EFI_NOT_FOUND) { ShellStatus = SHELL_NOT_FOUND; } else if (EFI_ERROR(Status)) { ShellStatus = SHELL_NOT_FOUND; } } return (ShellStatus); }