/** @file | |
* Utility functions used by the Dp application. | |
* | |
* Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR> | |
* This program and the accompanying materials | |
* are licensed and made available under the terms and conditions of the BSD License | |
* which accompanies this distribution. The full text of the license may be found at | |
* http://opensource.org/licenses/bsd-license.php | |
* | |
* THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
**/ | |
#include <Library/BaseLib.h> | |
#include <Library/BaseMemoryLib.h> | |
#include <Library/MemoryAllocationLib.h> | |
#include <Library/DebugLib.h> | |
#include <Library/UefiBootServicesTableLib.h> | |
#include <Library/TimerLib.h> | |
#include <Library/PeCoffGetEntryPointLib.h> | |
#include <Library/PrintLib.h> | |
#include <Library/HiiLib.h> | |
#include <Library/PcdLib.h> | |
#include <Protocol/LoadedImage.h> | |
#include <Protocol/DriverBinding.h> | |
#include <Guid/Performance.h> | |
#include "Dp.h" | |
#include "Literals.h" | |
#include "DpInternal.h" | |
/** Calculate an event's duration in timer ticks. | |
* | |
* Given the count direction and the event's start and end timer values, | |
* calculate the duration of the event in timer ticks. Information for | |
* the current measurement is pointed to by the parameter. | |
* | |
* If the measurement's start time is 1, it indicates that the developer | |
* is indicating that the measurement began at the release of reset. | |
* The start time is adjusted to the timer's starting count before performing | |
* the elapsed time calculation. | |
* | |
* The calculated duration, in ticks, is the absolute difference between | |
* the measurement's ending and starting counts. | |
* | |
* @pre The global TimerInfo structure must have already been initialized | |
* before this function is called. | |
* | |
* @param[in,out] Measurement Pointer to a MEASUREMENT_RECORD structure containing | |
* data for the current measurement. | |
* | |
* @return The 64-bit duration of the event. | |
**/ | |
UINT64 | |
GetDuration ( | |
IN OUT MEASUREMENT_RECORD *Measurement | |
) | |
{ | |
UINT64 Duration; | |
BOOLEAN Error; | |
// PERF_START macros are called with a value of 1 to indicate | |
// the beginning of time. So, adjust the start ticker value | |
// to the real beginning of time. | |
// Assumes no wraparound. Even then, there is a very low probability | |
// of having a valid StartTicker value of 1. | |
if (Measurement->StartTimeStamp == 1) { | |
Measurement->StartTimeStamp = TimerInfo.StartCount; | |
} | |
if (TimerInfo.CountUp) { | |
Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp; | |
Error = (BOOLEAN)(Duration > Measurement->EndTimeStamp); | |
} | |
else { | |
Duration = Measurement->StartTimeStamp - Measurement->EndTimeStamp; | |
Error = (BOOLEAN)(Duration > Measurement->StartTimeStamp); | |
} | |
if (Error) { | |
DEBUG ((EFI_D_ERROR, ALit_TimerLibError)); | |
Duration = 0; | |
} | |
return Duration; | |
} | |
/** Determine whether the Measurement record is for an EFI Phase. | |
* | |
* The Token and Module members of the measurement record are checked. | |
* Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL. | |
* | |
* @param[in] Measurement A pointer to the Measurement record to test. | |
* | |
* @retval TRUE The measurement record is for an EFI Phase. | |
* @retval FALSE The measurement record is NOT for an EFI Phase. | |
**/ | |
BOOLEAN | |
IsPhase( | |
IN MEASUREMENT_RECORD *Measurement | |
) | |
{ | |
BOOLEAN RetVal; | |
RetVal = (BOOLEAN)( ( *Measurement->Module == '\0') && | |
((AsciiStrnCmp (Measurement->Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) || | |
(AsciiStrnCmp (Measurement->Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) || | |
(AsciiStrnCmp (Measurement->Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) || | |
(AsciiStrnCmp (Measurement->Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0)) | |
); | |
return RetVal; | |
} | |
/** Get the file name portion of the Pdb File Name. | |
* | |
* The portion of the Pdb File Name between the last backslash and | |
* either a following period or the end of the string is converted | |
* to Unicode and copied into UnicodeBuffer. The name is truncated, | |
* if necessary, to ensure that UnicodeBuffer is not overrun. | |
* | |
* @param[in] PdbFileName Pdb file name. | |
* @param[out] UnicodeBuffer The resultant Unicode File Name. | |
* | |
**/ | |
VOID | |
GetShortPdbFileName ( | |
IN CHAR8 *PdbFileName, | |
OUT CHAR16 *UnicodeBuffer | |
) | |
{ | |
UINTN IndexA; // Current work location within an ASCII string. | |
UINTN IndexU; // Current work location within a Unicode string. | |
UINTN StartIndex; | |
UINTN EndIndex; | |
ZeroMem (UnicodeBuffer, DXE_PERFORMANCE_STRING_LENGTH * sizeof (CHAR16)); | |
if (PdbFileName == NULL) { | |
StrCpy (UnicodeBuffer, L" "); | |
} else { | |
StartIndex = 0; | |
for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++) | |
; | |
for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) { | |
if (PdbFileName[IndexA] == '\\') { | |
StartIndex = IndexA + 1; | |
} | |
if (PdbFileName[IndexA] == '.') { | |
EndIndex = IndexA; | |
} | |
} | |
IndexU = 0; | |
for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) { | |
UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA]; | |
IndexU++; | |
if (IndexU >= DXE_PERFORMANCE_STRING_LENGTH) { | |
UnicodeBuffer[DXE_PERFORMANCE_STRING_LENGTH] = 0; | |
break; | |
} | |
} | |
} | |
} | |
/** Get a human readable name for an image handle. | |
* | |
* @param[in] Handle | |
* | |
* @post The resulting Unicode name string is stored in the | |
* mGaugeString global array. | |
* | |
**/ | |
VOID | |
GetNameFromHandle ( | |
IN EFI_HANDLE Handle | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_LOADED_IMAGE_PROTOCOL *Image; | |
CHAR8 *PdbFileName; | |
EFI_DRIVER_BINDING_PROTOCOL *DriverBinding; | |
EFI_STRING StringPtr; | |
// Proactively get the error message so it will be ready if needed | |
StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL); | |
ASSERT (StringPtr != NULL); | |
// Get handle name from image protocol | |
// | |
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)) { | |
StrCpy (mGaugeString, StringPtr); | |
return ; | |
} | |
// Get handle name from image protocol | |
// | |
Status = gBS->HandleProtocol ( | |
DriverBinding->ImageHandle, | |
&gEfiLoadedImageProtocolGuid, | |
(VOID**) &Image | |
); | |
} | |
PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase); | |
if (PdbFileName != NULL) { | |
GetShortPdbFileName (PdbFileName, mGaugeString); | |
} else { | |
StrCpy (mGaugeString, StringPtr); | |
} | |
return ; | |
} | |
/** Calculate the Duration in microseconds. | |
* | |
* Duration is multiplied by 1000, instead of Frequency being divided by 1000 or | |
* multiplying the result by 1000, in order to maintain precision. Since Duration is | |
* a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow. | |
* | |
* The time is calculated as (Duration * 1000) / Timer_Frequency. | |
* | |
* @param[in] Duration The event duration in timer ticks. | |
* | |
* @return A 64-bit value which is the Elapsed time in microseconds. | |
**/ | |
UINT64 | |
DurationInMicroSeconds ( | |
IN UINT64 Duration | |
) | |
{ | |
UINT64 Temp; | |
Temp = MultU64x32 (Duration, 1000); | |
return DivU64x32 (Temp, TimerInfo.Frequency); | |
} | |
/** Formatted Print using a Hii Token to reference the localized format string. | |
* | |
* @param[in] Token A HII token associated with a localized Unicode string. | |
* | |
* @return The number of characters converted by UnicodeVSPrint(). | |
* | |
**/ | |
UINTN | |
PrintToken ( | |
IN UINT16 Token, | |
... | |
) | |
{ | |
VA_LIST Marker; | |
EFI_STRING StringPtr; | |
UINTN Return; | |
UINTN BufferSize; | |
StringPtr = HiiGetString (gHiiHandle, Token, NULL); | |
ASSERT (StringPtr != NULL); | |
VA_START (Marker, Token); | |
BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16); | |
if (mPrintTokenBuffer == NULL) { | |
mPrintTokenBuffer = AllocatePool (BufferSize); | |
ASSERT (mPrintTokenBuffer != NULL); | |
} | |
SetMem( mPrintTokenBuffer, BufferSize, 0); | |
Return = UnicodeVSPrint (mPrintTokenBuffer, BufferSize, StringPtr, Marker); | |
if (Return > 0 && gST->ConOut != NULL) { | |
gST->ConOut->OutputString (gST->ConOut, mPrintTokenBuffer); | |
} | |
return Return; | |
} | |
/** Get index of Measurement Record's match in the CumData array. | |
* | |
* If the Measurement's Token value matches a Token in one of the CumData | |
* records, the index of the matching record is returned. The returned | |
* index is a signed value so that negative values can indicate that | |
* the Measurement didn't match any entry in the CumData array. | |
* | |
* @param[in] Measurement A pointer to a Measurement Record to match against the CumData array. | |
* | |
* @retval <0 Token is not in the CumData array. | |
* @retval >=0 Return value is the index into CumData where Token is found. | |
**/ | |
INTN | |
GetCumulativeItem( | |
IN MEASUREMENT_RECORD *Measurement | |
) | |
{ | |
INTN Index; | |
for( Index = 0; Index < (INTN)NumCum; ++Index) { | |
if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) { | |
return Index; // Exit, we found a match | |
} | |
} | |
// If the for loop exits, Token was not found. | |
return -1; // Indicate failure | |
} |