/** Save question id and prompt id to the mac device list. If the same mac address has saved yet, no need to add more. @param MacAddrString Mac address string. @retval EFI_SUCCESS Add the item is successful. @return Other values if failed to Add the item. **/ BOOLEAN AddIdToMacDeviceList ( IN EFI_STRING MacAddrString ) { MENU_INFO_ITEM *TempDeviceList; UINTN Index; EFI_STRING StoredString; EFI_STRING_ID PromptId; EFI_HII_HANDLE HiiHandle; HiiHandle = gDeviceManagerPrivate.HiiHandle; TempDeviceList = NULL; for (Index = 0; Index < mMacDeviceList.CurListLen; Index ++) { StoredString = HiiGetString (HiiHandle, mMacDeviceList.NodeList[Index].PromptId, NULL); if (StoredString == NULL) { return FALSE; } // // Already has save the same mac address to the list. // if (StrCmp (MacAddrString, StoredString) == 0) { return FALSE; } } PromptId = HiiSetString(HiiHandle, 0, MacAddrString, NULL); // // If not in the list, save it. // if (mMacDeviceList.MaxListLen > mMacDeviceList.CurListLen + 1) { mMacDeviceList.NodeList[mMacDeviceList.CurListLen].PromptId = PromptId; mMacDeviceList.NodeList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET); } else { mMacDeviceList.MaxListLen += MAX_MAC_ADDRESS_NODE_LIST_LEN; if (mMacDeviceList.CurListLen != 0) { TempDeviceList = (MENU_INFO_ITEM *)AllocateCopyPool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen, (VOID *)mMacDeviceList.NodeList); } else { TempDeviceList = (MENU_INFO_ITEM *)AllocatePool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen); } if (TempDeviceList == NULL) { return FALSE; } TempDeviceList[mMacDeviceList.CurListLen].PromptId = PromptId; TempDeviceList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET); if (mMacDeviceList.CurListLen > 0) { FreePool(mMacDeviceList.NodeList); } mMacDeviceList.NodeList = TempDeviceList; } mMacDeviceList.CurListLen ++; return TRUE; }
/** Gather and print ALL Profiling Records. Displays all "interesting" Profile measurements in order. The number of records displayed is controlled by: - records with a duration less than mInterestThreshold microseconds are not displayed. - No more than Limit records are displayed. A Limit of zero will not limit the output. - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not displayed. @pre The mInterestThreshold global variable is set to the shortest duration to be printed. The mGaugeString and mUnicodeToken global arrays are used for temporary string storage. They must not be in use by a calling function. @param[in] Limit The number of records to print. Zero is ALL. @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. **/ VOID DumpAllProfile( IN UINTN Limit, IN BOOLEAN ExcludeFlag ) { EFI_STRING StringPtr; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PROFILE), NULL); ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle, (StringPtr == NULL) ? StringPtrUnknown: StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); }
/** Update add boot/driver option page. @param CallbackData The BMM context data. @param FormId The form ID to be updated. @param DevicePath Device path. **/ VOID UpdateOptionPage( IN BMM_CALLBACK_DATA *CallbackData, IN EFI_FORM_ID FormId, IN EFI_DEVICE_PATH_PROTOCOL *DevicePath ) { CHAR16 *String; EFI_STRING_ID StringToken; String = NULL; if (DevicePath != NULL){ String = ExtractFileNameFromDevicePath(DevicePath); } if (String == NULL) { String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL); ASSERT (String != NULL); } StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL); FreePool (String); if(FormId == FORM_BOOT_ADD_ID){ if (!CallbackData->BmmFakeNvData.BootOptionChanged) { ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData)); ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData)); ZeroMem (CallbackData->BmmOldFakeNVData.BootOptionalData, sizeof (CallbackData->BmmOldFakeNVData.BootOptionalData)); ZeroMem (CallbackData->BmmOldFakeNVData.BootDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.BootDescriptionData)); } } else if (FormId == FORM_DRV_ADD_FILE_ID){ if (!CallbackData->BmmFakeNvData.DriverOptionChanged) { ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData)); ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData)); ZeroMem (CallbackData->BmmOldFakeNVData.DriverOptionalData, sizeof (CallbackData->BmmOldFakeNVData.DriverOptionalData)); ZeroMem (CallbackData->BmmOldFakeNVData.DriverDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.DriverDescriptionData)); } } RefreshUpdateData(); mStartLabel->Number = FormId; HiiCreateSubTitleOpCode ( mStartOpCodeHandle, StringToken, 0, 0, 0 ); HiiUpdateForm ( CallbackData->BmmHiiHandle, &mBootMaintGuid, FormId, mStartOpCodeHandle,// Label FormId mEndOpCodeHandle // LABEL_END ); }
/** Get string by string id from HII Interface. @param[in] Id String ID to get the string from. @retval CHAR16 * String from ID. @retval NULL If error occurs. **/ CHAR16 * GetStringById ( IN EFI_STRING_ID Id ) { // // Get the current string for the current Language // return HiiGetString (mCallbackInfo->HiiHandle, Id, NULL); }
/** Gather and print cumulative data. Traverse the measurement records and:<BR> For each record with a Token listed in the CumData array:<BR> - Update the instance count and the total, minimum, and maximum durations. Finally, print the gathered cumulative statistics. **/ VOID ProcessCumulative( VOID ) { UINT64 AvgDur; // the computed average duration UINT64 Dur; UINT64 MinDur; UINT64 MaxDur; EFI_STRING StringPtr; UINTN TIndex; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown: StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1)); PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2)); PrintToken (STRING_TOKEN (STR_DP_DASHES)); for ( TIndex = 0; TIndex < NumCum; ++TIndex) { if (CumData[TIndex].Count != 0) { AvgDur = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count); AvgDur = DurationInMicroSeconds(AvgDur); Dur = DurationInMicroSeconds(CumData[TIndex].Duration); MaxDur = DurationInMicroSeconds(CumData[TIndex].MaxDur); MinDur = DurationInMicroSeconds(CumData[TIndex].MinDur); PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_STATS), CumData[TIndex].Name, CumData[TIndex].Count, Dur, AvgDur, MinDur, MaxDur ); } } }
/** Display the trailing Verbose information. **/ VOID DumpStatistics( void ) { EFI_STRING StringPtr; EFI_STRING StringPtrUnknown; StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_STATISTICS), NULL); StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown : StringPtr); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMTRACE), SummaryData.NumTrace); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMINCOMPLETE), SummaryData.NumIncomplete); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMPHASES), SummaryData.NumSummary); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMHANDLES), SummaryData.NumHandles, SummaryData.NumTrace - SummaryData.NumHandles); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMPEIMS), SummaryData.NumPEIMs); PrintToken( STRING_TOKEN (STR_DP_STATS_NUMGLOBALS), SummaryData.NumGlobal); #if PROFILING_IMPLEMENTED PrintToken( STRING_TOKEN (STR_DP_STATS_NUMPROFILE), SummaryData.NumProfile); #endif // PROFILING_IMPLEMENTED FreePool (StringPtr); FreePool (StringPtrUnknown); }
EFIAPI ShellDynCmdDumpFdtGetHelp ( IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *This, IN CONST CHAR8 *Language ) { // // This allocates memory. The caller has to free the allocated memory. // return HiiGetString ( mFdtPlatformDxeHiiHandle, STRING_TOKEN (STR_GET_HELP_DUMPFDT), Language ); }
/** Get the string based on the StringId and HII Package List Handle. @param Token The String's ID. @param HiiHandle The package list in the HII database to search for the specified string. @return The output string. **/ CHAR16 * LibGetToken ( IN EFI_STRING_ID Token, IN EFI_HII_HANDLE HiiHandle ) { EFI_STRING String; String = HiiGetString (HiiHandle, Token, NULL); if (String == NULL) { String = AllocateCopyPool (StrSize (mLibUnknownString), mLibUnknownString); ASSERT (String != NULL); } return (CHAR16 *) String; }
/** This call back function is registered with Boot Manager formset. When user selects a boot option, this call back function will be triggered. The boot option is saved for later processing. @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. @param Action Specifies the type of action taken by the browser. @param QuestionId A unique value which is sent to the original exporting driver so that it can identify the type of data to expect. @param Type The type of value for the question. @param Value A pointer to the data being sent to the original exporting driver. @param ActionRequest On return, points to the action requested by the callback function. @retval EFI_SUCCESS The callback successfully handled the action. @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters. **/ EFI_STATUS EFIAPI BootManagerCallback ( IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, IN EFI_BROWSER_ACTION Action, IN EFI_QUESTION_ID QuestionId, IN UINT8 Type, IN EFI_IFR_TYPE_VALUE *Value, OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest ) { EFI_BOOT_MANAGER_LOAD_OPTION *BootOption; UINTN BootOptionCount; EFI_INPUT_KEY Key; if (Action != EFI_BROWSER_ACTION_CHANGED) { // // Do nothing for other UEFI Action. Only do call back when data is changed. // return EFI_UNSUPPORTED; } if ((Value == NULL) || (ActionRequest == NULL)) { return EFI_INVALID_PARAMETER; } BootOption = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot); // // parse the selected option // BmBdsSetConsoleMode (FALSE); EfiBootManagerBoot (&BootOption[QuestionId - 1]); BmBdsSetConsoleMode (TRUE); if (EFI_ERROR (BootOption[QuestionId - 1].Status)) { gST->ConOut->OutputString ( gST->ConOut, HiiGetString (gBootManagerPrivate.HiiHandle, STRING_TOKEN (STR_ANY_KEY_CONTINUE), NULL) ); gST->ConIn->ReadKeyStroke (gST->ConIn, &Key); } EfiBootManagerFreeLoadOptions (BootOption, BootOptionCount); return EFI_SUCCESS; }
/** Transfer the param list value and get the command line parse. **/ VOID InitialShellParamList( void ) { UINT32 ListIndex; UINT32 ListLength; // // Allocate one more for the end tag. // ListLength = sizeof (ParamList) / sizeof (ParamList[0]) + 1; DpParamList = AllocatePool (sizeof (SHELL_PARAM_ITEM) * ListLength); ASSERT (DpParamList != NULL); for (ListIndex = 0; ListIndex < ListLength - 1; ListIndex ++) { DpParamList[ListIndex].Name = HiiGetString (gHiiHandle, ParamList[ListIndex].Token, NULL); DpParamList[ListIndex].Type = ParamList[ListIndex].Type; } DpParamList[ListIndex].Name = NULL; DpParamList[ListIndex].Type = TypeMax; }
/** This function is invoked if user selected a interactive opcode from Device Manager's Formset. If user set VBIOS, the new value is saved to EFI variable. @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. @param Action Specifies the type of action taken by the browser. @param QuestionId A unique value which is sent to the original exporting driver so that it can identify the type of data to expect. @param Type The type of value for the question. @param Value A pointer to the data being sent to the original exporting driver. @param ActionRequest On return, points to the action requested by the callback function. @retval EFI_SUCCESS The callback successfully handled the action. @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters. **/ EFI_STATUS EFIAPI DeviceManagerCallback ( IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, IN EFI_BROWSER_ACTION Action, IN EFI_QUESTION_ID QuestionId, IN UINT8 Type, IN EFI_IFR_TYPE_VALUE *Value, OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest ) { UINTN CurIndex; if (Action != EFI_BROWSER_ACTION_CHANGING) { // // Do nothing for other UEFI Action. Only do call back when data is changed. // return EFI_UNSUPPORTED; } if ((Value == NULL) || (ActionRequest == NULL)) { return EFI_INVALID_PARAMETER; } if ((QuestionId < MAX_KEY_SECTION_LEN + NETWORK_DEVICE_LIST_KEY_OFFSET) && (QuestionId >= NETWORK_DEVICE_LIST_KEY_OFFSET)) { // // If user select the mac address, need to record mac address string to support next form show. // for (CurIndex = 0; CurIndex < mMacDeviceList.CurListLen; CurIndex ++) { if (mMacDeviceList.NodeList[CurIndex].QuestionId == QuestionId) { mSelectedMacAddrString = HiiGetString (gDeviceManagerPrivate.HiiHandle, mMacDeviceList.NodeList[CurIndex].PromptId, NULL); } } CreateDeviceManagerForm(NETWORK_DEVICE_FORM_ID); } else if(QuestionId == QUESTION_NETWORK_DEVICE_ID){ CreateDeviceManagerForm(NETWORK_DEVICE_LIST_FORM_ID); } return EFI_SUCCESS; }
/** Dynamic create Hii information for Device Manager. @param NextShowFormId The FormId which need to be show. **/ VOID CreateDeviceManagerForm( IN EFI_FORM_ID NextShowFormId ) { UINTN Index; EFI_STRING String; EFI_STRING_ID Token; EFI_STRING_ID TokenHelp; EFI_HII_HANDLE *HiiHandles; EFI_HII_HANDLE HiiHandle; EFI_GUID FormSetGuid; VOID *StartOpCodeHandle; VOID *EndOpCodeHandle; EFI_IFR_GUID_LABEL *StartLabel; EFI_IFR_GUID_LABEL *EndLabel; BOOLEAN AddNetworkMenu; UINTN AddItemCount; UINTN NewStringLen; EFI_STRING NewStringTitle; CHAR16 *DevicePathStr; EFI_STRING_ID DevicePathId; EFI_IFR_FORM_SET *Buffer; UINTN BufferSize; UINT8 ClassGuidNum; EFI_GUID *ClassGuid; UINTN TempSize; UINT8 *Ptr; EFI_STATUS Status; TempSize =0; BufferSize = 0; Buffer = NULL; HiiHandle = gDeviceManagerPrivate.HiiHandle; AddNetworkMenu = FALSE; AddItemCount = 0; // // If need show the Network device list form, clear the old save list first. // if ((NextShowFormId == NETWORK_DEVICE_LIST_FORM_ID) && (mMacDeviceList.CurListLen > 0)) { mMacDeviceList.CurListLen = 0; } // // Update the network device form titile. // if (NextShowFormId == NETWORK_DEVICE_FORM_ID) { String = HiiGetString (HiiHandle, STRING_TOKEN (STR_FORM_NETWORK_DEVICE_TITLE), NULL); NewStringLen = StrLen(mSelectedMacAddrString) * 2; NewStringLen += (StrLen(String) + 2) * 2; NewStringTitle = AllocatePool (NewStringLen); UnicodeSPrint (NewStringTitle, NewStringLen, L"%s %s", String, mSelectedMacAddrString); HiiSetString (HiiHandle, STRING_TOKEN (STR_FORM_NETWORK_DEVICE_TITLE), NewStringTitle, NULL); FreePool (String); FreePool (NewStringTitle); } // // Allocate space for creation of UpdateData Buffer // StartOpCodeHandle = HiiAllocateOpCodeHandle (); ASSERT (StartOpCodeHandle != NULL); EndOpCodeHandle = HiiAllocateOpCodeHandle (); ASSERT (EndOpCodeHandle != NULL); // // Create Hii Extend Label OpCode as the start opcode // StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; // // According to the next show Form id(mNextShowFormId) to decide which form need to update. // StartLabel->Number = (UINT16) (LABEL_FORM_ID_OFFSET + NextShowFormId); // // Create Hii Extend Label OpCode as the end opcode // EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; EndLabel->Number = LABEL_END; // // Get all the Hii handles // HiiHandles = HiiGetHiiHandles (NULL); ASSERT (HiiHandles != NULL); // // Search for formset of each class type // for (Index = 0; HiiHandles[Index] != NULL; Index++) { Status = HiiGetFormSetFromHiiHandle(HiiHandles[Index], &Buffer,&BufferSize); if (EFI_ERROR (Status)){ continue; } Ptr = (UINT8 *)Buffer; while(TempSize < BufferSize) { TempSize += ((EFI_IFR_OP_HEADER *) Ptr)->Length; if (((EFI_IFR_OP_HEADER *) Ptr)->Length <= OFFSET_OF (EFI_IFR_FORM_SET, Flags)){ Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length; continue; } ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *)Ptr)->Flags & 0x3); ClassGuid = (EFI_GUID *) (VOID *)(Ptr + sizeof (EFI_IFR_FORM_SET)); while (ClassGuidNum-- > 0) { if (CompareGuid (&gEfiHiiPlatformSetupFormsetGuid, ClassGuid)== 0) { ClassGuid ++; continue; } String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->FormSetTitle, NULL); if (String == NULL) { String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL); ASSERT (String != NULL); } Token = HiiSetString (HiiHandle, 0, String, NULL); FreePool (String); String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->Help, NULL); if (String == NULL) { String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL); ASSERT (String != NULL); } TokenHelp = HiiSetString (HiiHandle, 0, String, NULL); FreePool (String); FormSetGuid = ((EFI_IFR_FORM_SET *)Ptr)->Guid; // // Network device process // if (IsNeedAddNetworkMenu (HiiHandles[Index], NextShowFormId,&AddItemCount)) { if (NextShowFormId == DEVICE_MANAGER_FORM_ID) { // // Only show one menu item "Network Config" in the device manger form. // if (!AddNetworkMenu) { AddNetworkMenu = TRUE; HiiCreateGotoOpCode ( StartOpCodeHandle, NETWORK_DEVICE_LIST_FORM_ID, STRING_TOKEN (STR_FORM_NETWORK_DEVICE_LIST_TITLE), STRING_TOKEN (STR_FORM_NETWORK_DEVICE_LIST_HELP), EFI_IFR_FLAG_CALLBACK, (EFI_QUESTION_ID) QUESTION_NETWORK_DEVICE_ID ); } } else if (NextShowFormId == NETWORK_DEVICE_LIST_FORM_ID) { // // In network device list form, same mac address device only show one menu. // while (AddItemCount > 0) { HiiCreateGotoOpCode ( StartOpCodeHandle, NETWORK_DEVICE_FORM_ID, mMacDeviceList.NodeList[mMacDeviceList.CurListLen - AddItemCount].PromptId, STRING_TOKEN (STR_NETWORK_DEVICE_HELP), EFI_IFR_FLAG_CALLBACK, mMacDeviceList.NodeList[mMacDeviceList.CurListLen - AddItemCount].QuestionId ); AddItemCount -= 1; } } else if (NextShowFormId == NETWORK_DEVICE_FORM_ID) { // // In network device form, only the selected mac address device need to be show. // DevicePathStr = DmExtractDevicePathFromHiiHandle(HiiHandles[Index]); DevicePathId = 0; if (DevicePathStr != NULL){ DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL); FreePool(DevicePathStr); } HiiCreateGotoExOpCode ( StartOpCodeHandle, 0, Token, TokenHelp, 0, (EFI_QUESTION_ID) (Index + DEVICE_KEY_OFFSET), 0, &FormSetGuid, DevicePathId ); } } else { // // Not network device process, only need to show at device manger form. // if (NextShowFormId == DEVICE_MANAGER_FORM_ID) { DevicePathStr = DmExtractDevicePathFromHiiHandle(HiiHandles[Index]); DevicePathId = 0; if (DevicePathStr != NULL){ DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL); FreePool(DevicePathStr); } HiiCreateGotoExOpCode ( StartOpCodeHandle, 0, Token, TokenHelp, 0, (EFI_QUESTION_ID) (Index + DEVICE_KEY_OFFSET), 0, &FormSetGuid, DevicePathId ); } } break; } Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length; } FreePool(Buffer); Buffer = NULL; TempSize = 0; BufferSize = 0; } HiiUpdateForm ( HiiHandle, &mDeviceManagerGuid, NextShowFormId, StartOpCodeHandle, EndOpCodeHandle ); HiiFreeOpCodeHandle (StartOpCodeHandle); HiiFreeOpCodeHandle (EndOpCodeHandle); FreePool (HiiHandles); }
/** Gather and print ALL Trace Records. Displays all "interesting" Trace measurements in order.<BR> The number of records displayed is controlled by: - records with a duration less than mInterestThreshold microseconds are not displayed. - No more than Limit records are displayed. A Limit of zero will not limit the output. - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not displayed. @pre The mInterestThreshold global variable is set to the shortest duration to be printed. The mGaugeString and mUnicodeToken global arrays are used for temporary string storage. They must not be in use by a calling function. @param[in] Limit The number of records to print. Zero is ALL. @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. **/ VOID DumpAllTrace( IN UINTN Limit, IN BOOLEAN ExcludeFlag ) { MEASUREMENT_RECORD Measurement; UINT64 ElapsedTime; UINT64 Duration; const CHAR16 *IncFlag; UINTN LogEntryKey; UINTN Count; UINTN Index; UINTN TIndex; EFI_HANDLE *HandleBuffer; UINTN Size; EFI_HANDLE TempHandle; EFI_STATUS Status; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_ALL), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (IncFlag == NULL) ? StringPtrUnknown : IncFlag); FreePool (StringPtrUnknown); // Get Handle information // Size = 0; HandleBuffer = &TempHandle; Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle); if (Status == EFI_BUFFER_TOO_SMALL) { HandleBuffer = AllocatePool (Size); ASSERT (HandleBuffer != NULL); if (HandleBuffer == NULL) { return; } Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer); } if (EFI_ERROR (Status)) { PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status); } else { // We have successfully populated the HandleBuffer // Display ALL Measurement Records // Up to Limit lines displayed // Display only records with Elapsed times >= mInterestThreshold // Display driver names in Module field for records with Handles. // if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_ALL_HEADR2) ); PrintToken (STRING_TOKEN (STR_DP_ALL_DASHES2) ); } else { PrintToken (STRING_TOKEN (STR_DP_ALL_HEADR) ); PrintToken (STRING_TOKEN (STR_DP_DASHES) ); } LogEntryKey = 0; Count = 0; Index = 0; while ( WITHIN_LIMIT(Count, Limit) && ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) ) { ++Index; // Count every record. First record is 1. ElapsedTime = 0; SafeFreePool ((VOID *) IncFlag); if (Measurement.EndTimeStamp != 0) { Duration = GetDuration (&Measurement); ElapsedTime = DurationInMicroSeconds ( Duration ); IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_COMPLETE), NULL); } else { IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_INCOMPLETE), NULL); // Mark incomplete records } if (((Measurement.EndTimeStamp != 0) && (ElapsedTime < mInterestThreshold)) || ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) ) { // Ignore "uninteresting" or excluded records continue; } ++Count; // Count the number of records printed // If Handle is non-zero, see if we can determine a name for the driver AsciiStrToUnicodeStr (Measurement.Module, mGaugeString); // Use Module by default AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken); if (Measurement.Handle != NULL) { // See if the Handle is in the HandleBuffer for (TIndex = 0; TIndex < (Size / sizeof(HandleBuffer[0])); TIndex++) { if (Measurement.Handle == HandleBuffer[TIndex]) { GetNameFromHandle (HandleBuffer[TIndex]); break; } } } if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) { UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", Measurement.Handle); } // Ensure that the argument strings are not too long. mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; mUnicodeToken[13] = 0; if (mShowId) { PrintToken( STRING_TOKEN (STR_DP_ALL_VARS2), Index, // 1 based, Which measurement record is being printed IncFlag, Measurement.Handle, mGaugeString, mUnicodeToken, ElapsedTime, Measurement.Identifier ); } else { PrintToken( STRING_TOKEN (STR_DP_ALL_VARS), Index, // 1 based, Which measurement record is being printed IncFlag, Measurement.Handle, mGaugeString, mUnicodeToken, ElapsedTime ); } } } if (HandleBuffer != &TempHandle) { FreePool (HandleBuffer); } SafeFreePool ((VOID *) IncFlag); }
/** Update the banner information for the Front Page based on Smbios information. **/ VOID UpdateFrontPageBannerStrings ( VOID ) { UINT8 StrIndex; CHAR16 *NewString; CHAR16 *FirmwareVersionString; EFI_STATUS Status; EFI_SMBIOS_HANDLE SmbiosHandle; EFI_SMBIOS_PROTOCOL *Smbios; SMBIOS_TABLE_TYPE0 *Type0Record; SMBIOS_TABLE_TYPE1 *Type1Record; SMBIOS_TABLE_TYPE4 *Type4Record; SMBIOS_TABLE_TYPE19 *Type19Record; EFI_SMBIOS_TABLE_HEADER *Record; UINT64 InstalledMemory; BOOLEAN FoundCpu; InstalledMemory = 0; FoundCpu = 0; // // Update default banner string. // NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_LEFT), NULL); UiCustomizeFrontPageBanner (4, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_LEFT), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_RIGHT), NULL); UiCustomizeFrontPageBanner (4, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_RIGHT), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_LEFT), NULL); UiCustomizeFrontPageBanner (5, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_LEFT), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_RIGHT), NULL); UiCustomizeFrontPageBanner (5, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_RIGHT), NewString, NULL); FreePool (NewString); // // Update Front Page banner strings base on SmBios Table. // Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **) &Smbios); if (EFI_ERROR (Status)) { // // Smbios protocol not found, get the default value. // NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NULL); UiCustomizeFrontPageBanner (1, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NULL); UiCustomizeFrontPageBanner (2, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NULL); UiCustomizeFrontPageBanner (2, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NULL); UiCustomizeFrontPageBanner (3, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL); FreePool (NewString); NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NULL); UiCustomizeFrontPageBanner (3, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NewString, NULL); FreePool (NewString); return; } SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED; Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL); while (!EFI_ERROR(Status)) { if (Record->Type == SMBIOS_TYPE_BIOS_INFORMATION) { Type0Record = (SMBIOS_TABLE_TYPE0 *) Record; StrIndex = Type0Record->BiosVersion; GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type0Record + Type0Record->Hdr.Length), StrIndex, &NewString); FirmwareVersionString = (CHAR16 *) PcdGetPtr (PcdFirmwareVersionString); if (*FirmwareVersionString != 0x0000 ) { FreePool (NewString); NewString = (CHAR16 *) PcdGetPtr (PcdFirmwareVersionString); UiCustomizeFrontPageBanner (3, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL); } else { UiCustomizeFrontPageBanner (3, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL); FreePool (NewString); } } if (Record->Type == SMBIOS_TYPE_SYSTEM_INFORMATION) { Type1Record = (SMBIOS_TABLE_TYPE1 *) Record; StrIndex = Type1Record->ProductName; GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type1Record + Type1Record->Hdr.Length), StrIndex, &NewString); UiCustomizeFrontPageBanner (1, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NewString, NULL); FreePool (NewString); } if ((Record->Type == SMBIOS_TYPE_PROCESSOR_INFORMATION) && !FoundCpu) { Type4Record = (SMBIOS_TABLE_TYPE4 *) Record; // // The information in the record should be only valid when the CPU Socket is populated. // if ((Type4Record->Status & SMBIOS_TYPE4_CPU_SOCKET_POPULATED) == SMBIOS_TYPE4_CPU_SOCKET_POPULATED) { StrIndex = Type4Record->ProcessorVersion; GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type4Record + Type4Record->Hdr.Length), StrIndex, &NewString); UiCustomizeFrontPageBanner (2, TRUE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NewString, NULL); FreePool (NewString); ConvertProcessorToString(Type4Record->CurrentSpeed, 6, &NewString); UiCustomizeFrontPageBanner (2, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NewString, NULL); FreePool (NewString); FoundCpu = TRUE; } } if ( Record->Type == SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS ) { Type19Record = (SMBIOS_TABLE_TYPE19 *) Record; if (Type19Record->StartingAddress != 0xFFFFFFFF ) { InstalledMemory += RShiftU64(Type19Record->EndingAddress - Type19Record->StartingAddress + 1, 10); } else { InstalledMemory += RShiftU64(Type19Record->ExtendedEndingAddress - Type19Record->ExtendedStartingAddress + 1, 20); } } Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL); } // // Now update the total installed RAM size // ConvertMemorySizeToString ((UINT32)InstalledMemory, &NewString ); UiCustomizeFrontPageBanner (3, FALSE, &NewString); HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NewString, NULL); FreePool (NewString); }
/** Gather and print Raw Trace Records. All Trace measurements with a duration greater than or equal to mInterestThreshold are printed without interpretation. The number of records displayed is controlled by: - records with a duration less than mInterestThreshold microseconds are not displayed. - No more than Limit records are displayed. A Limit of zero will not limit the output. - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not displayed. @pre The mInterestThreshold global variable is set to the shortest duration to be printed. @param[in] Limit The number of records to print. Zero is ALL. @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. **/ VOID DumpRawTrace( IN UINTN Limit, IN BOOLEAN ExcludeFlag ) { MEASUREMENT_RECORD Measurement; UINT64 ElapsedTime; UINT64 Duration; UINTN LogEntryKey; UINTN Count; UINTN Index; EFI_STRING StringPtr; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWTRACE), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown : StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_RAW_HEADR2) ); PrintToken (STRING_TOKEN (STR_DP_RAW_DASHES2) ); } else { PrintToken (STRING_TOKEN (STR_DP_RAW_HEADR) ); PrintToken (STRING_TOKEN (STR_DP_RAW_DASHES) ); } LogEntryKey = 0; Count = 0; Index = 0; while ( WITHIN_LIMIT(Count, Limit) && ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) ) { ++Index; // Count every record. First record is 1. ElapsedTime = 0; if (Measurement.EndTimeStamp != 0) { Duration = GetDuration (&Measurement); ElapsedTime = DurationInMicroSeconds ( Duration ); } if ((ElapsedTime < mInterestThreshold) || ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) ) { // Ignore "uninteresting" or Excluded records continue; } ++Count; // Count the number of records printed if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_RAW_VARS2), Index, // 1 based, Which measurement record is being printed Measurement.Handle, Measurement.StartTimeStamp, Measurement.EndTimeStamp, Measurement.Token, Measurement.Module, Measurement.Identifier ); } else { PrintToken (STRING_TOKEN (STR_DP_RAW_VARS), Index, // 1 based, Which measurement record is being printed Measurement.Handle, Measurement.StartTimeStamp, Measurement.EndTimeStamp, Measurement.Token, Measurement.Module ); } } }
/** function to take a list of files to copy and a destination location and do the verification and copying of those files to that location. This function will report any errors to the user and halt. The key is to have this function called ONLY once. this allows for the parameter verification to happen correctly. @param[in] FileList A LIST_ENTRY* based list of files to move. @param[in] DestDir The destination location. @param[in] SilentMode TRUE to eliminate screen output. @param[in] RecursiveMode TRUE to copy directories. @param[in] Resp The response to the overwrite query (if always). @retval SHELL_SUCCESS the files were all moved. @retval SHELL_INVALID_PARAMETER a parameter was invalid @retval SHELL_SECURITY_VIOLATION a security violation ocurred @retval SHELL_WRITE_PROTECTED the destination was write protected @retval SHELL_OUT_OF_RESOURCES a memory allocation failed **/ SHELL_STATUS EFIAPI ValidateAndCopyFiles( IN CONST EFI_SHELL_FILE_INFO *FileList, IN CONST CHAR16 *DestDir, IN BOOLEAN SilentMode, IN BOOLEAN RecursiveMode, IN VOID **Resp ) { CHAR16 *HiiOutput; CHAR16 *HiiResultOk; CONST EFI_SHELL_FILE_INFO *Node; SHELL_STATUS ShellStatus; CHAR16 *DestPath; VOID *Response; UINTN PathLen; CONST CHAR16 *Cwd; CONST CHAR16 *TempLocation; UINTN NewSize; if (Resp == NULL) { Response = NULL; } else { Response = *Resp; } DestPath = NULL; ShellStatus = SHELL_SUCCESS; PathLen = 0; Cwd = ShellGetCurrentDir(NULL); ASSERT(FileList != NULL); ASSERT(DestDir != NULL); // // We already verified that this was present. // ASSERT(Cwd != NULL); // // If we are trying to copy multiple files... make sure we got a directory for the target... // if (EFI_ERROR(ShellIsDirectory(DestDir)) && FileList->Link.ForwardLink != FileList->Link.BackLink) { // // Error for destination not a directory // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir); return (SHELL_INVALID_PARAMETER); } for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link) ; !IsNull(&FileList->Link, &Node->Link) ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link) ){ // // skip the directory traversing stuff... // if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) { continue; } NewSize = StrSize(DestDir); NewSize += StrSize(Node->FullName); NewSize += StrSize(Cwd); if (NewSize > PathLen) { PathLen = NewSize; } // // Make sure got -r if required // if (!RecursiveMode && !EFI_ERROR(ShellIsDirectory(Node->FullName))) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_REQ), gShellLevel2HiiHandle); return (SHELL_INVALID_PARAMETER); } // // make sure got dest as dir if needed // if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(DestDir))) { // // Error for destination not a directory // ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir); return (SHELL_INVALID_PARAMETER); } } HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_CP_OUTPUT), NULL); HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL); DestPath = AllocateZeroPool(PathLen); if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) { SHELL_FREE_NON_NULL(DestPath); SHELL_FREE_NON_NULL(HiiOutput); SHELL_FREE_NON_NULL(HiiResultOk); return (SHELL_OUT_OF_RESOURCES); } // // Go through the list of files to copy... // for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link) ; !IsNull(&FileList->Link, &Node->Link) ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link) ){ if (ShellGetExecutionBreakFlag()) { break; } ASSERT(Node->FileName != NULL); ASSERT(Node->FullName != NULL); // // skip the directory traversing stuff... // if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) { continue; } if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item && EFI_ERROR(ShellIsDirectory(DestDir)) // not an existing directory ) { if (StrStr(DestDir, L":") == NULL) { // // simple copy of a single file // StrCpy(DestPath, Cwd); if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') { StrCat(DestPath, L"\\"); } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCat(DestPath, DestDir); } else { StrCpy(DestPath, DestDir); } } else { // // we have multiple files or a directory in the DestDir // // // Check for leading slash // if (DestDir[0] == L'\\') { // // Copy to the root of CWD // StrCpy(DestPath, Cwd); while (PathRemoveLastItem(DestPath)); StrCat(DestPath, DestDir+1); StrCat(DestPath, Node->FileName); } else if (StrStr(DestDir, L":") == NULL) { StrCpy(DestPath, Cwd); if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') { StrCat(DestPath, L"\\"); } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCat(DestPath, DestDir); if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') { StrCat(DestPath, L"\\"); } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') { ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL; } StrCat(DestPath, Node->FileName); } else { StrCpy(DestPath, DestDir); if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') { StrCat(DestPath, L"\\"); } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') { ((CHAR16*)DestDir)[StrLen(DestDir)-1] = CHAR_NULL; } StrCat(DestPath, Node->FileName); } } // // Make sure the path exists // if (EFI_ERROR(VerifyIntermediateDirectories(DestPath))) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_WNF), gShellLevel2HiiHandle); ShellStatus = SHELL_DEVICE_ERROR; break; } if ( !EFI_ERROR(ShellIsDirectory(Node->FullName)) && !EFI_ERROR(ShellIsDirectory(DestPath)) && StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL ){ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; break; } if (StringNoCaseCompare(&Node->FullName, &DestPath) == 0) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; break; } if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0 && (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\') ) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle); ShellStatus = SHELL_INVALID_PARAMETER; break; } PathCleanUpDirectories(DestPath); ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath); // // copy single file... // ShellStatus = CopySingleFile(Node->FullName, DestPath, &Response, SilentMode); if (ShellStatus != SHELL_SUCCESS) { break; } } if (ShellStatus == SHELL_SUCCESS && Resp == NULL) { ShellPrintEx(-1, -1, L"%s", HiiResultOk); } SHELL_FREE_NON_NULL(DestPath); SHELL_FREE_NON_NULL(HiiOutput); SHELL_FREE_NON_NULL(HiiResultOk); if (Resp == NULL) { SHELL_FREE_NON_NULL(Response); } return (ShellStatus); }
/** Install HII Config Access protocol for network device and allocate resource. @param[in] Instance The IP4 Config instance. @retval EFI_SUCCESS The HII Config Access protocol is installed. @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. @retval Others Other errors as indicated. **/ EFI_STATUS Ip4ConfigDeviceInit ( IN IP4_CONFIG_INSTANCE *Instance ) { EFI_STATUS Status; EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; VENDOR_DEVICE_PATH VendorDeviceNode; EFI_SERVICE_BINDING_PROTOCOL *MnpSb; CHAR16 *MacString; CHAR16 MenuString[128]; CHAR16 PortString[128]; CHAR16 *OldMenuString; ConfigAccess = &Instance->HiiConfigAccessProtocol; ConfigAccess->ExtractConfig = Ip4DeviceExtractConfig; ConfigAccess->RouteConfig = Ip4DeviceRouteConfig; ConfigAccess->Callback = Ip4FormCallback; // // Construct device path node for EFI HII Config Access protocol, // which consists of controller physical device path and one hardware // vendor guid node. // ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH)); VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH; VendorDeviceNode.Header.SubType = HW_VENDOR_DP; CopyGuid (&VendorDeviceNode.Guid, &gEfiNicIp4ConfigVariableGuid); SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH)); Instance->HiiVendorDevicePath = AppendDevicePathNode ( Instance->ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode ); Instance->ChildHandle = NULL; // // Install Device Path Protocol and Config Access protocol on new handle // Status = gBS->InstallMultipleProtocolInterfaces ( &Instance->ChildHandle, &gEfiDevicePathProtocolGuid, Instance->HiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, ConfigAccess, NULL ); if (!EFI_ERROR (Status)) { // // Open the Parent Handle for the child // Status = gBS->OpenProtocol ( Instance->Controller, &gEfiManagedNetworkServiceBindingProtocolGuid, (VOID **) &MnpSb, Instance->Image, Instance->ChildHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } ASSERT_EFI_ERROR (Status); // // Publish our HII data // Instance->RegisteredHandle = HiiAddPackages ( &mNicIp4ConfigNvDataGuid, Instance->ChildHandle, Ip4ConfigDxeStrings, Ip4ConfigDxeBin, NULL ); if (Instance->RegisteredHandle == NULL) { return EFI_OUT_OF_RESOURCES; } // // Append MAC string in the menu string and tile string // Status = NetLibGetMacString (Instance->Controller, Instance->Image, &MacString); if (!EFI_ERROR (Status)) { OldMenuString = HiiGetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG_FORM_TITLE), NULL); UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString); HiiSetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG_FORM_TITLE), MenuString, NULL); UnicodeSPrint (PortString, 128, L"MAC:%s", MacString); HiiSetString (Instance->RegisteredHandle, STRING_TOKEN (STR_IP4_DEVICE_FORM_TITLE), PortString, NULL); FreePool (MacString); } return Status; }
/** Install HII Config Access protocol for network device and allocate resource. @param[in, out] Instance The IP4 config2 Instance. @retval EFI_SUCCESS The HII Config Access protocol is installed. @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. @retval Others Other errors as indicated. **/ EFI_STATUS Ip4Config2FormInit ( IN OUT IP4_CONFIG2_INSTANCE *Instance ) { EFI_STATUS Status; IP4_SERVICE *IpSb; IP4_FORM_CALLBACK_INFO *CallbackInfo; EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; VENDOR_DEVICE_PATH VendorDeviceNode; EFI_SERVICE_BINDING_PROTOCOL *MnpSb; CHAR16 *MacString; CHAR16 MenuString[128]; CHAR16 PortString[128]; CHAR16 *OldMenuString; EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance); ASSERT (IpSb != NULL); CallbackInfo = &Instance->CallbackInfo; CallbackInfo->Signature = IP4_FORM_CALLBACK_INFO_SIGNATURE; Status = gBS->HandleProtocol ( IpSb->Controller, &gEfiDevicePathProtocolGuid, (VOID **) &ParentDevicePath ); if (EFI_ERROR (Status)) { return Status; } // // Construct device path node for EFI HII Config Access protocol, // which consists of controller physical device path and one hardware // vendor guid node. // ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH)); VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH; VendorDeviceNode.Header.SubType = HW_VENDOR_DP; CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid); SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH)); CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode ( ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode ); if (CallbackInfo->HiiVendorDevicePath == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } ConfigAccess = &CallbackInfo->HiiConfigAccessProtocol; ConfigAccess->ExtractConfig = Ip4FormExtractConfig; ConfigAccess->RouteConfig = Ip4FormRouteConfig; ConfigAccess->Callback = Ip4FormCallback; // // Install Device Path Protocol and Config Access protocol on new handle // Status = gBS->InstallMultipleProtocolInterfaces ( &CallbackInfo->ChildHandle, &gEfiDevicePathProtocolGuid, CallbackInfo->HiiVendorDevicePath, &gEfiHiiConfigAccessProtocolGuid, ConfigAccess, NULL ); if (!EFI_ERROR (Status)) { // // Open the Parent Handle for the child // Status = gBS->OpenProtocol ( IpSb->Controller, &gEfiManagedNetworkServiceBindingProtocolGuid, (VOID **) &MnpSb, IpSb->Image, CallbackInfo->ChildHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER ); } if (EFI_ERROR (Status)) { goto Error; } // // Publish our HII data // CallbackInfo->RegisteredHandle = HiiAddPackages ( &gIp4Config2NvDataGuid, CallbackInfo->ChildHandle, Ip4DxeStrings, Ip4Config2Bin, NULL ); if (CallbackInfo->RegisteredHandle == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Error; } // // Append MAC string in the menu help string and tile help string // Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &MacString); if (!EFI_ERROR (Status)) { OldMenuString = HiiGetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP), NULL ); UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString); HiiSetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP), MenuString, NULL ); UnicodeSPrint (PortString, 128, L"MAC:%s", MacString); HiiSetString ( CallbackInfo->RegisteredHandle, STRING_TOKEN (STR_IP4_DEVICE_FORM_HELP), PortString, NULL ); FreePool (MacString); FreePool (OldMenuString); return EFI_SUCCESS; } Error: Ip4Config2FormUnload (Instance); return Status; }
/** Gather and print Major Phase metrics. @param[in] Ticker The timer value for the END of Shell phase **/ VOID ProcessPhases( IN UINT64 Ticker ) { MEASUREMENT_RECORD Measurement; UINT64 BdsTimeoutValue; UINT64 SecTime; UINT64 PeiTime; UINT64 DxeTime; UINT64 BdsTime; UINT64 ShellTime; UINT64 ElapsedTime; UINT64 Duration; UINT64 Total; EFI_STRING StringPtr; UINTN LogEntryKey; EFI_STRING StringPtrUnknown; BdsTimeoutValue = 0; SecTime = 0; PeiTime = 0; DxeTime = 0; BdsTime = 0; ShellTime = 0; // // Get Execution Phase Statistics // StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PHASES), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown : StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); LogEntryKey = 0; while ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) { if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) { Measurement.EndTimeStamp = Ticker; } if (Measurement.EndTimeStamp == 0) { // Skip "incomplete" records continue; } Duration = GetDuration (&Measurement); if ( Measurement.Handle != NULL && (AsciiStrnCmp (Measurement.Token, ALit_BdsTO, PERF_TOKEN_LENGTH) == 0) ) { BdsTimeoutValue = Duration; } else if (AsciiStrnCmp (Measurement.Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) { SecTime = Duration; } else if (AsciiStrnCmp (Measurement.Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) { PeiTime = Duration; } else if (AsciiStrnCmp (Measurement.Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) { DxeTime = Duration; } else if (AsciiStrnCmp (Measurement.Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0) { BdsTime = Duration; } else if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) { ShellTime = Duration; } } Total = 0; // print SEC phase duration time // if (SecTime > 0) { ElapsedTime = DurationInMicroSeconds ( SecTime ); // Calculate elapsed time in microseconds Total += DivU64x32 (ElapsedTime, 1000); // Accumulate time in milliseconds PrintToken (STRING_TOKEN (STR_DP_SEC_PHASE), ElapsedTime); } // print PEI phase duration time // if (PeiTime > 0) { ElapsedTime = DivU64x32 ( PeiTime, (UINT32)TimerInfo.Frequency ); Total += ElapsedTime; PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_PEI, ElapsedTime); } // print DXE phase duration time // if (DxeTime > 0) { ElapsedTime = DivU64x32 ( DxeTime, (UINT32)TimerInfo.Frequency ); Total += ElapsedTime; PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_DXE, ElapsedTime); } // print BDS phase duration time // if (BdsTime > 0) { ElapsedTime = DivU64x32 ( BdsTime, (UINT32)TimerInfo.Frequency ); Total += ElapsedTime; PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_BDS, ElapsedTime); } if (BdsTimeoutValue > 0) { ElapsedTime = DivU64x32 ( BdsTimeoutValue, (UINT32)TimerInfo.Frequency ); PrintToken (STRING_TOKEN (STR_DP_PHASE_BDSTO), ALit_BdsTO, ElapsedTime); } // print SHELL phase duration time // if (ShellTime > 0) { ElapsedTime = DivU64x32 ( ShellTime, (UINT32)TimerInfo.Frequency ); Total += ElapsedTime; PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_SHELL, ElapsedTime); } PrintToken (STRING_TOKEN (STR_DP_TOTAL_DURATION), Total); }
/** Update the form to include the driver health instances. @param ConfigureOnly Only include the configure required driver health instances when TRUE, include all the driver health instances otherwise. **/ VOID DriverHealthManagerUpdateForm ( BOOLEAN ConfigureOnly ) { EFI_STATUS Status; EFI_IFR_GUID_LABEL *StartLabel; EFI_IFR_GUID_LABEL *EndLabel; VOID *StartOpCodeHandle; VOID *EndOpCodeHandle; UINTN Index; EFI_STRING_ID Prompt; EFI_STRING_ID Help; CHAR16 String[512]; UINTN StringCount; EFI_STRING TmpString; EFI_STRING DriverName; EFI_STRING ControllerName; UINTN MessageIndex; EFI_HANDLE DriverHandle; EFI_STRING_ID DevicePath; EFI_GUID FormsetGuid; EfiBootManagerFreeDriverHealthInfo (mDriverHealthManagerHealthInfo, mDriverHealthManagerHealthInfoCount); mDriverHealthManagerHealthInfo = EfiBootManagerGetDriverHealthInfo (&mDriverHealthManagerHealthInfoCount); // // Allocate space for creation of UpdateData Buffer // StartOpCodeHandle = HiiAllocateOpCodeHandle (); ASSERT (StartOpCodeHandle != NULL); EndOpCodeHandle = HiiAllocateOpCodeHandle (); ASSERT (EndOpCodeHandle != NULL); // // Create Hii Extend Label OpCode as the start opcode // StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; StartLabel->Number = LABEL_BEGIN; // // Create Hii Extend Label OpCode as the end opcode // EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; EndLabel->Number = LABEL_END; for (Index = 0; Index < mDriverHealthManagerHealthInfoCount; Index++) { if (ConfigureOnly && mDriverHealthManagerHealthInfo[Index].HealthStatus != EfiDriverHealthStatusConfigurationRequired) { continue; } DriverName = DriverHealthManagerGetDriverName (mDriverHealthManagerHealthInfo[Index].DriverHealthHandle); ASSERT (DriverName != NULL); if (mDriverHealthManagerHealthInfo[Index].ControllerHandle == NULL) { // // The ControllerHandle is set to NULL and the HealthStatus is set to EfiDriverHealthStatusHealthy // if all the controllers managed by the driver are in healthy state. // ASSERT (mDriverHealthManagerHealthInfo[Index].HealthStatus == EfiDriverHealthStatusHealthy); UnicodeSPrint (String, sizeof (String), L"%s", DriverName); } else { ControllerName = DriverHealthManagerGetControllerName ( mDriverHealthManagerHealthInfo[Index].DriverHealthHandle, mDriverHealthManagerHealthInfo[Index].ControllerHandle, mDriverHealthManagerHealthInfo[Index].ChildHandle ); ASSERT (ControllerName != NULL); UnicodeSPrint (String, sizeof (String), L"%s %s", DriverName, ControllerName); FreePool (ControllerName); } FreePool (DriverName); Prompt = HiiSetString (mDriverHealthManagerHiiHandle, 0, String, NULL); switch(mDriverHealthManagerHealthInfo[Index].HealthStatus) { case EfiDriverHealthStatusRepairRequired: TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_REPAIR_REQUIRED), NULL); break; case EfiDriverHealthStatusConfigurationRequired: TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_CONFIGURATION_REQUIRED), NULL); break; case EfiDriverHealthStatusFailed: TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_FAILED), NULL); break; case EfiDriverHealthStatusReconnectRequired: TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_RECONNECT_REQUIRED), NULL); break; case EfiDriverHealthStatusRebootRequired: TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_REBOOT_REQUIRED), NULL); break; default: ASSERT (mDriverHealthManagerHealthInfo[Index].HealthStatus == EfiDriverHealthStatusHealthy); TmpString = HiiGetString (mDriverHealthManagerHiiHandle, STRING_TOKEN (STR_HEALTHY), NULL); break; } StringCount = UnicodeSPrint (String, sizeof (String), L"%s\n", TmpString); FreePool (TmpString); // // Add the message of the Module itself provided as the help. // if (mDriverHealthManagerHealthInfo[Index].MessageList != NULL) { for (MessageIndex = 0; mDriverHealthManagerHealthInfo[Index].MessageList[MessageIndex].HiiHandle != NULL; MessageIndex++) { TmpString = HiiGetString ( mDriverHealthManagerHealthInfo[Index].MessageList[MessageIndex].HiiHandle, mDriverHealthManagerHealthInfo[Index].MessageList[MessageIndex].StringId, NULL ); StringCount += UnicodeSPrint (String + StringCount, sizeof (String) - sizeof (String[0]) * StringCount, L"\n%s", TmpString); FreePool (TmpString); } } Help = HiiSetString (mDriverHealthManagerHiiHandle, 0, String, NULL); switch (mDriverHealthManagerHealthInfo[Index].HealthStatus) { case EfiDriverHealthStatusConfigurationRequired: Status = mDriverHealthManagerDatabase->GetPackageListHandle ( mDriverHealthManagerDatabase, mDriverHealthManagerHealthInfo[Index].HiiHandle, &DriverHandle ); ASSERT_EFI_ERROR (Status); TmpString = ConvertDevicePathToText (DevicePathFromHandle (DriverHandle), FALSE, TRUE); DevicePath = HiiSetString (mDriverHealthManagerHiiHandle, 0, TmpString, NULL); FreePool (TmpString); Status = DriverHealthManagerGetFormsetId (mDriverHealthManagerHealthInfo[Index].HiiHandle, &FormsetGuid); ASSERT_EFI_ERROR (Status); HiiCreateGotoExOpCode ( StartOpCodeHandle, 0, Prompt, Help, 0, 0, 0, &FormsetGuid, DevicePath ); break; case EfiDriverHealthStatusRepairRequired: case EfiDriverHealthStatusReconnectRequired: case EfiDriverHealthStatusRebootRequired: HiiCreateActionOpCode ( StartOpCodeHandle, (EFI_QUESTION_ID) (Index + QUESTION_ID_DRIVER_HEALTH_BASE), Prompt, Help, EFI_IFR_FLAG_CALLBACK, 0 ); break; default: ASSERT (mDriverHealthManagerHealthInfo[Index].HealthStatus == EfiDriverHealthStatusHealthy || mDriverHealthManagerHealthInfo[Index].HealthStatus == EfiDriverHealthStatusFailed); HiiCreateTextOpCode ( StartOpCodeHandle, Prompt, Help, 0 ); break; } } Status = HiiUpdateForm ( mDriverHealthManagerHiiHandle, ConfigureOnly ? PcdGetPtr (PcdDriverHealthConfigureForm) : &mDriverHealthManagerForm, DRIVER_HEALTH_FORM_ID, StartOpCodeHandle, EndOpCodeHandle ); ASSERT_EFI_ERROR (Status); HiiFreeOpCodeHandle (StartOpCodeHandle); HiiFreeOpCodeHandle (EndOpCodeHandle); }
/** Search the drivers in the system which need to show in the front page and insert the menu to the front page. @param HiiHandle The hii handle for the Uiapp driver. @param ClassGuid The class guid for the driver which is the target. @param SpecialHandlerFn The pointer to the specail handler function, if any. @param StartOpCodeHandle The opcode handle to save the new opcode. @retval EFI_SUCCESS Search the driver success **/ EFI_STATUS UiListThirdPartyDrivers ( IN EFI_HII_HANDLE HiiHandle, IN EFI_GUID *ClassGuid, IN DRIVER_SPECIAL_HANDLER SpecialHandlerFn, IN VOID *StartOpCodeHandle ) { UINTN Index; EFI_STRING String; EFI_STRING_ID Token; EFI_STRING_ID TokenHelp; EFI_HII_HANDLE *HiiHandles; CHAR16 *DevicePathStr; UINTN Count; UINTN CurrentSize; UI_HII_DRIVER_INSTANCE *DriverListPtr; EFI_STRING NewName; BOOLEAN EmptyLineAfter; if (gHiiDriverList != NULL) { FreePool (gHiiDriverList); } HiiHandles = HiiGetHiiHandles (NULL); ASSERT (HiiHandles != NULL); gHiiDriverList = AllocateZeroPool (UI_HII_DRIVER_LIST_SIZE * sizeof (UI_HII_DRIVER_INSTANCE)); ASSERT (gHiiDriverList != NULL); DriverListPtr = gHiiDriverList; CurrentSize = UI_HII_DRIVER_LIST_SIZE; for (Index = 0, Count = 0; HiiHandles[Index] != NULL; Index++) { if (!RequiredDriver (HiiHandles[Index], ClassGuid, &Token, &TokenHelp, &gHiiDriverList[Count].FormSetGuid)) { continue; } String = HiiGetString (HiiHandles[Index], Token, NULL); if (String == NULL) { String = HiiGetString (gStringPackHandle, STRING_TOKEN (STR_MISSING_STRING), NULL); ASSERT (String != NULL); } else if (SpecialHandlerFn != NULL) { // // Check whether need to rename the driver name. // EmptyLineAfter = FALSE; if (SpecialHandlerFn (String, &NewName, &EmptyLineAfter)) { FreePool (String); String = NewName; DriverListPtr[Count].EmptyLineAfter = EmptyLineAfter; } } DriverListPtr[Count].PromptId = HiiSetString (HiiHandle, 0, String, NULL); FreePool (String); String = HiiGetString (HiiHandles[Index], TokenHelp, NULL); if (String == NULL) { String = HiiGetString (gStringPackHandle, STRING_TOKEN (STR_MISSING_STRING), NULL); ASSERT (String != NULL); } DriverListPtr[Count].HelpId = HiiSetString (HiiHandle, 0, String, NULL); FreePool (String); DevicePathStr = ExtractDevicePathFromHiiHandle(HiiHandles[Index]); if (DevicePathStr != NULL){ DriverListPtr[Count].DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL); FreePool (DevicePathStr); } else { DriverListPtr[Count].DevicePathId = 0; } Count++; if (Count >= CurrentSize) { DriverListPtr = ReallocatePool ( CurrentSize * sizeof (UI_HII_DRIVER_INSTANCE), (Count + UI_HII_DRIVER_LIST_SIZE) * sizeof (UI_HII_DRIVER_INSTANCE), gHiiDriverList ); ASSERT (DriverListPtr != NULL); gHiiDriverList = DriverListPtr; CurrentSize += UI_HII_DRIVER_LIST_SIZE; } } FreePool (HiiHandles); Index = 0; while (gHiiDriverList[Index].PromptId != 0) { HiiCreateGotoExOpCode ( StartOpCodeHandle, 0, gHiiDriverList[Index].PromptId, gHiiDriverList[Index].HelpId, 0, (EFI_QUESTION_ID) (Index + FRONT_PAGE_KEY_DRIVER), 0, &gHiiDriverList[Index].FormSetGuid, gHiiDriverList[Index].DevicePathId ); if (gHiiDriverList[Index].EmptyLineAfter) { UiCreateEmptyLine (HiiHandle, StartOpCodeHandle); } Index ++; } return EFI_SUCCESS; }
/** Gather and print Handle data. @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. @return Status from a call to gBS->LocateHandle(). **/ EFI_STATUS ProcessHandles( IN BOOLEAN ExcludeFlag ) { MEASUREMENT_RECORD Measurement; UINT64 ElapsedTime; UINT64 Duration; EFI_HANDLE *HandleBuffer; EFI_STRING StringPtr; UINTN Index; UINTN LogEntryKey; UINTN Count; UINTN Size; EFI_HANDLE TempHandle; EFI_STATUS Status; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_DRIVERS), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown : StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); Size = 0; HandleBuffer = &TempHandle; Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle); if (Status == EFI_BUFFER_TOO_SMALL) { HandleBuffer = AllocatePool (Size); ASSERT (HandleBuffer != NULL); if (HandleBuffer == NULL) { return Status; } Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer); } if (EFI_ERROR (Status)) { PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status); } else { #if DP_DEBUG == 2 Print (L"There are %,d Handles defined.\n", (Size / sizeof(HandleBuffer[0]))); #endif if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_HANDLE_SECTION2) ); } else { PrintToken (STRING_TOKEN (STR_DP_HANDLE_SECTION) ); } PrintToken (STRING_TOKEN (STR_DP_DASHES) ); LogEntryKey = 0; Count = 0; while ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) { Count++; Duration = GetDuration (&Measurement); ElapsedTime = DurationInMicroSeconds ( Duration ); if ((ElapsedTime < mInterestThreshold) || (Measurement.EndTimeStamp == 0) || (Measurement.Handle == NULL) || ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) ) { // Ignore "uninteresting" or excluded records continue; } mGaugeString[0] = 0; // Empty driver name by default AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken); // See if the Handle is in the HandleBuffer for (Index = 0; Index < (Size / sizeof(HandleBuffer[0])); Index++) { if (Measurement.Handle == HandleBuffer[Index]) { GetNameFromHandle (HandleBuffer[Index]); // Name is put into mGaugeString break; } } // Ensure that the argument strings are not too long. mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; mUnicodeToken[11] = 0; if (mGaugeString[0] != 0) { // Display the record if it has a valid handle. if (mShowId) { PrintToken ( STRING_TOKEN (STR_DP_HANDLE_VARS2), Count, // 1 based, Which measurement record is being printed Index + 1, // 1 based, Which handle is being printed mGaugeString, mUnicodeToken, ElapsedTime, Measurement.Identifier ); } else { PrintToken ( STRING_TOKEN (STR_DP_HANDLE_VARS), Count, // 1 based, Which measurement record is being printed Index + 1, // 1 based, Which handle is being printed mGaugeString, mUnicodeToken, ElapsedTime ); } } } } if (HandleBuffer != &TempHandle) { FreePool (HandleBuffer); } return Status; }
/** function to take a list of files to move and a destination location and do the verification and moving of those files to that location. This function will report any errors to the user and continue to move the rest of the files. @param[in] FileList A LIST_ENTRY* based list of files to move @param[out] Resp pointer to response from question. Pass back on looped calling @param[in] DestParameter the originally specified destination location @retval SHELL_SUCCESS the files were all moved. @retval SHELL_INVALID_PARAMETER a parameter was invalid @retval SHELL_SECURITY_VIOLATION a security violation ocurred @retval SHELL_WRITE_PROTECTED the destination was write protected @retval SHELL_OUT_OF_RESOURCES a memory allocation failed **/ SHELL_STATUS EFIAPI ValidateAndMoveFiles( IN EFI_SHELL_FILE_INFO *FileList, OUT VOID **Resp, IN CONST CHAR16 *DestParameter ) { EFI_STATUS Status; CHAR16 *HiiOutput; CHAR16 *HiiResultOk; CHAR16 *DestPath; CHAR16 *FullDestPath; CONST CHAR16 *Cwd; CHAR16 *FullCwd; SHELL_STATUS ShellStatus; EFI_SHELL_FILE_INFO *Node; VOID *Response; UINT64 Attr; CHAR16 *CleanFilePathStr; ASSERT(FileList != NULL); ASSERT(DestParameter != NULL); DestPath = NULL; FullDestPath = NULL; Cwd = ShellGetCurrentDir(NULL); Response = *Resp; Attr = 0; CleanFilePathStr = NULL; FullCwd = NULL; if (Cwd != NULL) { FullCwd = AllocateZeroPool(StrSize(Cwd) + sizeof(CHAR16)); if (FullCwd == NULL) { return SHELL_OUT_OF_RESOURCES; } else { StrCpyS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, Cwd); StrCatS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, L"\\"); } } Status = ShellLevel2StripQuotes (DestParameter, &CleanFilePathStr); if (EFI_ERROR (Status)) { SHELL_FREE_NON_NULL(FullCwd); if (Status == EFI_OUT_OF_RESOURCES) { return SHELL_OUT_OF_RESOURCES; } else { return SHELL_INVALID_PARAMETER; } } ASSERT (CleanFilePathStr != NULL); // // Get and validate the destination location // ShellStatus = GetDestinationLocation(CleanFilePathStr, &DestPath, FullCwd, (BOOLEAN)(FileList->Link.ForwardLink == FileList->Link.BackLink), &Attr); FreePool (CleanFilePathStr); if (ShellStatus != SHELL_SUCCESS) { SHELL_FREE_NON_NULL (FullCwd); return (ShellStatus); } DestPath = PathCleanUpDirectories(DestPath); if (DestPath == NULL) { FreePool (FullCwd); return (SHELL_OUT_OF_RESOURCES); } HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MV_OUTPUT), NULL); HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL); if (HiiOutput == NULL || HiiResultOk == NULL) { SHELL_FREE_NON_NULL(DestPath); SHELL_FREE_NON_NULL(HiiOutput); SHELL_FREE_NON_NULL(HiiResultOk); SHELL_FREE_NON_NULL(FullCwd); return (SHELL_OUT_OF_RESOURCES); } // // Go through the list of files and directories to move... // for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link) ; !IsNull(&FileList->Link, &Node->Link) ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link) ){ if (ShellGetExecutionBreakFlag()) { break; } // // These should never be NULL // ASSERT(Node->FileName != NULL); ASSERT(Node->FullName != NULL); ASSERT(Node->Info != NULL); // // skip the directory traversing stuff... // if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) { continue; } SHELL_FREE_NON_NULL(FullDestPath); FullDestPath = NULL; if (ShellIsDirectory(DestPath)==EFI_SUCCESS) { CreateFullDestPath((CONST CHAR16 **)&DestPath, &FullDestPath, Node->FileName); } // // Validate that the move is valid // if (!IsValidMove(Node->FullName, FullCwd, FullDestPath!=NULL? FullDestPath:DestPath, Node->Info->Attribute, Attr, Node->Status)) { ShellStatus = SHELL_INVALID_PARAMETER; continue; } ShellPrintEx(-1, -1, HiiOutput, Node->FullName, FullDestPath!=NULL? FullDestPath:DestPath); // // See if destination exists // if (!EFI_ERROR(ShellFileExists(FullDestPath!=NULL? FullDestPath:DestPath))) { if (Response == NULL) { ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response); } switch (*(SHELL_PROMPT_RESPONSE*)Response) { case ShellPromptResponseNo: FreePool(Response); Response = NULL; continue; case ShellPromptResponseCancel: *Resp = Response; // // indicate to stop everything // SHELL_FREE_NON_NULL(FullCwd); return (SHELL_ABORTED); case ShellPromptResponseAll: *Resp = Response; break; case ShellPromptResponseYes: FreePool(Response); Response = NULL; break; default: FreePool(Response); SHELL_FREE_NON_NULL(FullCwd); return SHELL_ABORTED; } Status = ShellDeleteFileByName(FullDestPath!=NULL? FullDestPath:DestPath); } if (IsBetweenFileSystem(Node->FullName, FullCwd, DestPath)) { while (FullDestPath == NULL && DestPath != NULL && DestPath[0] != CHAR_NULL && DestPath[StrLen(DestPath) - 1] == L'\\') { DestPath[StrLen(DestPath) - 1] = CHAR_NULL; } Status = MoveBetweenFileSystems(Node, FullDestPath!=NULL? FullDestPath:DestPath, &Response); } else { Status = MoveWithinFileSystems(Node, DestPath, &Response); // // Display error status // if (EFI_ERROR(Status)) { ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"mv", Status); } } // // Check our result // if (EFI_ERROR(Status)) { ShellStatus = SHELL_INVALID_PARAMETER; if (Status == EFI_SECURITY_VIOLATION) { ShellStatus = SHELL_SECURITY_VIOLATION; } else if (Status == EFI_WRITE_PROTECTED) { ShellStatus = SHELL_WRITE_PROTECTED; } else if (Status == EFI_OUT_OF_RESOURCES) { ShellStatus = SHELL_OUT_OF_RESOURCES; } else if (Status == EFI_DEVICE_ERROR) { ShellStatus = SHELL_DEVICE_ERROR; } else if (Status == EFI_ACCESS_DENIED) { ShellStatus = SHELL_ACCESS_DENIED; } } else { ShellPrintEx(-1, -1, L"%s", HiiResultOk); } } // main for loop SHELL_FREE_NON_NULL(FullDestPath); SHELL_FREE_NON_NULL(DestPath); SHELL_FREE_NON_NULL(HiiOutput); SHELL_FREE_NON_NULL(HiiResultOk); SHELL_FREE_NON_NULL(FullCwd); return (ShellStatus); }
/** 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; }
/** Gather and print PEIM data. Only prints complete PEIM records **/ VOID ProcessPeims( VOID ) { MEASUREMENT_RECORD Measurement; UINT64 Duration; UINT64 ElapsedTime; EFI_STRING StringPtr; UINTN LogEntryKey; UINTN TIndex; EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PEIMS), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown : StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_PEIM_SECTION2)); } else { PrintToken (STRING_TOKEN (STR_DP_PEIM_SECTION)); } PrintToken (STRING_TOKEN (STR_DP_DASHES)); TIndex = 0; LogEntryKey = 0; while ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) { TIndex++; if ((Measurement.EndTimeStamp == 0) || (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) != 0) ) { continue; } Duration = GetDuration (&Measurement); ElapsedTime = DurationInMicroSeconds ( Duration ); // Calculate elapsed time in microseconds if (ElapsedTime >= mInterestThreshold) { // PEIM FILE Handle is the start address of its FFS file that contains its file guid. if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_PEIM_VARS2), TIndex, // 1 based, Which measurement record is being printed Measurement.Handle, // base address Measurement.Handle, // file guid ElapsedTime, Measurement.Identifier ); } else { PrintToken (STRING_TOKEN (STR_DP_PEIM_VARS), TIndex, // 1 based, Which measurement record is being printed Measurement.Handle, // base address Measurement.Handle, // file guid ElapsedTime ); } } } }
/** Gather and print global data. Strips out incomplete or "Execution Phase" records Only prints records where Handle is NULL Increment TIndex for every record, even skipped ones, so that we have an indication of every measurement record taken. **/ VOID ProcessGlobal( VOID ) { MEASUREMENT_RECORD Measurement; UINT64 Duration; UINT64 ElapsedTime; EFI_STRING StringPtr; UINTN LogEntryKey; UINTN Index; // Index, or number, of the measurement record being processed EFI_STRING StringPtrUnknown; StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_GENERAL), NULL); PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), (StringPtr == NULL) ? StringPtrUnknown: StringPtr); FreePool (StringPtr); FreePool (StringPtrUnknown); if (mShowId) { PrintToken (STRING_TOKEN (STR_DP_GLOBAL_SECTION2)); } else { PrintToken (STRING_TOKEN (STR_DP_GLOBAL_SECTION)); } PrintToken (STRING_TOKEN (STR_DP_DASHES)); Index = 1; LogEntryKey = 0; while ((LogEntryKey = GetPerformanceMeasurementEx ( LogEntryKey, &Measurement.Handle, &Measurement.Token, &Measurement.Module, &Measurement.StartTimeStamp, &Measurement.EndTimeStamp, &Measurement.Identifier)) != 0) { AsciiStrToUnicodeStr (Measurement.Module, mGaugeString); AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken); mGaugeString[25] = 0; mUnicodeToken[31] = 0; if ( ! ( IsPhase( &Measurement) || (Measurement.Handle != NULL) || (Measurement.EndTimeStamp == 0) )) { Duration = GetDuration (&Measurement); ElapsedTime = DurationInMicroSeconds ( Duration ); if (ElapsedTime >= mInterestThreshold) { if (mShowId) { PrintToken ( STRING_TOKEN (STR_DP_GLOBAL_VARS2), Index, mGaugeString, mUnicodeToken, ElapsedTime, Measurement.Identifier ); } else { PrintToken ( STRING_TOKEN (STR_DP_GLOBAL_VARS), Index, mGaugeString, mUnicodeToken, ElapsedTime ); } } } Index++; } }
/** This function processes the results of changes in configuration. When user select a interactive opcode, this callback will be triggered. Based on the Question(QuestionId) that triggers the callback, the corresponding actions is performed. It handles: 1) Process the axtra action or exit file explorer when user select one file . 2) update of file content if a dir is selected. @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. @param Action Specifies the type of action taken by the browser. @param QuestionId A unique value which is sent to the original exporting driver so that it can identify the type of data to expect. @param Type The type of value for the question. @param Value A pointer to the data being sent to the original exporting driver. @param ActionRequest On return, points to the action requested by the callback function. @retval EFI_SUCCESS The callback successfully handled the action. @retval other error Error occur when parse one directory. **/ EFI_STATUS EFIAPI LibCallback ( IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, IN EFI_BROWSER_ACTION Action, IN EFI_QUESTION_ID QuestionId, IN UINT8 Type, IN EFI_IFR_TYPE_VALUE *Value, OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest ) { EFI_STATUS Status; BOOLEAN NeedExit; CHAR16 *NewFileName; CHAR16 *NewFolderName; NeedExit = TRUE; NewFileName = NULL; NewFolderName = NULL; if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) { // // Do nothing for other UEFI Action. Only do call back when data is changed. // return EFI_UNSUPPORTED; } if (Action == EFI_BROWSER_ACTION_CHANGED) { if ((Value == NULL) || (ActionRequest == NULL)) { return EFI_INVALID_PARAMETER; } if (QuestionId == KEY_VALUE_CREATE_FILE_AND_EXIT) { *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT; if (!IsZeroBuffer (mNewFileName, sizeof (mNewFileName))) { Status = LibCreateNewFile (mNewFileName,TRUE); ZeroMem (mNewFileName,sizeof (mNewFileName)); } } if (QuestionId == KEY_VALUE_NO_CREATE_FILE_AND_EXIT) { ZeroMem (mNewFileName,sizeof (mNewFileName)); *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT; } if (QuestionId == KEY_VALUE_CREATE_FOLDER_AND_EXIT) { *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT; if (!IsZeroBuffer (mNewFolderName, sizeof (mNewFolderName))) { Status = LibCreateNewFile (mNewFolderName, FALSE); ZeroMem (mNewFolderName,sizeof (mNewFolderName)); } } if (QuestionId == KEY_VALUE_NO_CREATE_FOLDER_AND_EXIT) { ZeroMem (mNewFolderName,sizeof (mNewFolderName)); *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT; } if (QuestionId == NEW_FILE_NAME_ID) { NewFileName = HiiGetString (gFileExplorerPrivate.FeHiiHandle, Value->string, NULL); if (NewFileName != NULL) { StrCpyS (mNewFileName, MAX_FILE_NAME_LEN, NewFileName); FreePool (NewFileName); NewFileName = NULL; } else { return EFI_INVALID_PARAMETER; } } if (QuestionId == NEW_FOLDER_NAME_ID) { NewFolderName = HiiGetString (gFileExplorerPrivate.FeHiiHandle, Value->string, NULL); if (NewFolderName != NULL) { StrCpyS (mNewFolderName, MAX_FOLDER_NAME_LEN, NewFolderName); FreePool (NewFolderName); NewFolderName = NULL; } else { return EFI_INVALID_PARAMETER; } } if (QuestionId >= FILE_OPTION_OFFSET) { LibGetDevicePath(QuestionId); // // Process the extra action. // if (gFileExplorerPrivate.ChooseHandler != NULL) { NeedExit = gFileExplorerPrivate.ChooseHandler (gFileExplorerPrivate.RetDevicePath); } if (NeedExit) { *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT; } } } else if (Action == EFI_BROWSER_ACTION_CHANGING) { if (Value == NULL) { return EFI_INVALID_PARAMETER; } if (QuestionId >= FILE_OPTION_OFFSET) { LibGetDevicePath(QuestionId); Status = LibUpdateFileExplorer (QuestionId); if (EFI_ERROR (Status)) { return Status; } } } return EFI_SUCCESS; }
/** 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); }
/** Build the EFI_IFR_DATA_ARRAY which will be used to pass to EFI_FORM_CALLBACK_PROTOCOL.Callback. Check definition of EFI_IFR_DATA_ARRAY for details. ASSERT if the Question Type is not EFI_IFR_TYPE_NUM_SIZE_* or EFI_IFR_TYPE_STRING. @param ConfigAccess Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL @param QuestionId The Question ID. @param Type The Question Type. @param Value The Question Value. @param NvMapAllocated On output indicates if a buffer is allocated for NvMap. @return A pointer to EFI_IFR_DATA_ARRAY. The caller must free this buffer allocated. **/ EFI_IFR_DATA_ARRAY * CreateIfrDataArray ( IN CONFIG_ACCESS_PRIVATE *ConfigAccess, IN EFI_QUESTION_ID QuestionId, IN UINT8 Type, IN EFI_IFR_TYPE_VALUE *Value, OUT BOOLEAN *NvMapAllocated ) { EFI_IFR_DATA_ARRAY *IfrDataArray; EFI_IFR_DATA_ENTRY *IfrDataEntry; UINTN BrowserDataSize; FORMSET_STORAGE *BufferStorage; UINTN Size; EFI_STRING String; FORM_BROWSER_STATEMENT *Statement; *NvMapAllocated = FALSE; String = NULL; switch (Type) { case EFI_IFR_TYPE_NUM_SIZE_8: case EFI_IFR_TYPE_NUM_SIZE_16: case EFI_IFR_TYPE_NUM_SIZE_32: case EFI_IFR_TYPE_NUM_SIZE_64: case EFI_IFR_TYPE_BOOLEAN: Size = sizeof (*Value); break; case EFI_IFR_TYPE_STRING: if (Value->string == 0) { Size = 0; } else { String = HiiGetString (ConfigAccess->ThunkContext->UefiHiiHandle, Value->string, NULL); ASSERT (String != NULL); Size = StrSize (String); } break; case EFI_IFR_TYPE_ACTION: case EFI_IFR_TYPE_UNDEFINED: Size = 0; break; default: ASSERT (FALSE); Size = 0; break; } IfrDataArray = AllocateZeroPool (sizeof (EFI_IFR_DATA_ARRAY) + sizeof (EFI_IFR_DATA_ENTRY) + Size); ASSERT (IfrDataArray != NULL); IfrDataArray->EntryCount = 1; IfrDataEntry = (EFI_IFR_DATA_ENTRY *) (IfrDataArray + 1); Statement = GetStorageFromQuestionId (ConfigAccess->ThunkContext->FormSet, QuestionId); if (Statement == NULL || Statement->Storage == NULL) { // // The QuestionId is not associated with a Buffer Storage. // Try to get the first Buffer Storage then. // BufferStorage = GetFirstStorageOfFormSet (ConfigAccess->ThunkContext->FormSet); } else { BufferStorage = Statement->Storage; IfrDataEntry->OpCode = Statement->Operand; } if (BufferStorage != NULL) { BrowserDataSize = BufferStorage->Size; IfrDataEntry->Length = (UINT8) (sizeof (EFI_IFR_DATA_ENTRY) + Size); if (ConfigAccess->ThunkContext->NvMapOverride == NULL) { *NvMapAllocated = TRUE; IfrDataArray->NvRamMap = AllocateZeroPool (BrowserDataSize); } else { *NvMapAllocated = FALSE; IfrDataArray->NvRamMap = ConfigAccess->ThunkContext->NvMapOverride; } ASSERT (HiiGetBrowserData (&BufferStorage->Guid, BufferStorage->Name, BrowserDataSize, (UINT8 *) IfrDataArray->NvRamMap)); switch (Type) { case EFI_IFR_TYPE_NUM_SIZE_8: case EFI_IFR_TYPE_NUM_SIZE_16: case EFI_IFR_TYPE_NUM_SIZE_32: case EFI_IFR_TYPE_NUM_SIZE_64: case EFI_IFR_TYPE_BOOLEAN: CopyMem (&IfrDataEntry->Data, &(Value->u8), sizeof (*Value)); break; case EFI_IFR_TYPE_STRING: if (Size != 0) { ASSERT (String != NULL); StrCpy ((CHAR16 *) &IfrDataEntry->Data, String); FreePool (String); } break; case EFI_IFR_TYPE_ACTION: case EFI_IFR_TYPE_UNDEFINED: break; default: ASSERT (FALSE); break; } // // Need to fiil in the information for the rest of field for EFI_IFR_DATA_ENTRY. // It seems that no implementation is found to use other fields. Leave them uninitialized for now. // //UINT8 OpCode; // Likely a string, numeric, or one-of //UINT8 Length; // Length of the EFI_IFR_DATA_ENTRY packet //UINT16 Flags; // Flags settings to determine what behavior is desired from the browser after the callback //VOID *Data; // The data in the form based on the op-code type - this is not a pointer to the data, the data follows immediately // If the OpCode is a OneOf or Numeric type - Data is a UINT16 value // If the OpCode is a String type - Data is a CHAR16[x] type // If the OpCode is a Checkbox type - Data is a UINT8 value // If the OpCode is a NV Access type - Data is a FRAMEWORK_EFI_IFR_NV_DATA structure } return IfrDataArray; }
/** This call back function is registered with Boot Manager formset. When user selects a boot option, this call back function will be triggered. The boot option is saved for later processing. @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. @param Action Specifies the type of action taken by the browser. @param QuestionId A unique value which is sent to the original exporting driver so that it can identify the type of data to expect. @param Type The type of value for the question. @param Value A pointer to the data being sent to the original exporting driver. @param ActionRequest On return, points to the action requested by the callback function. @retval EFI_SUCCESS The callback successfully handled the action. @retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters. **/ EFI_STATUS EFIAPI BootManagerCallback ( IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, IN EFI_BROWSER_ACTION Action, IN EFI_QUESTION_ID QuestionId, IN UINT8 Type, IN EFI_IFR_TYPE_VALUE *Value, OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest ) { EFI_BOOT_MANAGER_LOAD_OPTION *BootOption; UINTN BootOptionCount; EFI_INPUT_KEY Key; if (Action == EFI_BROWSER_ACTION_FORM_OPEN) { // //Means enter the boot manager form. //Update the boot manage page,because the boot option may changed. // if (QuestionId == 0x1212){ UpdateBootManager(); } return EFI_SUCCESS; } if (Action != EFI_BROWSER_ACTION_CHANGED) { // // Do nothing for other UEFI Action. Only do call back when data is changed. // return EFI_UNSUPPORTED; } if ((Value == NULL) || (ActionRequest == NULL)) { return EFI_INVALID_PARAMETER; } BootOption = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot); // // Clear the screen before. // gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK)); gST->ConOut->ClearScreen (gST->ConOut); // //check any reset required change is applied? if yes, reset system // BmSetupResetReminder (); // // parse the selected option // BmSetConsoleMode (FALSE); EfiBootManagerBoot (&BootOption[QuestionId - 1]); BmSetConsoleMode (TRUE); if (EFI_ERROR (BootOption[QuestionId - 1].Status)) { gST->ConOut->OutputString ( gST->ConOut, HiiGetString (gBootManagerPrivate.HiiHandle, STRING_TOKEN (STR_ANY_KEY_CONTINUE), NULL) ); gST->ConIn->ReadKeyStroke (gST->ConIn, &Key); } EfiBootManagerFreeLoadOptions (BootOption, BootOptionCount); return EFI_SUCCESS; }