Dp.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago
EFI: First step in UDK2018 merge. Does not build yet.
Property svn:eol-style set to `native`
File size: 32.2 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/ShellPkg/DynamicCommand/DpDynamicCommand/Dp.c@ 77662

Download in other formats: