a906808ab312a84381afe7d68b88414e188e8751
[mirror_edk2.git] / ShellPkg / DynamicCommand / DpDynamicCommand / Dp.c
1 /** @file
2 Shell command for Displaying Performance Metrics.
3
4 The Dp command reads performance data and presents it in several
5 different formats depending upon the needs of the user. Both
6 Trace and Measured Profiling information is processed and presented.
7
8 Dp uses the "PerformanceLib" to read the measurement records.
9 The "TimerLib" provides information about the timer, such as frequency,
10 beginning, and ending counter values.
11 Measurement records contain identifying information (Handle, Token, Module)
12 and start and end time values.
13 Dp uses this information to group records in different ways. It also uses
14 timer information to calculate elapsed time for each measurement.
15
16 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.
17 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
18 This program and the accompanying materials
19 are licensed and made available under the terms and conditions of the BSD License
20 which accompanies this distribution. The full text of the license may be found at
21 http://opensource.org/licenses/bsd-license.php
22
23 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
24 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
25 **/
26
27 #include "Dp.h"
28 #include "Literals.h"
29 #include "DpInternal.h"
30
31 #pragma pack(1)
32
33 typedef struct {
34 EFI_ACPI_DESCRIPTION_HEADER Header;
35 UINT32 Entry;
36 } RSDT_TABLE;
37
38 typedef struct {
39 EFI_ACPI_DESCRIPTION_HEADER Header;
40 UINT64 Entry;
41 } XSDT_TABLE;
42
43 #pragma pack()
44
45 EFI_HANDLE mDpHiiHandle;
46
47 typedef struct {
48 EFI_HANDLE Handle;
49 EFI_GUID ModuleGuid;
50 } HANDLE_GUID_MAP;
51
52 HANDLE_GUID_MAP *mCacheHandleGuidTable;
53 UINTN mCachePairCount = 0;
54
55 //
56 /// Module-Global Variables
57 ///@{
58 CHAR16 mGaugeString[DP_GAUGE_STRING_LENGTH + 1];
59 CHAR16 mUnicodeToken[DXE_PERFORMANCE_STRING_SIZE];
60 UINT64 mInterestThreshold;
61 BOOLEAN mShowId = FALSE;
62 UINT8 *mBootPerformanceTable;
63 UINTN mBootPerformanceTableSize;
64 BOOLEAN mPeiPhase = FALSE;
65 BOOLEAN mDxePhase = FALSE;
66
67 PERF_SUMMARY_DATA SummaryData = { 0 }; ///< Create the SummaryData structure and init. to ZERO.
68 MEASUREMENT_RECORD *mMeasurementList = NULL;
69 UINTN mMeasurementNum = 0;
70
71 /// Items for which to gather cumulative statistics.
72 PERF_CUM_DATA CumData[] = {
73 PERF_INIT_CUM_DATA (LOAD_IMAGE_TOK),
74 PERF_INIT_CUM_DATA (START_IMAGE_TOK),
75 PERF_INIT_CUM_DATA (DRIVERBINDING_START_TOK),
76 PERF_INIT_CUM_DATA (DRIVERBINDING_SUPPORT_TOK)
77 };
78
79 /// Number of items for which we are gathering cumulative statistics.
80 UINT32 const NumCum = sizeof(CumData) / sizeof(PERF_CUM_DATA);
81
82 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
83 {L"-v", TypeFlag}, // -v Verbose Mode
84 {L"-A", TypeFlag}, // -A All, Cooked
85 {L"-R", TypeFlag}, // -R RAW All
86 {L"-s", TypeFlag}, // -s Summary
87 {L"-x", TypeFlag}, // -x eXclude Cumulative Items
88 {L"-i", TypeFlag}, // -i Display Identifier
89 {L"-c", TypeValue}, // -c Display cumulative data.
90 {L"-n", TypeValue}, // -n # Number of records to display for A and R
91 {L"-t", TypeValue}, // -t # Threshold of interest
92 {NULL, TypeMax}
93 };
94
95 ///@}
96
97 /**
98 Display the trailing Verbose information.
99 **/
100 VOID
101 DumpStatistics( void )
102 {
103 EFI_STRING StringPtr;
104 EFI_STRING StringPtrUnknown;
105 StringPtr = HiiGetString (mDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_STATISTICS), NULL);
106 StringPtrUnknown = HiiGetString (mDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
107 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), mDpHiiHandle,
108 (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
109 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMTRACE), mDpHiiHandle, SummaryData.NumTrace);
110 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMINCOMPLETE), mDpHiiHandle, SummaryData.NumIncomplete);
111 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPHASES), mDpHiiHandle, SummaryData.NumSummary);
112 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMHANDLES), mDpHiiHandle, SummaryData.NumHandles, SummaryData.NumTrace - SummaryData.NumHandles);
113 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPEIMS), mDpHiiHandle, SummaryData.NumPEIMs);
114 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMGLOBALS), mDpHiiHandle, SummaryData.NumGlobal);
115 SHELL_FREE_NON_NULL (StringPtr);
116 SHELL_FREE_NON_NULL (StringPtrUnknown);
117 }
118
119 /**
120 This function scan ACPI table in RSDT.
121
122 @param Rsdt ACPI RSDT
123 @param Signature ACPI table signature
124
125 @return ACPI table
126 **/
127 VOID *
128 ScanTableInRSDT (
129 IN RSDT_TABLE *Rsdt,
130 IN UINT32 Signature
131 )
132 {
133 UINTN Index;
134 UINT32 EntryCount;
135 UINT32 *EntryPtr;
136 EFI_ACPI_DESCRIPTION_HEADER *Table;
137
138 EntryCount = (Rsdt->Header.Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof(UINT32);
139
140 EntryPtr = &Rsdt->Entry;
141 for (Index = 0; Index < EntryCount; Index ++, EntryPtr ++) {
142 Table = (EFI_ACPI_DESCRIPTION_HEADER*)((UINTN)(*EntryPtr));
143 if (Table->Signature == Signature) {
144 return Table;
145 }
146 }
147
148 return NULL;
149 }
150
151 /**
152 This function scan ACPI table in XSDT.
153
154 @param Xsdt ACPI XSDT
155 @param Signature ACPI table signature
156
157 @return ACPI table
158 **/
159 VOID *
160 ScanTableInXSDT (
161 IN XSDT_TABLE *Xsdt,
162 IN UINT32 Signature
163 )
164 {
165 UINTN Index;
166 UINT32 EntryCount;
167 UINT64 EntryPtr;
168 UINTN BasePtr;
169 EFI_ACPI_DESCRIPTION_HEADER *Table;
170
171 EntryCount = (Xsdt->Header.Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof(UINT64);
172
173 BasePtr = (UINTN)(&(Xsdt->Entry));
174 for (Index = 0; Index < EntryCount; Index ++) {
175 CopyMem (&EntryPtr, (VOID *)(BasePtr + Index * sizeof(UINT64)), sizeof(UINT64));
176 Table = (EFI_ACPI_DESCRIPTION_HEADER*)((UINTN)(EntryPtr));
177 if (Table->Signature == Signature) {
178 return Table;
179 }
180 }
181
182 return NULL;
183 }
184
185 /**
186 This function scan ACPI table in RSDP.
187
188 @param Rsdp ACPI RSDP
189 @param Signature ACPI table signature
190
191 @return ACPI table
192 **/
193 VOID *
194 FindAcpiPtr (
195 IN EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp,
196 IN UINT32 Signature
197 )
198 {
199 EFI_ACPI_DESCRIPTION_HEADER *AcpiTable;
200 RSDT_TABLE *Rsdt;
201 XSDT_TABLE *Xsdt;
202
203 AcpiTable = NULL;
204
205 //
206 // Check ACPI2.0 table
207 //
208 Rsdt = (RSDT_TABLE *)(UINTN)Rsdp->RsdtAddress;
209 Xsdt = NULL;
210 if ((Rsdp->Revision >= 2) && (Rsdp->XsdtAddress < (UINT64)(UINTN)-1)) {
211 Xsdt = (XSDT_TABLE *)(UINTN)Rsdp->XsdtAddress;
212 }
213 //
214 // Check Xsdt
215 //
216 if (Xsdt != NULL) {
217 AcpiTable = ScanTableInXSDT (Xsdt, Signature);
218 }
219 //
220 // Check Rsdt
221 //
222 if ((AcpiTable == NULL) && (Rsdt != NULL)) {
223 AcpiTable = ScanTableInRSDT (Rsdt, Signature);
224 }
225
226 return AcpiTable;
227 }
228
229 /**
230 Get Boot performance table form Acpi table.
231
232 **/
233 EFI_STATUS
234 GetBootPerformanceTable (
235 )
236 {
237 EFI_STATUS Status;
238 VOID *AcpiTable;
239 FIRMWARE_PERFORMANCE_TABLE *FirmwarePerformanceTable;
240
241 AcpiTable = NULL;
242
243 Status = EfiGetSystemConfigurationTable (
244 &gEfiAcpi20TableGuid,
245 &AcpiTable
246 );
247 if (EFI_ERROR (Status)) {
248 Status = EfiGetSystemConfigurationTable (
249 &gEfiAcpi10TableGuid,
250 &AcpiTable
251 );
252 }
253 if (EFI_ERROR(Status) || AcpiTable == NULL) {
254 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GET_ACPI_TABLE_FAIL), mDpHiiHandle);
255 return Status;
256 }
257
258 FirmwarePerformanceTable = FindAcpiPtr (
259 (EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER *)AcpiTable,
260 EFI_ACPI_5_0_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE
261 );
262 if (FirmwarePerformanceTable == NULL) {
263 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GET_ACPI_FPDT_FAIL), mDpHiiHandle);
264 return EFI_NOT_FOUND;
265 }
266
267 mBootPerformanceTable = (UINT8*) (UINTN)FirmwarePerformanceTable->BootPointerRecord.BootPerformanceTablePointer;
268 mBootPerformanceTableSize = ((BOOT_PERFORMANCE_TABLE *) mBootPerformanceTable)->Header.Length;
269
270 return EFI_SUCCESS;
271 }
272
273 /**
274 Get Handle form Module Guid.
275
276 @param ModuleGuid Module Guid.
277 @param Handle The handle to be returned.
278
279 **/
280 VOID
281 GetHandleFormModuleGuid (
282 IN EFI_GUID *ModuleGuid,
283 IN OUT EFI_HANDLE *Handle
284 )
285 {
286 UINTN Index;
287
288 if (IsZeroGuid (ModuleGuid)) {
289 *Handle = NULL;
290 }
291 //
292 // Try to get the Handle form the caached array.
293 //
294 for (Index = 0; Index < mCachePairCount; Index++) {
295 if (CompareGuid (ModuleGuid, &mCacheHandleGuidTable[Index].ModuleGuid)) {
296 *Handle = mCacheHandleGuidTable[Index].Handle;
297 break;
298 }
299 }
300 if (Index >= mCachePairCount) {
301 *Handle = NULL;
302 }
303 }
304
305 /**
306 Cache the GUID and handle mapping pairs. In order to save time for searching.
307
308 **/
309 EFI_STATUS
310 BuildCachedGuidHandleTable (
311 VOID
312 )
313 {
314 EFI_STATUS Status;
315 EFI_HANDLE *HandleBuffer;
316 UINTN HandleCount;
317 UINTN Index;
318 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
319 EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
320 EFI_GUID *TempGuid;
321 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;
322
323 Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer);
324 if (EFI_ERROR (Status)) {
325 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), mDpHiiHandle, Status);
326 return Status;
327 }
328
329 mCacheHandleGuidTable = AllocateZeroPool (HandleCount * sizeof (HANDLE_GUID_MAP));
330 if (mCacheHandleGuidTable == NULL) {
331 return EFI_OUT_OF_RESOURCES;
332 }
333
334 for (Index = 0; Index < HandleCount; Index++) {
335 //
336 // Try Handle as ImageHandle.
337 //
338 Status = gBS->HandleProtocol (
339 HandleBuffer[Index],
340 &gEfiLoadedImageProtocolGuid,
341 (VOID**) &LoadedImage
342 );
343 if (EFI_ERROR (Status)) {
344 //
345 // Try Handle as Controller Handle
346 //
347 Status = gBS->OpenProtocol (
348 HandleBuffer[Index],
349 &gEfiDriverBindingProtocolGuid,
350 (VOID **) &DriverBinding,
351 NULL,
352 NULL,
353 EFI_OPEN_PROTOCOL_GET_PROTOCOL
354 );
355 if (!EFI_ERROR (Status)) {
356 //
357 // Get Image protocol from ImageHandle
358 //
359 Status = gBS->HandleProtocol (
360 DriverBinding->ImageHandle,
361 &gEfiLoadedImageProtocolGuid,
362 (VOID**) &LoadedImage
363 );
364 }
365 }
366
367 if (!EFI_ERROR (Status) && LoadedImage != NULL) {
368 //
369 // Get Module Guid from DevicePath.
370 //
371 if (LoadedImage->FilePath != NULL &&
372 LoadedImage->FilePath->Type == MEDIA_DEVICE_PATH &&
373 LoadedImage->FilePath->SubType == MEDIA_PIWG_FW_FILE_DP
374 ) {
375 FvFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LoadedImage->FilePath;
376 TempGuid = &FvFilePath->FvFileName;
377
378 mCacheHandleGuidTable[mCachePairCount].Handle = HandleBuffer[Index];
379 CopyGuid (&mCacheHandleGuidTable[mCachePairCount].ModuleGuid, TempGuid);
380 mCachePairCount ++;
381 }
382 }
383 }
384 if (HandleBuffer != NULL) {
385 FreePool (HandleBuffer);
386 HandleBuffer = NULL;
387 }
388 return EFI_SUCCESS;
389 }
390
391 /**
392 Get Measurement form Fpdt records.
393
394 @param RecordHeader Pointer to the start record.
395 @param IsStart Is start record or End record.
396 @param Measurement Pointer to the measurement which need to be filled.
397
398 **/
399 VOID
400 GetMeasurementInfo (
401 IN EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *RecordHeader,
402 IN BOOLEAN IsStart,
403 IN OUT MEASUREMENT_RECORD *Measurement
404 )
405 {
406 VOID *ModuleGuid;
407 EFI_HANDLE StartHandle;
408
409 switch (RecordHeader->Type) {
410 case FPDT_GUID_EVENT_TYPE:
411 ModuleGuid = &(((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Guid);
412 Measurement->Identifier = ((UINT32)((FPDT_GUID_EVENT_RECORD *)RecordHeader)->ProgressID);
413 if (IsStart) {
414 Measurement->StartTimeStamp = ((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Timestamp;
415 } else {
416 Measurement->EndTimeStamp = ((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Timestamp;
417 }
418 switch (Measurement->Identifier) {
419 case MODULE_START_ID:
420 case MODULE_END_ID:
421 if (mPeiPhase) {
422 Measurement->Token = ALit_PEIM;
423 Measurement->Module = ALit_PEIM;
424 } else if (mDxePhase) {
425 Measurement->Token = ALit_START_IMAGE;
426 Measurement->Module = ALit_START_IMAGE;
427 }
428 break;
429 default:
430 ASSERT(FALSE);
431 }
432
433 if (Measurement->Token != NULL && AsciiStrCmp (Measurement->Token, ALit_PEIM) == 0) {
434 Measurement->Handle = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
435 } else {
436 GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
437 Measurement->Handle = StartHandle;
438 //
439 // When no perf entry to record the PEI and DXE phase,
440 // For start image, we need detect the PEIM and non PEIM here.
441 //
442 if (Measurement->Token == NULL) {
443 if (StartHandle == NULL && !IsZeroGuid (ModuleGuid)) {
444 Measurement->Token = ALit_PEIM;
445 Measurement->Module = ALit_PEIM;
446 Measurement->Handle = ModuleGuid;
447 } else {
448 Measurement->Token = ALit_START_IMAGE;
449 Measurement->Module = ALit_START_IMAGE;
450 }
451 }
452 }
453 break;
454
455 case FPDT_DYNAMIC_STRING_EVENT_TYPE:
456 ModuleGuid = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
457 Measurement->Identifier = ((UINT32)((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
458 if (IsStart) {
459 Measurement->StartTimeStamp = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
460 } else {
461 Measurement->EndTimeStamp = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
462 }
463 switch (Measurement->Identifier) {
464 case MODULE_START_ID:
465 case MODULE_END_ID:
466 if (mPeiPhase) {
467 Measurement->Token = ALit_PEIM;
468 } else if (mDxePhase) {
469 Measurement->Token = ALit_START_IMAGE;
470 }
471 break;
472
473 case MODULE_LOADIMAGE_START_ID:
474 case MODULE_LOADIMAGE_END_ID:
475 Measurement->Token = ALit_LOAD_IMAGE;
476 break;
477
478 case MODULE_DB_START_ID:
479 case MODULE_DB_END_ID:
480 Measurement->Token = ALit_DB_START;
481 break;
482
483 case MODULE_DB_SUPPORT_START_ID:
484 case MODULE_DB_SUPPORT_END_ID:
485 Measurement->Token = ALit_DB_SUPPORT;
486 break;
487
488 case MODULE_DB_STOP_START_ID:
489 case MODULE_DB_STOP_END_ID:
490 Measurement->Token = ALit_DB_STOP;
491 break;
492
493 default:
494 Measurement->Token = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->String;
495 break;
496 }
497
498 Measurement->Module = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->String;
499
500 if (Measurement->Token != NULL && AsciiStrCmp (Measurement->Token, ALit_PEIM) == 0) {
501 Measurement->Handle = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
502 } else {
503 GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
504 Measurement->Handle = StartHandle;
505 //
506 // When no perf entry to record the PEI and DXE phase,
507 // For start image, we need detect the PEIM and non PEIM here.
508 //
509 if (Measurement->Token == NULL && (Measurement->Identifier == MODULE_START_ID || Measurement->Identifier == MODULE_END_ID)) {
510 if (StartHandle == NULL && !IsZeroGuid (ModuleGuid)) {
511 Measurement->Token = ALit_PEIM;
512 Measurement->Handle = ModuleGuid;
513 } else {
514 Measurement->Token = ALit_START_IMAGE;
515 }
516 }
517 }
518 break;
519
520 case FPDT_GUID_QWORD_EVENT_TYPE:
521 ModuleGuid = &(((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Guid);
522 Measurement->Identifier = ((UINT32)((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->ProgressID);
523 if (IsStart) {
524 Measurement->StartTimeStamp = ((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Timestamp;
525 } else {
526 Measurement->EndTimeStamp = ((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Timestamp;
527 }
528 switch (Measurement->Identifier) {
529 case MODULE_DB_START_ID:
530 Measurement->Token = ALit_DB_START;
531 Measurement->Module = ALit_DB_START;
532 break;
533
534 case MODULE_DB_SUPPORT_START_ID:
535 case MODULE_DB_SUPPORT_END_ID:
536 Measurement->Token = ALit_DB_SUPPORT;
537 Measurement->Module = ALit_DB_SUPPORT;
538 break;
539
540 case MODULE_DB_STOP_START_ID:
541 case MODULE_DB_STOP_END_ID:
542 Measurement->Token = ALit_DB_STOP;
543 Measurement->Module = ALit_DB_STOP;
544 break;
545
546 case MODULE_LOADIMAGE_START_ID:
547 case MODULE_LOADIMAGE_END_ID:
548 Measurement->Token = ALit_LOAD_IMAGE;
549 Measurement->Module = ALit_LOAD_IMAGE;
550 break;
551
552 default:
553 ASSERT(FALSE);
554 }
555 GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
556 Measurement->Handle = StartHandle;
557 break;
558
559 case FPDT_GUID_QWORD_STRING_EVENT_TYPE:
560 ModuleGuid = &(((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->Guid);
561 Measurement->Identifier = ((UINT32)((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
562 if (IsStart) {
563 Measurement->StartTimeStamp = ((FPDT_GUID_QWORD_STRING_EVENT_RECORD*)RecordHeader)->Timestamp;
564 } else {
565 Measurement->EndTimeStamp = ((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
566 }
567 //
568 // Currently only "DB:Start:" end record with FPDT_GUID_QWORD_STRING_EVENT_TYPE.
569 //
570 switch (Measurement->Identifier) {
571 case MODULE_DB_END_ID:
572 Measurement->Token = ALit_DB_START;
573 Measurement->Module = ALit_DB_START;
574 break;
575 default:
576 ASSERT(FALSE);
577 }
578 GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
579 Measurement->Handle = StartHandle;
580 break;
581
582 case FPDT_DUAL_GUID_STRING_EVENT_TYPE:
583 ModuleGuid = &(((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Guid1);
584 Measurement->Identifier = ((UINT32)((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
585 if (IsStart) {
586 Measurement->StartTimeStamp = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
587 } else {
588 Measurement->EndTimeStamp = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
589 }
590 Measurement->Token = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->String;
591 Measurement->Module = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->String;
592 GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
593 Measurement->Handle = StartHandle;
594 break;
595
596 default:
597 break;
598 }
599 }
600
601 /**
602 Search the start measurement in the mMeasurementList for the end measurement.
603
604 @param EndMeasureMent Measurement for end record.
605
606 **/
607 VOID
608 SearchMeasurement (
609 IN MEASUREMENT_RECORD *EndMeasureMent
610 )
611 {
612 INTN Index;
613
614 for (Index = mMeasurementNum - 1; Index >= 0; Index--) {
615 if (AsciiStrCmp (EndMeasureMent->Token, ALit_PEIM) == 0) {
616 if (mMeasurementList[Index].EndTimeStamp == 0 && EndMeasureMent->Handle!= NULL && mMeasurementList[Index].Handle != NULL&&
617 CompareGuid(mMeasurementList[Index].Handle, EndMeasureMent->Handle) &&
618 (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
619 (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0)) {
620 mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
621 break;
622 }
623 } else if (EndMeasureMent->Identifier == PERF_CROSSMODULE_END_ID) {
624 if (mMeasurementList[Index].EndTimeStamp == 0 &&
625 (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
626 (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0) &&
627 mMeasurementList[Index].Identifier == PERF_CROSSMODULE_START_ID) {
628 mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
629 break;
630 }
631 } else {
632 if (mMeasurementList[Index].EndTimeStamp == 0 && mMeasurementList[Index].Handle == EndMeasureMent->Handle &&
633 (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
634 (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0)) {
635 mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
636 break;
637 }
638 }
639 }
640 }
641
642 /**
643 Generate the measure record array.
644
645 **/
646 EFI_STATUS
647 BuildMeasurementList (
648 )
649 {
650 EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *RecordHeader;
651 UINT8 *PerformanceTablePtr;
652 UINT16 StartProgressId;
653 UINTN TableLength;
654 UINT8 *StartRecordEvent;
655 MEASUREMENT_RECORD MeasureMent;
656
657 mMeasurementList = AllocateZeroPool (mBootPerformanceTableSize);
658 if (mMeasurementList == NULL) {
659 return EFI_OUT_OF_RESOURCES;
660 }
661
662 TableLength = sizeof (BOOT_PERFORMANCE_TABLE);
663 PerformanceTablePtr = (mBootPerformanceTable + TableLength);
664
665 while (TableLength < mBootPerformanceTableSize) {
666 RecordHeader = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER*) PerformanceTablePtr;
667 StartRecordEvent = (UINT8 *)RecordHeader;
668 StartProgressId = ((FPDT_GUID_EVENT_RECORD *)StartRecordEvent)->ProgressID;
669
670 //
671 // If the record with ProgressId 0, the record doesn't appear in pairs. The timestamp in the record is the EndTimeStamp, its StartTimeStamp is 0.
672 // If the record is the start record, fill the info to the measurement in the mMeasurementList.
673 // If the record is the end record, find the related start measurement in the mMeasurementList and fill the EndTimeStamp.
674 //
675 if (StartProgressId == 0) {
676 GetMeasurementInfo (RecordHeader, FALSE, &(mMeasurementList[mMeasurementNum]));
677 mMeasurementNum ++;
678 } else if (((StartProgressId >= PERF_EVENTSIGNAL_START_ID && ((StartProgressId & 0x000F) == 0)) ||
679 (StartProgressId < PERF_EVENTSIGNAL_START_ID && ((StartProgressId & 0x0001) != 0)))) {
680 //
681 // Since PEIM and StartImage has same Type and ID when PCD PcdEdkiiFpdtStringRecordEnableOnly = FALSE
682 // So we need to identify these two kinds of record through different phase.
683 //
684 if(StartProgressId == PERF_CROSSMODULE_START_ID ){
685 if (AsciiStrCmp (((FPDT_DYNAMIC_STRING_EVENT_RECORD *)StartRecordEvent)->String, ALit_PEI) == 0) {
686 mPeiPhase = TRUE;
687 } else if (AsciiStrCmp (((FPDT_DYNAMIC_STRING_EVENT_RECORD *)StartRecordEvent)->String, ALit_DXE) == 0) {
688 mDxePhase = TRUE;
689 mPeiPhase = FALSE;
690 }
691 }
692 // Get measurement info form the start record to the mMeasurementList.
693 GetMeasurementInfo (RecordHeader, TRUE, &(mMeasurementList[mMeasurementNum]));
694 mMeasurementNum ++;
695 } else {
696 ZeroMem(&MeasureMent, sizeof(MEASUREMENT_RECORD));
697 GetMeasurementInfo (RecordHeader, FALSE, &MeasureMent);
698 SearchMeasurement (&MeasureMent);
699 }
700 TableLength += RecordHeader->Length;
701 PerformanceTablePtr += RecordHeader->Length;
702 }
703 return EFI_SUCCESS;
704 }
705
706 /**
707 Initialize the cumulative data.
708
709 **/
710 VOID
711 InitCumulativeData (
712 VOID
713 )
714 {
715 UINTN Index;
716
717 for (Index = 0; Index < NumCum; ++Index) {
718 CumData[Index].Count = 0;
719 CumData[Index].MinDur = PERF_MAXDUR;
720 CumData[Index].MaxDur = 0;
721 CumData[Index].Duration = 0;
722 }
723 }
724
725 /**
726 Initialize the Summary data.
727
728 **/
729 VOID
730 InitSummaryData (
731 VOID
732 )
733 {
734 SummaryData.NumTrace = 0;
735 SummaryData.NumIncomplete = 0;
736 SummaryData.NumSummary = 0;
737 SummaryData.NumHandles = 0;
738 SummaryData.NumPEIMs = 0;
739 SummaryData.NumGlobal = 0;
740 }
741
742 /**
743 Dump performance data.
744
745 @param[in] ImageHandle The image handle.
746 @param[in] SystemTable The system table.
747
748 @retval SHELL_SUCCESS Command completed successfully.
749 @retval SHELL_INVALID_PARAMETER Command usage error.
750 @retval SHELL_ABORTED The user aborts the operation.
751 @retval value Unknown error.
752 **/
753 SHELL_STATUS
754 RunDp (
755 IN EFI_HANDLE ImageHandle,
756 IN EFI_SYSTEM_TABLE *SystemTable
757 )
758 {
759 LIST_ENTRY *ParamPackage;
760 CONST CHAR16 *CmdLineArg;
761 EFI_STATUS Status;
762
763 PERFORMANCE_PROPERTY *PerformanceProperty;
764 UINTN Number2Display;
765
766 EFI_STRING StringPtr;
767 BOOLEAN SummaryMode;
768 BOOLEAN VerboseMode;
769 BOOLEAN AllMode;
770 BOOLEAN RawMode;
771 BOOLEAN ExcludeMode;
772 BOOLEAN CumulativeMode;
773 CONST CHAR16 *CustomCumulativeToken;
774 PERF_CUM_DATA *CustomCumulativeData;
775 UINTN NameSize;
776 SHELL_STATUS ShellStatus;
777 TIMER_INFO TimerInfo;
778
779 StringPtr = NULL;
780 SummaryMode = FALSE;
781 VerboseMode = FALSE;
782 AllMode = FALSE;
783 RawMode = FALSE;
784 ExcludeMode = FALSE;
785 CumulativeMode = FALSE;
786 CustomCumulativeData = NULL;
787 ShellStatus = SHELL_SUCCESS;
788
789 //
790 // initialize the shell lib (we must be in non-auto-init...)
791 //
792 Status = ShellInitialize();
793 ASSERT_EFI_ERROR(Status);
794
795 //
796 // Process Command Line arguments
797 //
798 Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);
799 if (EFI_ERROR(Status)) {
800 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_INVALID_ARG), mDpHiiHandle);
801 return SHELL_INVALID_PARAMETER;
802 }
803
804 //
805 // Boolean options
806 //
807 VerboseMode = ShellCommandLineGetFlag (ParamPackage, L"-v");
808 SummaryMode = (BOOLEAN) (ShellCommandLineGetFlag (ParamPackage, L"-S") || ShellCommandLineGetFlag (ParamPackage, L"-s"));
809 AllMode = ShellCommandLineGetFlag (ParamPackage, L"-A");
810 RawMode = ShellCommandLineGetFlag (ParamPackage, L"-R");
811 ExcludeMode = ShellCommandLineGetFlag (ParamPackage, L"-x");
812 mShowId = ShellCommandLineGetFlag (ParamPackage, L"-i");
813 CumulativeMode = ShellCommandLineGetFlag (ParamPackage, L"-c");
814
815 // Options with Values
816 CmdLineArg = ShellCommandLineGetValue (ParamPackage, L"-n");
817 if (CmdLineArg == NULL) {
818 Number2Display = DEFAULT_DISPLAYCOUNT;
819 } else {
820 Number2Display = StrDecimalToUintn(CmdLineArg);
821 if (Number2Display == 0) {
822 Number2Display = MAXIMUM_DISPLAYCOUNT;
823 }
824 }
825
826 CmdLineArg = ShellCommandLineGetValue (ParamPackage, L"-t");
827 if (CmdLineArg == NULL) {
828 mInterestThreshold = DEFAULT_THRESHOLD; // 1ms := 1,000 us
829 } else {
830 mInterestThreshold = StrDecimalToUint64(CmdLineArg);
831 }
832
833
834 //
835 // DP dump performance data by parsing FPDT table in ACPI table.
836 // Folloing 3 steps are to get the measurement form the FPDT table.
837 //
838
839 //
840 //1. Get FPDT from ACPI table.
841 //
842 Status = GetBootPerformanceTable ();
843 if (EFI_ERROR (Status)) {
844 ShellStatus = Status;
845 goto Done;
846 }
847
848 //
849 //2. Cache the ModuleGuid and hanlde mapping table.
850 //
851 Status = BuildCachedGuidHandleTable();
852 if (EFI_ERROR (Status)) {
853 ShellStatus = Status;
854 goto Done;
855 }
856
857 //
858 //3. Build the measurement array form the FPDT records.
859 //
860 Status = BuildMeasurementList ();
861 if (EFI_ERROR (Status)) {
862 ShellStatus = SHELL_OUT_OF_RESOURCES;
863 goto Done;
864 }
865
866 //
867 // Initialize the pre-defined cumulative data.
868 //
869 InitCumulativeData ();
870
871 //
872 // Initialize the Summary data.
873 //
874 InitSummaryData ();
875
876 //
877 // Init the custom cumulative data.
878 //
879 CustomCumulativeToken = ShellCommandLineGetValue (ParamPackage, L"-c");
880 if (CustomCumulativeToken != NULL) {
881 CustomCumulativeData = AllocateZeroPool (sizeof (PERF_CUM_DATA));
882 if (CustomCumulativeData == NULL) {
883 ShellStatus = SHELL_OUT_OF_RESOURCES;
884 goto Done;
885 }
886 CustomCumulativeData->MinDur = PERF_MAXDUR;
887 CustomCumulativeData->MaxDur = 0;
888 CustomCumulativeData->Count = 0;
889 CustomCumulativeData->Duration = 0;
890 NameSize = StrLen (CustomCumulativeToken) + 1;
891 CustomCumulativeData->Name = AllocateZeroPool (NameSize);
892 if (CustomCumulativeData->Name == NULL) {
893 ShellStatus = SHELL_OUT_OF_RESOURCES;
894 goto Done;
895 }
896 UnicodeStrToAsciiStrS (CustomCumulativeToken, CustomCumulativeData->Name, NameSize);
897 }
898
899 //
900 // Timer specific processing
901 //
902 // Get the Performance counter characteristics:
903 // Freq = Frequency in Hz
904 // StartCount = Value loaded into the counter when it starts counting
905 // EndCount = Value counter counts to before it needs to be reset
906 //
907 Status = EfiGetSystemConfigurationTable (&gPerformanceProtocolGuid, (VOID **) &PerformanceProperty);
908 if (EFI_ERROR (Status) || (PerformanceProperty == NULL)) {
909 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PERF_PROPERTY_NOT_FOUND), mDpHiiHandle);
910 goto Done;
911 }
912
913 TimerInfo.Frequency = (UINT32)DivU64x32 (PerformanceProperty->Frequency, 1000);
914 TimerInfo.StartCount = 0;
915 TimerInfo.EndCount = 0xFFFF;
916 TimerInfo.CountUp = TRUE;
917
918 //
919 // Print header
920 //
921 // print DP's build version
922 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_BUILD_REVISION), mDpHiiHandle, DP_MAJOR_VERSION, DP_MINOR_VERSION);
923
924 // print performance timer characteristics
925 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_KHZ), mDpHiiHandle, TimerInfo.Frequency);
926
927 if (VerboseMode && !RawMode) {
928 StringPtr = HiiGetString (mDpHiiHandle,
929 (EFI_STRING_ID) (TimerInfo.CountUp ? STRING_TOKEN (STR_DP_UP) : STRING_TOKEN (STR_DP_DOWN)), NULL);
930 ASSERT (StringPtr != NULL);
931 // Print Timer count range and direction
932 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TIMER_PROPERTIES), mDpHiiHandle,
933 StringPtr,
934 TimerInfo.StartCount,
935 TimerInfo.EndCount
936 );
937 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_VERBOSE_THRESHOLD), mDpHiiHandle, mInterestThreshold);
938 }
939
940 /****************************************************************************
941 **** Print Sections based on command line options
942 ****
943 **** Option modes have the following priority:
944 **** v Verbose -- Valid in combination with any other options
945 **** t Threshold -- Modifies All, Raw, and Cooked output
946 **** Default is 0 for All and Raw mode
947 **** Default is DEFAULT_THRESHOLD for "Cooked" mode
948 **** n Number2Display Used by All and Raw mode. Otherwise ignored.
949 **** A All -- R and S options are ignored
950 **** R Raw -- S option is ignored
951 **** s Summary -- Modifies "Cooked" output only
952 **** Cooked (Default)
953 ****************************************************************************/
954 GatherStatistics (CustomCumulativeData);
955 if (CumulativeMode) {
956 ProcessCumulative (CustomCumulativeData);
957 } else if (AllMode) {
958 Status = DumpAllTrace( Number2Display, ExcludeMode);
959 if (Status == EFI_ABORTED) {
960 ShellStatus = SHELL_ABORTED;
961 goto Done;
962 }
963 } else if (RawMode) {
964 Status = DumpRawTrace( Number2Display, ExcludeMode);
965 if (Status == EFI_ABORTED) {
966 ShellStatus = SHELL_ABORTED;
967 goto Done;
968 }
969 } else {
970 //------------- Begin Cooked Mode Processing
971 ProcessPhases ();
972 if ( ! SummaryMode) {
973 Status = ProcessHandles ( ExcludeMode);
974 if (Status == EFI_ABORTED) {
975 ShellStatus = SHELL_ABORTED;
976 goto Done;
977 }
978
979 Status = ProcessPeims ();
980 if (Status == EFI_ABORTED) {
981 ShellStatus = SHELL_ABORTED;
982 goto Done;
983 }
984
985 Status = ProcessGlobal ();
986 if (Status == EFI_ABORTED) {
987 ShellStatus = SHELL_ABORTED;
988 goto Done;
989 }
990
991 ProcessCumulative (NULL);
992 }
993 } //------------- End of Cooked Mode Processing
994 if ( VerboseMode || SummaryMode) {
995 DumpStatistics();
996 }
997
998 Done:
999 if (ParamPackage != NULL) {
1000 ShellCommandLineFreeVarList (ParamPackage);
1001 }
1002 SHELL_FREE_NON_NULL (StringPtr);
1003 if (CustomCumulativeData != NULL) {
1004 SHELL_FREE_NON_NULL (CustomCumulativeData->Name);
1005 }
1006 SHELL_FREE_NON_NULL (CustomCumulativeData);
1007
1008 SHELL_FREE_NON_NULL (mMeasurementList);
1009
1010 SHELL_FREE_NON_NULL (mCacheHandleGuidTable);
1011
1012 mMeasurementNum = 0;
1013 mCachePairCount = 0;
1014 return ShellStatus;
1015 }
1016
1017
1018 /**
1019 Retrive HII package list from ImageHandle and publish to HII database.
1020
1021 @param ImageHandle The image handle of the process.
1022
1023 @return HII handle.
1024 **/
1025 EFI_HANDLE
1026 InitializeHiiPackage (
1027 EFI_HANDLE ImageHandle
1028 )
1029 {
1030 EFI_STATUS Status;
1031 EFI_HII_PACKAGE_LIST_HEADER *PackageList;
1032 EFI_HANDLE HiiHandle;
1033
1034 //
1035 // Retrieve HII package list from ImageHandle
1036 //
1037 Status = gBS->OpenProtocol (
1038 ImageHandle,
1039 &gEfiHiiPackageListProtocolGuid,
1040 (VOID **)&PackageList,
1041 ImageHandle,
1042 NULL,
1043 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1044 );
1045 ASSERT_EFI_ERROR (Status);
1046 if (EFI_ERROR (Status)) {
1047 return NULL;
1048 }
1049
1050 //
1051 // Publish HII package list to HII Database.
1052 //
1053 Status = gHiiDatabase->NewPackageList (
1054 gHiiDatabase,
1055 PackageList,
1056 NULL,
1057 &HiiHandle
1058 );
1059 ASSERT_EFI_ERROR (Status);
1060 if (EFI_ERROR (Status)) {
1061 return NULL;
1062 }
1063 return HiiHandle;
1064 }