1 /** @file 2 Utility functions used by the Dp application. 3 4 Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved. 5 (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR> 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions of the BSD License 8 which accompanies this distribution. The full text of the license may be found at 9 http://opensource.org/licenses/bsd-license.php 10 11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 **/ 14 15 #include <Library/BaseLib.h> 16 #include <Library/BaseMemoryLib.h> 17 #include <Library/MemoryAllocationLib.h> 18 #include <Library/DebugLib.h> 19 #include <Library/UefiBootServicesTableLib.h> 20 #include <Library/TimerLib.h> 21 #include <Library/PeCoffGetEntryPointLib.h> 22 #include <Library/PrintLib.h> 23 #include <Library/HiiLib.h> 24 #include <Library/PcdLib.h> 25 #include <Library/UefiLib.h> 26 #include <Library/DevicePathLib.h> 27 #include <Library/HandleParsingLib.h> 28 29 #include <Pi/PiFirmwareFile.h> 30 #include <Library/DxeServicesLib.h> 31 32 #include <Protocol/LoadedImage.h> 33 #include <Protocol/DriverBinding.h> 34 #include <Protocol/ComponentName2.h> 35 #include <Protocol/DevicePath.h> 36 37 #include <Guid/Performance.h> 38 39 #include "Dp.h" 40 #include "Literals.h" 41 #include "DpInternal.h" 42 43 /** 44 Calculate an event's duration in timer ticks. 45 46 Given the count direction and the event's start and end timer values, 47 calculate the duration of the event in timer ticks. Information for 48 the current measurement is pointed to by the parameter. 49 50 If the measurement's start time is 1, it indicates that the developer 51 is indicating that the measurement began at the release of reset. 52 The start time is adjusted to the timer's starting count before performing 53 the elapsed time calculation. 54 55 The calculated duration, in ticks, is the absolute difference between 56 the measurement's ending and starting counts. 57 58 @param Measurement Pointer to a MEASUREMENT_RECORD structure containing 59 data for the current measurement. 60 61 @return The 64-bit duration of the event. 62 **/ 63 UINT64 64 GetDuration ( 65 IN OUT MEASUREMENT_RECORD *Measurement 66 ) 67 { 68 UINT64 Duration; 69 BOOLEAN Error; 70 71 // PERF_START macros are called with a value of 1 to indicate 72 // the beginning of time. So, adjust the start ticker value 73 // to the real beginning of time. 74 // Assumes no wraparound. Even then, there is a very low probability 75 // of having a valid StartTicker value of 1. 76 if (Measurement->StartTimeStamp == 1) { 77 Measurement->StartTimeStamp = TimerInfo.StartCount; 78 } 79 if (TimerInfo.CountUp) { 80 Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp; 81 Error = (BOOLEAN)(Duration > Measurement->EndTimeStamp); 82 } 83 else { 84 Duration = Measurement->StartTimeStamp - Measurement->EndTimeStamp; 85 Error = (BOOLEAN)(Duration > Measurement->StartTimeStamp); 86 } 87 88 if (Error) { 89 DEBUG ((EFI_D_ERROR, ALit_TimerLibError)); 90 Duration = 0; 91 } 92 return Duration; 93 } 94 95 /** 96 Determine whether the Measurement record is for an EFI Phase. 97 98 The Token and Module members of the measurement record are checked. 99 Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL. 100 101 @param[in] Measurement A pointer to the Measurement record to test. 102 103 @retval TRUE The measurement record is for an EFI Phase. 104 @retval FALSE The measurement record is NOT for an EFI Phase. 105 **/ 106 BOOLEAN 107 IsPhase( 108 IN MEASUREMENT_RECORD *Measurement 109 ) 110 { 111 BOOLEAN RetVal; 112 113 RetVal = (BOOLEAN)( ( *Measurement->Module == '\0') && 114 ((AsciiStrnCmp (Measurement->Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) || 115 (AsciiStrnCmp (Measurement->Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) || 116 (AsciiStrnCmp (Measurement->Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) || 117 (AsciiStrnCmp (Measurement->Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0)) 118 ); 119 return RetVal; 120 } 121 122 /** 123 Get the file name portion of the Pdb File Name. 124 125 The portion of the Pdb File Name between the last backslash and 126 either a following period or the end of the string is converted 127 to Unicode and copied into UnicodeBuffer. The name is truncated, 128 if necessary, to ensure that UnicodeBuffer is not overrun. 129 130 @param[in] PdbFileName Pdb file name. 131 @param[out] UnicodeBuffer The resultant Unicode File Name. 132 133 **/ 134 VOID 135 DpGetShortPdbFileName ( 136 IN CHAR8 *PdbFileName, 137 OUT CHAR16 *UnicodeBuffer 138 ) 139 { 140 UINTN IndexA; // Current work location within an ASCII string. 141 UINTN IndexU; // Current work location within a Unicode string. 142 UINTN StartIndex; 143 UINTN EndIndex; 144 145 ZeroMem (UnicodeBuffer, (DP_GAUGE_STRING_LENGTH + 1) * sizeof (CHAR16)); 146 147 if (PdbFileName == NULL) { 148 StrnCpyS (UnicodeBuffer, DP_GAUGE_STRING_LENGTH + 1, L" ", 1); 149 } else { 150 StartIndex = 0; 151 for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++) 152 ; 153 for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) { 154 if (PdbFileName[IndexA] == '\\') { 155 StartIndex = IndexA + 1; 156 } 157 158 if (PdbFileName[IndexA] == '.') { 159 EndIndex = IndexA; 160 } 161 } 162 163 IndexU = 0; 164 for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) { 165 UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA]; 166 IndexU++; 167 if (IndexU >= DP_GAUGE_STRING_LENGTH) { 168 UnicodeBuffer[DP_GAUGE_STRING_LENGTH] = 0; 169 break; 170 } 171 } 172 } 173 } 174 175 /** 176 Get a human readable name for an image handle. 177 The following methods will be tried orderly: 178 1. Image PDB 179 2. ComponentName2 protocol 180 3. FFS UI section 181 4. Image GUID 182 5. Image DevicePath 183 6. Unknown Driver Name 184 185 @param[in] Handle 186 187 @post The resulting Unicode name string is stored in the 188 mGaugeString global array. 189 190 **/ 191 VOID 192 DpGetNameFromHandle ( 193 IN EFI_HANDLE Handle 194 ) 195 { 196 EFI_STATUS Status; 197 EFI_LOADED_IMAGE_PROTOCOL *Image; 198 CHAR8 *PdbFileName; 199 EFI_DRIVER_BINDING_PROTOCOL *DriverBinding; 200 EFI_STRING StringPtr; 201 EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath; 202 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 203 EFI_GUID *NameGuid; 204 CHAR16 *NameString; 205 UINTN StringSize; 206 CHAR8 *PlatformLanguage; 207 EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2; 208 209 // 210 // Method 1: Get the name string from image PDB 211 // 212 Status = gBS->HandleProtocol ( 213 Handle, 214 &gEfiLoadedImageProtocolGuid, 215 (VOID **) &Image 216 ); 217 218 if (EFI_ERROR (Status)) { 219 Status = gBS->OpenProtocol ( 220 Handle, 221 &gEfiDriverBindingProtocolGuid, 222 (VOID **) &DriverBinding, 223 NULL, 224 NULL, 225 EFI_OPEN_PROTOCOL_GET_PROTOCOL 226 ); 227 if (!EFI_ERROR (Status)) { 228 Status = gBS->HandleProtocol ( 229 DriverBinding->ImageHandle, 230 &gEfiLoadedImageProtocolGuid, 231 (VOID **) &Image 232 ); 233 } 234 } 235 236 if (!EFI_ERROR (Status)) { 237 PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase); 238 239 if (PdbFileName != NULL) { 240 DpGetShortPdbFileName (PdbFileName, mGaugeString); 241 return; 242 } 243 } 244 245 // 246 // Method 2: Get the name string from ComponentName2 protocol 247 // 248 Status = gBS->HandleProtocol ( 249 Handle, 250 &gEfiComponentName2ProtocolGuid, 251 (VOID **) &ComponentName2 252 ); 253 if (!EFI_ERROR (Status)) { 254 // 255 // Get the current platform language setting 256 // 257 PlatformLanguage = GetBestLanguageForDriver(ComponentName2->SupportedLanguages, NULL, FALSE); 258 Status = ComponentName2->GetDriverName ( 259 ComponentName2, 260 PlatformLanguage != NULL ? PlatformLanguage : "en-US", 261 &StringPtr 262 ); 263 if (!EFI_ERROR (Status)) { 264 SHELL_FREE_NON_NULL (PlatformLanguage); 265 StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH); 266 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; 267 return; 268 } 269 } 270 271 Status = gBS->HandleProtocol ( 272 Handle, 273 &gEfiLoadedImageDevicePathProtocolGuid, 274 (VOID **) &LoadedImageDevicePath 275 ); 276 if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) { 277 DevicePath = LoadedImageDevicePath; 278 279 // 280 // Try to get image GUID from LoadedImageDevicePath protocol 281 // 282 NameGuid = NULL; 283 while (!IsDevicePathEndType (DevicePath)) { 284 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath); 285 if (NameGuid != NULL) { 286 break; 287 } 288 DevicePath = NextDevicePathNode (DevicePath); 289 } 290 291 if (NameGuid != NULL) { 292 // 293 // Try to get the image's FFS UI section by image GUID 294 // 295 NameString = NULL; 296 StringSize = 0; 297 Status = GetSectionFromAnyFv ( 298 NameGuid, 299 EFI_SECTION_USER_INTERFACE, 300 0, 301 (VOID **) &NameString, 302 &StringSize 303 ); 304 305 if (!EFI_ERROR (Status)) { 306 // 307 // Method 3. Get the name string from FFS UI section 308 // 309 StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH); 310 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; 311 FreePool (NameString); 312 } else { 313 // 314 // Method 4: Get the name string from image GUID 315 // 316 UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid); 317 } 318 return; 319 } else { 320 // 321 // Method 5: Get the name string from image DevicePath 322 // 323 NameString = ConvertDevicePathToText (LoadedImageDevicePath, TRUE, FALSE); 324 if (NameString != NULL) { 325 StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH); 326 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; 327 FreePool (NameString); 328 return; 329 } 330 } 331 } 332 333 // 334 // Method 6: Unknown Driver Name 335 // 336 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL); 337 ASSERT (StringPtr != NULL); 338 StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH); 339 FreePool (StringPtr); 340 } 341 342 /** 343 Calculate the Duration in microseconds. 344 345 Duration is multiplied by 1000, instead of Frequency being divided by 1000 or 346 multiplying the result by 1000, in order to maintain precision. Since Duration is 347 a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow. 348 349 The time is calculated as (Duration * 1000) / Timer_Frequency. 350 351 @param[in] Duration The event duration in timer ticks. 352 353 @return A 64-bit value which is the Elapsed time in microseconds. 354 **/ 355 UINT64 356 DurationInMicroSeconds ( 357 IN UINT64 Duration 358 ) 359 { 360 UINT64 Temp; 361 362 Temp = MultU64x32 (Duration, 1000); 363 return DivU64x32 (Temp, TimerInfo.Frequency); 364 } 365 366 /** 367 Get index of Measurement Record's match in the CumData array. 368 369 If the Measurement's Token value matches a Token in one of the CumData 370 records, the index of the matching record is returned. The returned 371 index is a signed value so that negative values can indicate that 372 the Measurement didn't match any entry in the CumData array. 373 374 @param[in] Measurement A pointer to a Measurement Record to match against the CumData array. 375 376 @retval <0 Token is not in the CumData array. 377 @retval >=0 Return value is the index into CumData where Token is found. 378 **/ 379 INTN 380 GetCumulativeItem( 381 IN MEASUREMENT_RECORD *Measurement 382 ) 383 { 384 INTN Index; 385 386 for( Index = 0; Index < (INTN)NumCum; ++Index) { 387 if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) { 388 return Index; // Exit, we found a match 389 } 390 } 391 // If the for loop exits, Token was not found. 392 return -1; // Indicate failure 393 } 394