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
GetDuration(IN OUT MEASUREMENT_RECORD * Measurement)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
IsPhase(IN MEASUREMENT_RECORD * Measurement)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
DpGetShortPdbFileName(IN CHAR8 * PdbFileName,OUT CHAR16 * UnicodeBuffer)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
DpGetNameFromHandle(IN EFI_HANDLE Handle)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
DurationInMicroSeconds(IN UINT64 Duration)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
GetCumulativeItem(IN MEASUREMENT_RECORD * Measurement)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