eca2ef309bbc6bb959b1a577ab8f57dd4d1e8d09
[mirror_edk2.git] / ShellPkg / Library / UefiDpLib / DpTrace.c
1 /** @file
2 Trace reporting for the Dp utility.
3
4 Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.
5 (C) Copyright 2015-2016 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/PerformanceLib.h>
23 #include <Library/PrintLib.h>
24 #include <Library/HiiLib.h>
25 #include <Library/PcdLib.h>
26
27 #include <Guid/Performance.h>
28
29 #include "Dp.h"
30 #include "Literals.h"
31 #include "DpInternal.h"
32
33 /**
34 Collect verbose statistics about the logged performance measurements.
35
36 General Summary information for all Trace measurements is gathered and
37 stored within the SummaryData structure. This information is both
38 used internally by subsequent reporting functions, and displayed
39 at the end of verbose reports.
40
41 @pre The SummaryData and CumData structures must be initialized
42 prior to calling this function.
43
44 @post The SummaryData and CumData structures contain statistics for the
45 current performance logs.
46
47 @param[in, out] CustomCumulativeData A pointer to the cumtom cumulative data.
48
49 **/
50 VOID
51 GatherStatistics(
52 IN OUT PERF_CUM_DATA *CustomCumulativeData OPTIONAL
53 )
54 {
55 MEASUREMENT_RECORD Measurement;
56 UINT64 Duration;
57 UINTN LogEntryKey;
58 INTN TIndex;
59
60 LogEntryKey = 0;
61 while ((LogEntryKey = GetPerformanceMeasurementEx (
62 LogEntryKey,
63 &Measurement.Handle,
64 &Measurement.Token,
65 &Measurement.Module,
66 &Measurement.StartTimeStamp,
67 &Measurement.EndTimeStamp,
68 &Measurement.Identifier)) != 0)
69 {
70 ++SummaryData.NumTrace; // Count the number of TRACE Measurement records
71 if (Measurement.EndTimeStamp == 0) {
72 ++SummaryData.NumIncomplete; // Count the incomplete records
73 continue;
74 }
75
76 if (Measurement.Handle != NULL) {
77 ++SummaryData.NumHandles; // Count the number of measurements with non-NULL handles
78 }
79
80 if (IsPhase( &Measurement)) {
81 ++SummaryData.NumSummary; // Count the number of major phases
82 }
83 else { // !IsPhase(...
84 if(Measurement.Handle == NULL) {
85 ++SummaryData.NumGlobal;
86 }
87 }
88
89 if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) {
90 ++SummaryData.NumPEIMs; // Count PEIM measurements
91 }
92
93 Duration = GetDuration (&Measurement);
94 TIndex = GetCumulativeItem (&Measurement);
95 if (TIndex >= 0) {
96 CumData[TIndex].Duration += Duration;
97 CumData[TIndex].Count++;
98 if ( Duration < CumData[TIndex].MinDur ) {
99 CumData[TIndex].MinDur = Duration;
100 }
101 if ( Duration > CumData[TIndex].MaxDur ) {
102 CumData[TIndex].MaxDur = Duration;
103 }
104 }
105
106 //
107 // Collect the data for custom cumulative data.
108 //
109 if ((CustomCumulativeData != NULL) && (AsciiStrCmp (Measurement.Token, CustomCumulativeData->Name) == 0)) {
110 CustomCumulativeData->Duration += Duration;
111 CustomCumulativeData->Count++;
112 if (Duration < CustomCumulativeData->MinDur) {
113 CustomCumulativeData->MinDur = Duration;
114 }
115 if (Duration > CustomCumulativeData->MaxDur) {
116 CustomCumulativeData->MaxDur = Duration;
117 }
118 }
119 }
120 }
121
122 /**
123 Gather and print ALL Trace Records.
124
125 Displays all "interesting" Trace measurements in order.<BR>
126 The number of records displayed is controlled by:
127 - records with a duration less than mInterestThreshold microseconds are not displayed.
128 - No more than Limit records are displayed. A Limit of zero will not limit the output.
129 - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not
130 displayed.
131
132 @pre The mInterestThreshold global variable is set to the shortest duration to be printed.
133 The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.
134 They must not be in use by a calling function.
135
136 @param[in] Limit The number of records to print. Zero is ALL.
137 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display.
138
139 @retval EFI_SUCCESS The operation was successful.
140 @retval EFI_ABORTED The user aborts the operation.
141 @return Others from a call to gBS->LocateHandleBuffer().
142 **/
143 EFI_STATUS
144 DumpAllTrace(
145 IN UINTN Limit,
146 IN BOOLEAN ExcludeFlag
147 )
148 {
149 MEASUREMENT_RECORD Measurement;
150 UINT64 ElapsedTime;
151 UINT64 Duration;
152 CHAR16 *IncFlag;
153 UINTN LogEntryKey;
154 UINTN Count;
155 UINTN Index;
156 UINTN TIndex;
157
158 EFI_HANDLE *HandleBuffer;
159 UINTN HandleCount;
160 EFI_STATUS Status;
161 EFI_STRING StringPtrUnknown;
162
163 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
164 IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_ALL), NULL);
165 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
166 (IncFlag == NULL) ? StringPtrUnknown : IncFlag);
167 FreePool (StringPtrUnknown);
168
169 // Get Handle information
170 //
171 Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer);
172 if (EFI_ERROR (Status)) {
173 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), gDpHiiHandle, Status);
174 }
175 else {
176 // We have successfully populated the HandleBuffer
177 // Display ALL Measurement Records
178 // Up to Limit lines displayed
179 // Display only records with Elapsed times >= mInterestThreshold
180 // Display driver names in Module field for records with Handles.
181 //
182 if (mShowId) {
183 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_HEADR2), gDpHiiHandle);
184 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_DASHES2), gDpHiiHandle);
185 } else {
186 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_HEADR), gDpHiiHandle);
187 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);
188 }
189
190 LogEntryKey = 0;
191 Count = 0;
192 Index = 0;
193 while ( WITHIN_LIMIT(Count, Limit) &&
194 ((LogEntryKey = GetPerformanceMeasurementEx (
195 LogEntryKey,
196 &Measurement.Handle,
197 &Measurement.Token,
198 &Measurement.Module,
199 &Measurement.StartTimeStamp,
200 &Measurement.EndTimeStamp,
201 &Measurement.Identifier)) != 0)
202 )
203 {
204 ++Index; // Count every record. First record is 1.
205 ElapsedTime = 0;
206 SHELL_FREE_NON_NULL (IncFlag);
207 if (Measurement.EndTimeStamp != 0) {
208 Duration = GetDuration (&Measurement);
209 ElapsedTime = DurationInMicroSeconds ( Duration );
210 IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_COMPLETE), NULL);
211 }
212 else {
213 IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_INCOMPLETE), NULL); // Mark incomplete records
214 }
215 if (((Measurement.EndTimeStamp != 0) && (ElapsedTime < mInterestThreshold)) ||
216 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))
217 ) { // Ignore "uninteresting" or excluded records
218 continue;
219 }
220 ++Count; // Count the number of records printed
221
222 // If Handle is non-zero, see if we can determine a name for the driver
223 AsciiStrToUnicodeStrS (Measurement.Module, mGaugeString, ARRAY_SIZE (mGaugeString)); // Use Module by default
224 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken));
225 if (Measurement.Handle != NULL) {
226 // See if the Handle is in the HandleBuffer
227 for (TIndex = 0; TIndex < HandleCount; TIndex++) {
228 if (Measurement.Handle == HandleBuffer[TIndex]) {
229 DpGetNameFromHandle (HandleBuffer[TIndex]);
230 break;
231 }
232 }
233 }
234
235 if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) {
236 UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", Measurement.Handle);
237 }
238
239 // Ensure that the argument strings are not too long.
240 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
241 mUnicodeToken[13] = 0;
242
243 if (mShowId) {
244 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_VARS2), gDpHiiHandle,
245 Index, // 1 based, Which measurement record is being printed
246 IncFlag,
247 Measurement.Handle,
248 mGaugeString,
249 mUnicodeToken,
250 ElapsedTime,
251 Measurement.Identifier
252 );
253 } else {
254 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_VARS), gDpHiiHandle,
255 Index, // 1 based, Which measurement record is being printed
256 IncFlag,
257 Measurement.Handle,
258 mGaugeString,
259 mUnicodeToken,
260 ElapsedTime
261 );
262 }
263 if (ShellGetExecutionBreakFlag ()) {
264 Status = EFI_ABORTED;
265 break;
266 }
267 }
268 }
269 if (HandleBuffer != NULL) {
270 FreePool (HandleBuffer);
271 }
272 SHELL_FREE_NON_NULL (IncFlag);
273
274 return Status;
275 }
276
277 /**
278 Gather and print Raw Trace Records.
279
280 All Trace measurements with a duration greater than or equal to
281 mInterestThreshold are printed without interpretation.
282
283 The number of records displayed is controlled by:
284 - records with a duration less than mInterestThreshold microseconds are not displayed.
285 - No more than Limit records are displayed. A Limit of zero will not limit the output.
286 - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not
287 displayed.
288
289 @pre The mInterestThreshold global variable is set to the shortest duration to be printed.
290
291 @param[in] Limit The number of records to print. Zero is ALL.
292 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display.
293
294 @retval EFI_SUCCESS The operation was successful.
295 @retval EFI_ABORTED The user aborts the operation.
296 **/
297 EFI_STATUS
298 DumpRawTrace(
299 IN UINTN Limit,
300 IN BOOLEAN ExcludeFlag
301 )
302 {
303 MEASUREMENT_RECORD Measurement;
304 UINT64 ElapsedTime;
305 UINT64 Duration;
306 UINTN LogEntryKey;
307 UINTN Count;
308 UINTN Index;
309
310 EFI_STRING StringPtr;
311 EFI_STRING StringPtrUnknown;
312 EFI_STATUS Status;
313
314 Status = EFI_SUCCESS;
315
316 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
317 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWTRACE), NULL);
318 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
319 (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
320 FreePool (StringPtr);
321 FreePool (StringPtrUnknown);
322
323 if (mShowId) {
324 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_HEADR2), gDpHiiHandle);
325 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_DASHES2), gDpHiiHandle);
326 } else {
327 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_HEADR), gDpHiiHandle);
328 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_DASHES), gDpHiiHandle);
329 }
330
331 LogEntryKey = 0;
332 Count = 0;
333 Index = 0;
334 while ( WITHIN_LIMIT(Count, Limit) &&
335 ((LogEntryKey = GetPerformanceMeasurementEx (
336 LogEntryKey,
337 &Measurement.Handle,
338 &Measurement.Token,
339 &Measurement.Module,
340 &Measurement.StartTimeStamp,
341 &Measurement.EndTimeStamp,
342 &Measurement.Identifier)) != 0)
343 )
344 {
345 ++Index; // Count every record. First record is 1.
346 ElapsedTime = 0;
347 if (Measurement.EndTimeStamp != 0) {
348 Duration = GetDuration (&Measurement);
349 ElapsedTime = DurationInMicroSeconds ( Duration );
350 }
351 if ((ElapsedTime < mInterestThreshold) ||
352 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))
353 ) { // Ignore "uninteresting" or Excluded records
354 continue;
355 }
356 ++Count; // Count the number of records printed
357
358 if (mShowId) {
359 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_VARS2), gDpHiiHandle,
360 Index, // 1 based, Which measurement record is being printed
361 Measurement.Handle,
362 Measurement.StartTimeStamp,
363 Measurement.EndTimeStamp,
364 Measurement.Token,
365 Measurement.Module,
366 Measurement.Identifier
367 );
368 } else {
369 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_VARS), gDpHiiHandle,
370 Index, // 1 based, Which measurement record is being printed
371 Measurement.Handle,
372 Measurement.StartTimeStamp,
373 Measurement.EndTimeStamp,
374 Measurement.Token,
375 Measurement.Module
376 );
377 }
378 if (ShellGetExecutionBreakFlag ()) {
379 Status = EFI_ABORTED;
380 break;
381 }
382 }
383 return Status;
384 }
385
386 /**
387 Gather and print Major Phase metrics.
388
389 @param[in] Ticker The timer value for the END of Shell phase
390
391 **/
392 VOID
393 ProcessPhases(
394 IN UINT64 Ticker
395 )
396 {
397 MEASUREMENT_RECORD Measurement;
398 UINT64 BdsTimeoutValue;
399 UINT64 SecTime;
400 UINT64 PeiTime;
401 UINT64 DxeTime;
402 UINT64 BdsTime;
403 UINT64 ShellTime;
404 UINT64 ElapsedTime;
405 UINT64 Duration;
406 UINT64 Total;
407 EFI_STRING StringPtr;
408 UINTN LogEntryKey;
409 EFI_STRING StringPtrUnknown;
410
411 BdsTimeoutValue = 0;
412 SecTime = 0;
413 PeiTime = 0;
414 DxeTime = 0;
415 BdsTime = 0;
416 ShellTime = 0;
417 //
418 // Get Execution Phase Statistics
419 //
420 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
421 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PHASES), NULL);
422 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
423 (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
424 FreePool (StringPtr);
425 FreePool (StringPtrUnknown);
426
427 LogEntryKey = 0;
428 while ((LogEntryKey = GetPerformanceMeasurementEx (
429 LogEntryKey,
430 &Measurement.Handle,
431 &Measurement.Token,
432 &Measurement.Module,
433 &Measurement.StartTimeStamp,
434 &Measurement.EndTimeStamp,
435 &Measurement.Identifier)) != 0)
436 {
437 if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {
438 Measurement.EndTimeStamp = Ticker;
439 }
440 if (Measurement.EndTimeStamp == 0) { // Skip "incomplete" records
441 continue;
442 }
443 Duration = GetDuration (&Measurement);
444 if ( Measurement.Handle != NULL
445 && (AsciiStrnCmp (Measurement.Token, ALit_BdsTO, PERF_TOKEN_LENGTH) == 0)
446 )
447 {
448 BdsTimeoutValue = Duration;
449 } else if (AsciiStrnCmp (Measurement.Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) {
450 SecTime = Duration;
451 } else if (AsciiStrnCmp (Measurement.Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) {
452 PeiTime = Duration;
453 } else if (AsciiStrnCmp (Measurement.Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) {
454 DxeTime = Duration;
455 } else if (AsciiStrnCmp (Measurement.Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0) {
456 BdsTime = Duration;
457 } else if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {
458 ShellTime = Duration;
459 }
460 }
461
462 Total = 0;
463
464 // print SEC phase duration time
465 //
466 if (SecTime > 0) {
467 ElapsedTime = DurationInMicroSeconds ( SecTime ); // Calculate elapsed time in microseconds
468 Total += DivU64x32 (ElapsedTime, 1000); // Accumulate time in milliseconds
469 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SEC_PHASE), gDpHiiHandle, ElapsedTime);
470 }
471
472 // print PEI phase duration time
473 //
474 if (PeiTime > 0) {
475 ElapsedTime = DivU64x32 (
476 PeiTime,
477 (UINT32)TimerInfo.Frequency
478 );
479 Total += ElapsedTime;
480 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_PEI, ElapsedTime);
481 }
482
483 // print DXE phase duration time
484 //
485 if (DxeTime > 0) {
486 ElapsedTime = DivU64x32 (
487 DxeTime,
488 (UINT32)TimerInfo.Frequency
489 );
490 Total += ElapsedTime;
491 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_DXE, ElapsedTime);
492 }
493
494 // print BDS phase duration time
495 //
496 if (BdsTime > 0) {
497 ElapsedTime = DivU64x32 (
498 BdsTime,
499 (UINT32)TimerInfo.Frequency
500 );
501 Total += ElapsedTime;
502 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_BDS, ElapsedTime);
503 }
504
505 if (BdsTimeoutValue > 0) {
506 ElapsedTime = DivU64x32 (
507 BdsTimeoutValue,
508 (UINT32)TimerInfo.Frequency
509 );
510 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_BDSTO), gDpHiiHandle, ALit_BdsTO, ElapsedTime);
511 }
512
513 // print SHELL phase duration time
514 //
515 if (ShellTime > 0) {
516 ElapsedTime = DivU64x32 (
517 ShellTime,
518 (UINT32)TimerInfo.Frequency
519 );
520 Total += ElapsedTime;
521 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_SHELL, ElapsedTime);
522 }
523
524 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TOTAL_DURATION), gDpHiiHandle, Total);
525 }
526
527 /**
528 Gather and print Handle data.
529
530 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display.
531
532 @retval EFI_SUCCESS The operation was successful.
533 @retval EFI_ABORTED The user aborts the operation.
534 @return Others from a call to gBS->LocateHandleBuffer().
535 **/
536 EFI_STATUS
537 ProcessHandles(
538 IN BOOLEAN ExcludeFlag
539 )
540 {
541 MEASUREMENT_RECORD Measurement;
542 UINT64 ElapsedTime;
543 UINT64 Duration;
544 EFI_HANDLE *HandleBuffer;
545 EFI_STRING StringPtr;
546 UINTN Index;
547 UINTN LogEntryKey;
548 UINTN Count;
549 UINTN HandleCount;
550 EFI_STATUS Status;
551 EFI_STRING StringPtrUnknown;
552
553 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
554 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_DRIVERS), NULL);
555 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
556 (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
557 FreePool (StringPtr);
558 FreePool (StringPtrUnknown);
559
560 Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer);
561 if (EFI_ERROR (Status)) {
562 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), gDpHiiHandle, Status);
563 }
564 else {
565 #if DP_DEBUG == 2
566 Print (L"There are %,d Handles defined.\n", (Size / sizeof(HandleBuffer[0])));
567 #endif
568
569 if (mShowId) {
570 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_SECTION2), gDpHiiHandle);
571 } else {
572 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_SECTION), gDpHiiHandle);
573 }
574 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);
575
576 LogEntryKey = 0;
577 Count = 0;
578 while ((LogEntryKey = GetPerformanceMeasurementEx (
579 LogEntryKey,
580 &Measurement.Handle,
581 &Measurement.Token,
582 &Measurement.Module,
583 &Measurement.StartTimeStamp,
584 &Measurement.EndTimeStamp,
585 &Measurement.Identifier)) != 0)
586 {
587 Count++;
588 Duration = GetDuration (&Measurement);
589 ElapsedTime = DurationInMicroSeconds ( Duration );
590 if ((ElapsedTime < mInterestThreshold) ||
591 (Measurement.EndTimeStamp == 0) ||
592 (Measurement.Handle == NULL) ||
593 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))
594 ) { // Ignore "uninteresting" or excluded records
595 continue;
596 }
597 mGaugeString[0] = 0; // Empty driver name by default
598 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken));
599 // See if the Handle is in the HandleBuffer
600 for (Index = 0; Index < HandleCount; Index++) {
601 if (Measurement.Handle == HandleBuffer[Index]) {
602 DpGetNameFromHandle (HandleBuffer[Index]); // Name is put into mGaugeString
603 break;
604 }
605 }
606 // Ensure that the argument strings are not too long.
607 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
608 mUnicodeToken[11] = 0;
609 if (mGaugeString[0] != 0) {
610 // Display the record if it has a valid handle.
611 if (mShowId) {
612 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_VARS2), gDpHiiHandle,
613 Count, // 1 based, Which measurement record is being printed
614 Index + 1, // 1 based, Which handle is being printed
615 mGaugeString,
616 mUnicodeToken,
617 ElapsedTime,
618 Measurement.Identifier
619 );
620 } else {
621 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_VARS), gDpHiiHandle,
622 Count, // 1 based, Which measurement record is being printed
623 Index + 1, // 1 based, Which handle is being printed
624 mGaugeString,
625 mUnicodeToken,
626 ElapsedTime
627 );
628 }
629 }
630 if (ShellGetExecutionBreakFlag ()) {
631 Status = EFI_ABORTED;
632 break;
633 }
634 }
635 }
636 if (HandleBuffer != NULL) {
637 FreePool (HandleBuffer);
638 }
639 return Status;
640 }
641
642 /**
643 Gather and print PEIM data.
644
645 Only prints complete PEIM records
646
647 @retval EFI_SUCCESS The operation was successful.
648 @retval EFI_ABORTED The user aborts the operation.
649 **/
650 EFI_STATUS
651 ProcessPeims(
652 VOID
653 )
654 {
655 MEASUREMENT_RECORD Measurement;
656 UINT64 Duration;
657 UINT64 ElapsedTime;
658 EFI_STRING StringPtr;
659 UINTN LogEntryKey;
660 UINTN TIndex;
661 EFI_STRING StringPtrUnknown;
662 EFI_STATUS Status;
663
664 Status = EFI_SUCCESS;
665
666 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
667 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PEIMS), NULL);
668 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
669 (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
670 FreePool (StringPtr);
671 FreePool (StringPtrUnknown);
672
673 if (mShowId) {
674 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_SECTION2), gDpHiiHandle);
675 } else {
676 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_SECTION), gDpHiiHandle);
677 }
678 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);
679 TIndex = 0;
680 LogEntryKey = 0;
681 while ((LogEntryKey = GetPerformanceMeasurementEx (
682 LogEntryKey,
683 &Measurement.Handle,
684 &Measurement.Token,
685 &Measurement.Module,
686 &Measurement.StartTimeStamp,
687 &Measurement.EndTimeStamp,
688 &Measurement.Identifier)) != 0)
689 {
690 TIndex++;
691 if ((Measurement.EndTimeStamp == 0) ||
692 (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) != 0)
693 ) {
694 continue;
695 }
696
697 Duration = GetDuration (&Measurement);
698 ElapsedTime = DurationInMicroSeconds ( Duration ); // Calculate elapsed time in microseconds
699 if (ElapsedTime >= mInterestThreshold) {
700 // PEIM FILE Handle is the start address of its FFS file that contains its file guid.
701 if (mShowId) {
702 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_VARS2), gDpHiiHandle,
703 TIndex, // 1 based, Which measurement record is being printed
704 Measurement.Handle, // base address
705 Measurement.Handle, // file guid
706 ElapsedTime,
707 Measurement.Identifier
708 );
709 } else {
710 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_VARS), gDpHiiHandle,
711 TIndex, // 1 based, Which measurement record is being printed
712 Measurement.Handle, // base address
713 Measurement.Handle, // file guid
714 ElapsedTime
715 );
716 }
717 }
718 if (ShellGetExecutionBreakFlag ()) {
719 Status = EFI_ABORTED;
720 break;
721 }
722 }
723 return Status;
724 }
725
726 /**
727 Gather and print global data.
728
729 Strips out incomplete or "Execution Phase" records
730 Only prints records where Handle is NULL
731 Increment TIndex for every record, even skipped ones, so that we have an
732 indication of every measurement record taken.
733
734 @retval EFI_SUCCESS The operation was successful.
735 @retval EFI_ABORTED The user aborts the operation.
736 **/
737 EFI_STATUS
738 ProcessGlobal(
739 VOID
740 )
741 {
742 MEASUREMENT_RECORD Measurement;
743 UINT64 Duration;
744 UINT64 ElapsedTime;
745 EFI_STRING StringPtr;
746 UINTN LogEntryKey;
747 UINTN Index; // Index, or number, of the measurement record being processed
748 EFI_STRING StringPtrUnknown;
749 EFI_STATUS Status;
750
751 Status = EFI_SUCCESS;
752
753 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
754 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_GENERAL), NULL);
755 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
756 (StringPtr == NULL) ? StringPtrUnknown: StringPtr);
757 FreePool (StringPtr);
758 FreePool (StringPtrUnknown);
759
760 if (mShowId) {
761 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_SECTION2), gDpHiiHandle);
762 } else {
763 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_SECTION), gDpHiiHandle);
764 }
765 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);
766
767 Index = 1;
768 LogEntryKey = 0;
769
770 while ((LogEntryKey = GetPerformanceMeasurementEx (
771 LogEntryKey,
772 &Measurement.Handle,
773 &Measurement.Token,
774 &Measurement.Module,
775 &Measurement.StartTimeStamp,
776 &Measurement.EndTimeStamp,
777 &Measurement.Identifier)) != 0)
778 {
779 AsciiStrToUnicodeStrS (Measurement.Module, mGaugeString, ARRAY_SIZE (mGaugeString));
780 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken));
781 mGaugeString[25] = 0;
782 mUnicodeToken[31] = 0;
783 if ( ! ( IsPhase( &Measurement) ||
784 (Measurement.Handle != NULL) ||
785 (Measurement.EndTimeStamp == 0)
786 ))
787 {
788 Duration = GetDuration (&Measurement);
789 ElapsedTime = DurationInMicroSeconds ( Duration );
790 if (ElapsedTime >= mInterestThreshold) {
791 if (mShowId) {
792 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_VARS2), gDpHiiHandle,
793 Index,
794 mGaugeString,
795 mUnicodeToken,
796 ElapsedTime,
797 Measurement.Identifier
798 );
799 } else {
800 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_VARS), gDpHiiHandle,
801 Index,
802 mGaugeString,
803 mUnicodeToken,
804 ElapsedTime
805 );
806 }
807 }
808 }
809 if (ShellGetExecutionBreakFlag ()) {
810 Status = EFI_ABORTED;
811 break;
812 }
813 Index++;
814 }
815 return Status;
816 }
817
818 /**
819 Gather and print cumulative data.
820
821 Traverse the measurement records and:<BR>
822 For each record with a Token listed in the CumData array:<BR>
823 - Update the instance count and the total, minimum, and maximum durations.
824 Finally, print the gathered cumulative statistics.
825
826 @param[in] CustomCumulativeData A pointer to the cumtom cumulative data.
827
828 **/
829 VOID
830 ProcessCumulative(
831 IN PERF_CUM_DATA *CustomCumulativeData OPTIONAL
832 )
833 {
834 UINT64 AvgDur; // the computed average duration
835 UINT64 Dur;
836 UINT64 MinDur;
837 UINT64 MaxDur;
838 EFI_STRING StringPtr;
839 UINTN TIndex;
840 EFI_STRING StringPtrUnknown;
841
842 StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
843 StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL);
844 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
845 (StringPtr == NULL) ? StringPtrUnknown: StringPtr);
846 FreePool (StringPtr);
847 FreePool (StringPtrUnknown);
848
849 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1), gDpHiiHandle);
850 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2), gDpHiiHandle);
851 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);
852
853 for ( TIndex = 0; TIndex < NumCum; ++TIndex) {
854 if (CumData[TIndex].Count != 0) {
855 AvgDur = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count);
856 AvgDur = DurationInMicroSeconds(AvgDur);
857 Dur = DurationInMicroSeconds(CumData[TIndex].Duration);
858 MaxDur = DurationInMicroSeconds(CumData[TIndex].MaxDur);
859 MinDur = DurationInMicroSeconds(CumData[TIndex].MinDur);
860
861 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_STATS), gDpHiiHandle,
862 CumData[TIndex].Name,
863 CumData[TIndex].Count,
864 Dur,
865 AvgDur,
866 MinDur,
867 MaxDur
868 );
869 }
870 }
871
872 //
873 // Print the custom cumulative data.
874 //
875 if (CustomCumulativeData != NULL) {
876 if (CustomCumulativeData->Count != 0) {
877 AvgDur = DivU64x32 (CustomCumulativeData->Duration, CustomCumulativeData->Count);
878 AvgDur = DurationInMicroSeconds (AvgDur);
879 Dur = DurationInMicroSeconds (CustomCumulativeData->Duration);
880 MaxDur = DurationInMicroSeconds (CustomCumulativeData->MaxDur);
881 MinDur = DurationInMicroSeconds (CustomCumulativeData->MinDur);
882 } else {
883 AvgDur = 0;
884 Dur = 0;
885 MaxDur = 0;
886 MinDur = 0;
887 }
888 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_STATS), gDpHiiHandle,
889 CustomCumulativeData->Name,
890 CustomCumulativeData->Count,
891 Dur,
892 AvgDur,
893 MinDur,
894 MaxDur
895 );
896 }
897 }