diff options
| -rw-r--r-- | MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.c | 884 | ||||
| -rw-r--r-- | MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf | 3 |
2 files changed, 725 insertions, 162 deletions
diff --git a/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.c b/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.c index ea2a00b..48d8f46 100644 --- a/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.c +++ b/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.c @@ -1,17 +1,16 @@ /** @file
-
+
Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution. The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
-#include <Base.h>
#include <Uefi.h>
#include <PiDxe.h>
#include <Library/BaseLib.h>
@@ -23,7 +22,6 @@ #include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/DebugLib.h>
#include <Library/DxeServicesLib.h>
-#include <Library/PeCoffGetEntryPointLib.h>
#include <Library/PrintLib.h>
#include <Protocol/SmmCommunication.h>
@@ -33,126 +31,202 @@ #include <Guid/MemoryProfile.h>
#include <Guid/PiSmmCommunicationRegionTable.h>
-CHAR16 *mActionString[] = {
- L"Unknown",
- L"AllocatePages",
- L"FreePages",
- L"AllocatePool",
- L"FreePool",
+CHAR8 *mActionString[] = {
+ "Unknown",
+ "gBS->AllocatePages",
+ "gBS->FreePages",
+ "gBS->AllocatePool",
+ "gBS->FreePool",
+};
+
+CHAR8 *mSmmActionString[] = {
+ "SmmUnknown",
+ "gSmst->SmmAllocatePages",
+ "gSmst->SmmFreePages",
+ "gSmst->SmmAllocatePool",
+ "gSmst->SmmFreePool",
+};
+
+typedef struct {
+ MEMORY_PROFILE_ACTION Action;
+ CHAR8 *String;
+} ACTION_STRING;
+
+ACTION_STRING mExtActionString[] = {
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_PAGES, "Lib:AllocatePages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_PAGES, "Lib:AllocateRuntimePages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_PAGES, "Lib:AllocateReservedPages"},
+ {MEMORY_PROFILE_ACTION_LIB_FREE_PAGES, "Lib:FreePages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_PAGES, "Lib:AllocateAlignedPages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_RUNTIME_PAGES, "Lib:AllocateAlignedRuntimePages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_RESERVED_PAGES, "Lib:AllocateAlignedReservedPages"},
+ {MEMORY_PROFILE_ACTION_LIB_FREE_ALIGNED_PAGES, "Lib:FreeAlignedPages"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_POOL, "Lib:AllocatePool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_POOL, "Lib:AllocateRuntimePool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_POOL, "Lib:AllocateReservedPool"},
+ {MEMORY_PROFILE_ACTION_LIB_FREE_POOL, "Lib:FreePool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ZERO_POOL, "Lib:AllocateZeroPool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_ZERO_POOL, "Lib:AllocateRuntimeZeroPool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_ZERO_POOL, "Lib:AllocateReservedZeroPool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_COPY_POOL, "Lib:AllocateCopyPool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_COPY_POOL, "Lib:AllocateRuntimeCopyPool"},
+ {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_COPY_POOL, "Lib:AllocateReservedCopyPool"},
+ {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_POOL, "Lib:ReallocatePool"},
+ {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_RUNTIME_POOL, "Lib:ReallocateRuntimePool"},
+ {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_RESERVED_POOL, "Lib:ReallocateReservedPool"},
};
-CHAR16 *mMemoryTypeString[] = {
- L"EfiReservedMemoryType",
- L"EfiLoaderCode",
- L"EfiLoaderData",
- L"EfiBootServicesCode",
- L"EfiBootServicesData",
- L"EfiRuntimeServicesCode",
- L"EfiRuntimeServicesData",
- L"EfiConventionalMemory",
- L"EfiUnusableMemory",
- L"EfiACPIReclaimMemory",
- L"EfiACPIMemoryNVS",
- L"EfiMemoryMappedIO",
- L"EfiMemoryMappedIOPortSpace",
- L"EfiPalCode",
- L"EfiPersistentMemory",
- L"EfiOSReserved",
- L"EfiOemReserved",
+CHAR8 mUserDefinedActionString[] = {"UserDefined-0x80000000"};
+
+CHAR8 *mMemoryTypeString[] = {
+ "EfiReservedMemoryType",
+ "EfiLoaderCode",
+ "EfiLoaderData",
+ "EfiBootServicesCode",
+ "EfiBootServicesData",
+ "EfiRuntimeServicesCode",
+ "EfiRuntimeServicesData",
+ "EfiConventionalMemory",
+ "EfiUnusableMemory",
+ "EfiACPIReclaimMemory",
+ "EfiACPIMemoryNVS",
+ "EfiMemoryMappedIO",
+ "EfiMemoryMappedIOPortSpace",
+ "EfiPalCode",
+ "EfiPersistentMemory",
+ "EfiOSReserved",
+ "EfiOemReserved",
};
-CHAR16 *mSubsystemString[] = {
- L"Unknown",
- L"NATIVE",
- L"WINDOWS_GUI",
- L"WINDOWS_CUI",
- L"Unknown",
- L"Unknown",
- L"Unknown",
- L"POSIX_CUI",
- L"Unknown",
- L"WINDOWS_CE_GUI",
- L"EFI_APPLICATION",
- L"EFI_BOOT_SERVICE_DRIVER",
- L"EFI_RUNTIME_DRIVER",
- L"EFI_ROM",
- L"XBOX",
- L"Unknown",
+CHAR8 *mSubsystemString[] = {
+ "Unknown",
+ "NATIVE",
+ "WINDOWS_GUI",
+ "WINDOWS_CUI",
+ "Unknown",
+ "Unknown",
+ "Unknown",
+ "POSIX_CUI",
+ "Unknown",
+ "WINDOWS_CE_GUI",
+ "EFI_APPLICATION",
+ "EFI_BOOT_SERVICE_DRIVER",
+ "EFI_RUNTIME_DRIVER",
+ "EFI_ROM",
+ "XBOX",
+ "Unknown",
};
-CHAR16 *mFileTypeString[] = {
- L"Unknown",
- L"RAW",
- L"FREEFORM",
- L"SECURITY_CORE",
- L"PEI_CORE",
- L"DXE_CORE",
- L"PEIM",
- L"DRIVER",
- L"COMBINED_PEIM_DRIVER",
- L"APPLICATION",
- L"SMM",
- L"FIRMWARE_VOLUME_IMAGE",
- L"COMBINED_SMM_DXE",
- L"SMM_CORE",
+CHAR8 *mFileTypeString[] = {
+ "Unknown",
+ "RAW",
+ "FREEFORM",
+ "SECURITY_CORE",
+ "PEI_CORE",
+ "DXE_CORE",
+ "PEIM",
+ "DRIVER",
+ "COMBINED_PEIM_DRIVER",
+ "APPLICATION",
+ "SMM",
+ "FIRMWARE_VOLUME_IMAGE",
+ "COMBINED_SMM_DXE",
+ "SMM_CORE",
};
-#define PROFILE_NAME_STRING_LENGTH 36
-CHAR16 mNameString[PROFILE_NAME_STRING_LENGTH + 1];
+#define PROFILE_NAME_STRING_LENGTH 64
+CHAR8 mNameString[PROFILE_NAME_STRING_LENGTH + 1];
+
+//
+// Profile summary information
+//
+#define MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE SIGNATURE_32 ('M','P','A','S')
+#define MEMORY_PROFILE_ALLOC_SUMMARY_INFO_REVISION 0x0001
+
+typedef struct {
+ MEMORY_PROFILE_COMMON_HEADER Header;
+ PHYSICAL_ADDRESS CallerAddress;
+ MEMORY_PROFILE_ACTION Action;
+ CHAR8 *ActionString;
+ UINT32 AllocateCount;
+ UINT64 TotalSize;
+} MEMORY_PROFILE_ALLOC_SUMMARY_INFO;
+
+typedef struct {
+ UINT32 Signature;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO AllocSummaryInfo;
+ LIST_ENTRY Link;
+} MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA;
+
+typedef struct {
+ UINT32 Signature;
+ MEMORY_PROFILE_DRIVER_INFO *DriverInfo;
+ LIST_ENTRY *AllocSummaryInfoList;
+ LIST_ENTRY Link;
+} MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA;
+
+typedef struct {
+ UINT32 Signature;
+ MEMORY_PROFILE_CONTEXT *Context;
+ LIST_ENTRY *DriverSummaryInfoList;
+} MEMORY_PROFILE_CONTEXT_SUMMARY_DATA;
-/**
+LIST_ENTRY mImageSummaryQueue = INITIALIZE_LIST_HEAD_VARIABLE (mImageSummaryQueue);
+MEMORY_PROFILE_CONTEXT_SUMMARY_DATA mMemoryProfileContextSummary;
+
+/**
Get the file name portion of the Pdb File Name.
-
+
The portion of the Pdb File Name between the last backslash and
- either a following period or the end of the string is converted
- to Unicode and copied into UnicodeBuffer. The name is truncated,
- if necessary, to ensure that UnicodeBuffer is not overrun.
-
+ either a following period or the end of the string is copied into
+ AsciiBuffer. The name is truncated, if necessary, to ensure that
+ AsciiBuffer is not overrun.
+
@param[in] PdbFileName Pdb file name.
- @param[out] UnicodeBuffer The resultant Unicode File Name.
-
+ @param[out] AsciiBuffer The resultant Ascii File Name.
+
**/
VOID
GetShortPdbFileName (
IN CHAR8 *PdbFileName,
- OUT CHAR16 *UnicodeBuffer
+ OUT CHAR8 *AsciiBuffer
)
{
- UINTN IndexA; // Current work location within an ASCII string.
- UINTN IndexU; // Current work location within a Unicode string.
+ UINTN IndexPdb; // Current work location within a Pdb string.
+ UINTN IndexBuffer; // Current work location within a Buffer string.
UINTN StartIndex;
UINTN EndIndex;
- ZeroMem (UnicodeBuffer, (PROFILE_NAME_STRING_LENGTH + 1) * sizeof (CHAR16));
+ ZeroMem (AsciiBuffer, PROFILE_NAME_STRING_LENGTH + 1);
if (PdbFileName == NULL) {
- StrnCpyS (UnicodeBuffer, PROFILE_NAME_STRING_LENGTH + 1, L" ", 1);
+ AsciiStrnCpyS (AsciiBuffer, PROFILE_NAME_STRING_LENGTH + 1, " ", 1);
} else {
StartIndex = 0;
for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++);
- for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) {
- if (PdbFileName[IndexA] == '\\') {
- StartIndex = IndexA + 1;
+ for (IndexPdb = 0; PdbFileName[IndexPdb] != 0; IndexPdb++) {
+ if (PdbFileName[IndexPdb] == '\\') {
+ StartIndex = IndexPdb + 1;
}
- if (PdbFileName[IndexA] == '.') {
- EndIndex = IndexA;
+ if (PdbFileName[IndexPdb] == '.') {
+ EndIndex = IndexPdb;
}
}
- IndexU = 0;
- for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) {
- UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA];
- IndexU++;
- if (IndexU >= PROFILE_NAME_STRING_LENGTH) {
- UnicodeBuffer[PROFILE_NAME_STRING_LENGTH] = 0;
+ IndexBuffer = 0;
+ for (IndexPdb = StartIndex; IndexPdb < EndIndex; IndexPdb++) {
+ AsciiBuffer[IndexBuffer] = PdbFileName[IndexPdb];
+ IndexBuffer++;
+ if (IndexBuffer >= PROFILE_NAME_STRING_LENGTH) {
+ AsciiBuffer[PROFILE_NAME_STRING_LENGTH] = 0;
break;
}
}
}
}
-/**
+/**
Get a human readable name for an image.
The following methods will be tried orderly:
1. Image PDB
@@ -161,29 +235,24 @@ GetShortPdbFileName ( @param[in] DriverInfo Pointer to memory profile driver info.
- @post The resulting Unicode name string is stored in the mNameString global array.
+ @return The resulting Ascii name string is stored in the mNameString global array.
**/
-VOID
+CHAR8 *
GetDriverNameString (
IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo
)
{
EFI_STATUS Status;
- CHAR8 *PdbFileName;
CHAR16 *NameString;
UINTN StringSize;
//
// Method 1: Get the name string from image PDB
//
- if ((DriverInfo->ImageBase != 0) && (DriverInfo->FileType != EFI_FV_FILETYPE_SMM) && (DriverInfo->FileType != EFI_FV_FILETYPE_SMM_CORE)) {
- PdbFileName = PeCoffLoaderGetPdbPointer ((VOID *) (UINTN) DriverInfo->ImageBase);
-
- if (PdbFileName != NULL) {
- GetShortPdbFileName (PdbFileName, mNameString);
- return;
- }
+ if (DriverInfo->Header.Length > sizeof (MEMORY_PROFILE_DRIVER_INFO)) {
+ GetShortPdbFileName ((CHAR8 *) (DriverInfo + 1), mNameString);
+ return mNameString;
}
if (!CompareGuid (&DriverInfo->FileName, &gZeroGuid)) {
@@ -203,17 +272,20 @@ GetDriverNameString ( //
// Method 2: Get the name string from FFS UI section
//
- StrnCpyS (mNameString, PROFILE_NAME_STRING_LENGTH + 1, NameString, PROFILE_NAME_STRING_LENGTH);
- mNameString[PROFILE_NAME_STRING_LENGTH] = 0;
+ if (StrLen (NameString) > PROFILE_NAME_STRING_LENGTH) {
+ NameString[PROFILE_NAME_STRING_LENGTH] = 0;
+ }
+ UnicodeStrToAsciiStrS (NameString, mNameString, sizeof (mNameString));
FreePool (NameString);
- return;
+ return mNameString;
}
}
//
// Method 3: Get the name string from image GUID
//
- UnicodeSPrint (mNameString, sizeof (mNameString), L"%g", &DriverInfo->FileName);
+ AsciiSPrint (mNameString, sizeof (mNameString), "%g", &DriverInfo->FileName);
+ return mNameString;
}
/**
@@ -224,7 +296,7 @@ GetDriverNameString ( @return Pointer to string.
**/
-CHAR16 *
+CHAR8 *
ProfileMemoryTypeToStr (
IN EFI_MEMORY_TYPE MemoryType
)
@@ -249,11 +321,62 @@ ProfileMemoryTypeToStr ( }
/**
+ Action to string.
+
+ @param[in] Action Profile action.
+ @param[in] UserDefinedActionString Pointer to user defined action string.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
+
+ @return Pointer to string.
+
+**/
+CHAR8 *
+ProfileActionToStr (
+ IN MEMORY_PROFILE_ACTION Action,
+ IN CHAR8 *UserDefinedActionString,
+ IN BOOLEAN IsForSmm
+ )
+{
+ UINTN Index;
+ UINTN ActionStringCount;
+ CHAR8 **ActionString;
+
+ if (IsForSmm) {
+ ActionString = mSmmActionString;
+ ActionStringCount = sizeof (mSmmActionString) / sizeof (mSmmActionString[0]);
+ } else {
+ ActionString = mActionString;
+ ActionStringCount = sizeof (mActionString) / sizeof (mActionString[0]);
+ }
+
+ if ((UINTN) (UINT32) Action < ActionStringCount) {
+ return ActionString[Action];
+ }
+ for (Index = 0; Index < sizeof (mExtActionString) / sizeof (mExtActionString[0]); Index++) {
+ if (mExtActionString[Index].Action == Action) {
+ return mExtActionString[Index].String;
+ }
+ }
+ if ((Action & MEMORY_PROFILE_ACTION_USER_DEFINED_MASK) != 0) {
+ if (UserDefinedActionString != NULL) {
+ return UserDefinedActionString;
+ }
+ AsciiSPrint (mUserDefinedActionString, sizeof (mUserDefinedActionString), "UserDefined-0x%08x", Action);
+ return mUserDefinedActionString;
+ }
+
+ return ActionString[0];
+}
+
+/**
Dump memory profile allocate information.
@param[in] DriverInfo Pointer to memory profile driver info.
@param[in] AllocIndex Memory profile alloc info index.
@param[in] AllocInfo Pointer to memory profile alloc info.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
@return Pointer to next memory profile alloc info.
@@ -262,20 +385,30 @@ MEMORY_PROFILE_ALLOC_INFO * DumpMemoryProfileAllocInfo (
IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo,
IN UINTN AllocIndex,
- IN MEMORY_PROFILE_ALLOC_INFO *AllocInfo
+ IN MEMORY_PROFILE_ALLOC_INFO *AllocInfo,
+ IN BOOLEAN IsForSmm
)
{
+ CHAR8 *ActionString;
+
if (AllocInfo->Header.Signature != MEMORY_PROFILE_ALLOC_INFO_SIGNATURE) {
return NULL;
}
+
+ if (AllocInfo->ActionStringOffset != 0) {
+ ActionString = (CHAR8 *) ((UINTN) AllocInfo + AllocInfo->ActionStringOffset);
+ } else {
+ ActionString = NULL;
+ }
+
Print (L" MEMORY_PROFILE_ALLOC_INFO (0x%x)\n", AllocIndex);
Print (L" Signature - 0x%08x\n", AllocInfo->Header.Signature);
Print (L" Length - 0x%04x\n", AllocInfo->Header.Length);
- Print (L" Revision - 0x%04x\n", AllocInfo->Header.Revision);
+ Print (L" Revision - 0x%04x\n", AllocInfo->Header.Revision);
Print (L" CallerAddress - 0x%016lx (Offset: 0x%08x)\n", AllocInfo->CallerAddress, (UINTN) (AllocInfo->CallerAddress - DriverInfo->ImageBase));
Print (L" SequenceId - 0x%08x\n", AllocInfo->SequenceId);
- Print (L" Action - 0x%08x (%s)\n", AllocInfo->Action, mActionString[(AllocInfo->Action < sizeof(mActionString)/sizeof(mActionString[0])) ? AllocInfo->Action : 0]);
- Print (L" MemoryType - 0x%08x (%s)\n", AllocInfo->MemoryType, ProfileMemoryTypeToStr (AllocInfo->MemoryType));
+ Print (L" Action - 0x%08x (%a)\n", AllocInfo->Action, ProfileActionToStr (AllocInfo->Action, ActionString, IsForSmm));
+ Print (L" MemoryType - 0x%08x (%a)\n", AllocInfo->MemoryType, ProfileMemoryTypeToStr (AllocInfo->MemoryType));
Print (L" Buffer - 0x%016lx\n", AllocInfo->Buffer);
Print (L" Size - 0x%016lx\n", AllocInfo->Size);
@@ -287,6 +420,8 @@ DumpMemoryProfileAllocInfo ( @param[in] DriverIndex Memory profile driver info index.
@param[in] DriverInfo Pointer to memory profile driver info.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
@return Pointer to next memory profile driver info.
@@ -294,12 +429,14 @@ DumpMemoryProfileAllocInfo ( MEMORY_PROFILE_DRIVER_INFO *
DumpMemoryProfileDriverInfo (
IN UINTN DriverIndex,
- IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo
+ IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo,
+ IN BOOLEAN IsForSmm
)
{
UINTN TypeIndex;
MEMORY_PROFILE_ALLOC_INFO *AllocInfo;
UINTN AllocIndex;
+ CHAR8 *NameString;
if (DriverInfo->Header.Signature != MEMORY_PROFILE_DRIVER_INFO_SIGNATURE) {
return NULL;
@@ -307,28 +444,31 @@ DumpMemoryProfileDriverInfo ( Print (L" MEMORY_PROFILE_DRIVER_INFO (0x%x)\n", DriverIndex);
Print (L" Signature - 0x%08x\n", DriverInfo->Header.Signature);
Print (L" Length - 0x%04x\n", DriverInfo->Header.Length);
- Print (L" Revision - 0x%04x\n", DriverInfo->Header.Revision);
- GetDriverNameString (DriverInfo);
- Print (L" FileName - %s\n", &mNameString);
+ Print (L" Revision - 0x%04x\n", DriverInfo->Header.Revision);
+ NameString = GetDriverNameString (DriverInfo);
+ Print (L" FileName - %a\n", NameString);
+ if (DriverInfo->PdbStringOffset != 0) {
+ Print (L" Pdb - %a\n", (CHAR8 *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset));
+ }
Print (L" ImageBase - 0x%016lx\n", DriverInfo->ImageBase);
Print (L" ImageSize - 0x%016lx\n", DriverInfo->ImageSize);
Print (L" EntryPoint - 0x%016lx\n", DriverInfo->EntryPoint);
- Print (L" ImageSubsystem - 0x%04x (%s)\n", DriverInfo->ImageSubsystem, mSubsystemString[(DriverInfo->ImageSubsystem < sizeof(mSubsystemString)/sizeof(mSubsystemString[0])) ? DriverInfo->ImageSubsystem : 0]);
- Print (L" FileType - 0x%02x (%s)\n", DriverInfo->FileType, mFileTypeString[(DriverInfo->FileType < sizeof(mFileTypeString)/sizeof(mFileTypeString[0])) ? DriverInfo->FileType : 0]);
+ Print (L" ImageSubsystem - 0x%04x (%a)\n", DriverInfo->ImageSubsystem, mSubsystemString[(DriverInfo->ImageSubsystem < sizeof(mSubsystemString)/sizeof(mSubsystemString[0])) ? DriverInfo->ImageSubsystem : 0]);
+ Print (L" FileType - 0x%02x (%a)\n", DriverInfo->FileType, mFileTypeString[(DriverInfo->FileType < sizeof(mFileTypeString)/sizeof(mFileTypeString[0])) ? DriverInfo->FileType : 0]);
Print (L" CurrentUsage - 0x%016lx\n", DriverInfo->CurrentUsage);
Print (L" PeakUsage - 0x%016lx\n", DriverInfo->PeakUsage);
for (TypeIndex = 0; TypeIndex < sizeof (DriverInfo->CurrentUsageByType) / sizeof (DriverInfo->CurrentUsageByType[0]); TypeIndex++) {
if ((DriverInfo->CurrentUsageByType[TypeIndex] != 0) ||
(DriverInfo->PeakUsageByType[TypeIndex] != 0)) {
- Print (L" CurrentUsage[0x%02x] - 0x%016lx (%s)\n", TypeIndex, DriverInfo->CurrentUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
- Print (L" PeakUsage[0x%02x] - 0x%016lx (%s)\n", TypeIndex, DriverInfo->PeakUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
+ Print (L" CurrentUsage[0x%02x] - 0x%016lx (%a)\n", TypeIndex, DriverInfo->CurrentUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
+ Print (L" PeakUsage[0x%02x] - 0x%016lx (%a)\n", TypeIndex, DriverInfo->PeakUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
}
}
Print (L" AllocRecordCount - 0x%08x\n", DriverInfo->AllocRecordCount);
AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) DriverInfo + DriverInfo->Header.Length);
for (AllocIndex = 0; AllocIndex < DriverInfo->AllocRecordCount; AllocIndex++) {
- AllocInfo = DumpMemoryProfileAllocInfo (DriverInfo, AllocIndex, AllocInfo);
+ AllocInfo = DumpMemoryProfileAllocInfo (DriverInfo, AllocIndex, AllocInfo, IsForSmm);
if (AllocInfo == NULL) {
return NULL;
}
@@ -340,13 +480,16 @@ DumpMemoryProfileDriverInfo ( Dump memory profile context information.
@param[in] Context Pointer to memory profile context.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
@return Pointer to the end of memory profile context buffer.
**/
VOID *
DumpMemoryProfileContext (
- IN MEMORY_PROFILE_CONTEXT *Context
+ IN MEMORY_PROFILE_CONTEXT *Context,
+ IN BOOLEAN IsForSmm
)
{
UINTN TypeIndex;
@@ -359,14 +502,14 @@ DumpMemoryProfileContext ( Print (L"MEMORY_PROFILE_CONTEXT\n");
Print (L" Signature - 0x%08x\n", Context->Header.Signature);
Print (L" Length - 0x%04x\n", Context->Header.Length);
- Print (L" Revision - 0x%04x\n", Context->Header.Revision);
+ Print (L" Revision - 0x%04x\n", Context->Header.Revision);
Print (L" CurrentTotalUsage - 0x%016lx\n", Context->CurrentTotalUsage);
Print (L" PeakTotalUsage - 0x%016lx\n", Context->PeakTotalUsage);
for (TypeIndex = 0; TypeIndex < sizeof (Context->CurrentTotalUsageByType) / sizeof (Context->CurrentTotalUsageByType[0]); TypeIndex++) {
if ((Context->CurrentTotalUsageByType[TypeIndex] != 0) ||
(Context->PeakTotalUsageByType[TypeIndex] != 0)) {
- Print (L" CurrentTotalUsage[0x%02x] - 0x%016lx (%s)\n", TypeIndex, Context->CurrentTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
- Print (L" PeakTotalUsage[0x%02x] - 0x%016lx (%s)\n", TypeIndex, Context->PeakTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
+ Print (L" CurrentTotalUsage[0x%02x] - 0x%016lx (%a)\n", TypeIndex, Context->CurrentTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
+ Print (L" PeakTotalUsage[0x%02x] - 0x%016lx (%a)\n", TypeIndex, Context->PeakTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);
}
}
Print (L" TotalImageSize - 0x%016lx\n", Context->TotalImageSize);
@@ -375,7 +518,7 @@ DumpMemoryProfileContext ( DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *) ((UINTN) Context + Context->Header.Length);
for (DriverIndex = 0; DriverIndex < Context->ImageCount; DriverIndex++) {
- DriverInfo = DumpMemoryProfileDriverInfo (DriverIndex, DriverInfo);
+ DriverInfo = DumpMemoryProfileDriverInfo (DriverIndex, DriverInfo, IsForSmm);
if (DriverInfo == NULL) {
return NULL;
}
@@ -404,7 +547,7 @@ DumpMemoryProfileDescriptor ( Print (L" MEMORY_PROFILE_DESCRIPTOR (0x%x)\n", DescriptorIndex);
Print (L" Signature - 0x%08x\n", Descriptor->Header.Signature);
Print (L" Length - 0x%04x\n", Descriptor->Header.Length);
- Print (L" Revision - 0x%04x\n", Descriptor->Header.Revision);
+ Print (L" Revision - 0x%04x\n", Descriptor->Header.Revision);
Print (L" Address - 0x%016lx\n", Descriptor->Address);
Print (L" Size - 0x%016lx\n", Descriptor->Size);
@@ -433,7 +576,7 @@ DumpMemoryProfileFreeMemory ( Print (L"MEMORY_PROFILE_FREE_MEMORY\n");
Print (L" Signature - 0x%08x\n", FreeMemory->Header.Signature);
Print (L" Length - 0x%04x\n", FreeMemory->Header.Length);
- Print (L" Revision - 0x%04x\n", FreeMemory->Header.Revision);
+ Print (L" Revision - 0x%04x\n", FreeMemory->Header.Revision);
Print (L" TotalFreeMemoryPages - 0x%016lx\n", FreeMemory->TotalFreeMemoryPages);
Print (L" FreeMemoryEntryCount - 0x%08x\n", FreeMemory->FreeMemoryEntryCount);
@@ -470,7 +613,7 @@ DumpMemoryProfileMemoryRange ( Print (L"MEMORY_PROFILE_MEMORY_RANGE\n");
Print (L" Signature - 0x%08x\n", MemoryRange->Header.Signature);
Print (L" Length - 0x%04x\n", MemoryRange->Header.Length);
- Print (L" Revision - 0x%04x\n", MemoryRange->Header.Revision);
+ Print (L" Revision - 0x%04x\n", MemoryRange->Header.Revision);
Print (L" MemoryRangeCount - 0x%08x\n", MemoryRange->MemoryRangeCount);
Descriptor = (MEMORY_PROFILE_DESCRIPTOR *) ((UINTN) MemoryRange + MemoryRange->Header.Length);
@@ -513,6 +656,10 @@ ScanMemoryProfileBySignature ( //
return (VOID *) CommonHeader;
}
+ if (CommonHeader->Length == 0) {
+ ASSERT (FALSE);
+ return NULL;
+ }
CommonHeader = (MEMORY_PROFILE_COMMON_HEADER *) ((UINTN) CommonHeader + CommonHeader->Length);
}
@@ -524,12 +671,15 @@ ScanMemoryProfileBySignature ( @param[in] ProfileBuffer Memory profile base address.
@param[in] ProfileSize Memory profile size.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
**/
VOID
DumpMemoryProfile (
IN PHYSICAL_ADDRESS ProfileBuffer,
- IN UINT64 ProfileSize
+ IN UINT64 ProfileSize,
+ IN BOOLEAN IsForSmm
)
{
MEMORY_PROFILE_CONTEXT *Context;
@@ -538,7 +688,7 @@ DumpMemoryProfile ( Context = (MEMORY_PROFILE_CONTEXT *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_CONTEXT_SIGNATURE);
if (Context != NULL) {
- DumpMemoryProfileContext (Context);
+ DumpMemoryProfileContext (Context, IsForSmm);
}
FreeMemory = (MEMORY_PROFILE_FREE_MEMORY *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_FREE_MEMORY_SIGNATURE);
@@ -553,6 +703,317 @@ DumpMemoryProfile ( }
/**
+ Get Allocate summary information structure by caller address.
+
+ @param[in] CallerAddress Caller address.
+ @param[in] DriverSummaryInfoData Driver summary information data structure.
+
+ @return Allocate summary information structure by caller address.
+
+**/
+MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *
+GetAllocSummaryInfoByCallerAddress (
+ IN PHYSICAL_ADDRESS CallerAddress,
+ IN MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA *DriverSummaryInfoData
+ )
+{
+ LIST_ENTRY *AllocSummaryInfoList;
+ LIST_ENTRY *AllocSummaryLink;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO *AllocSummaryInfo;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *AllocSummaryInfoData;
+
+ AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;
+
+ for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;
+ AllocSummaryLink != AllocSummaryInfoList;
+ AllocSummaryLink = AllocSummaryLink->ForwardLink) {
+ AllocSummaryInfoData = CR (
+ AllocSummaryLink,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,
+ Link,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE
+ );
+ AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;
+ if (AllocSummaryInfo->CallerAddress == CallerAddress) {
+ return AllocSummaryInfoData;
+ }
+ }
+ return NULL;
+}
+
+/**
+ Create Allocate summary information structure and
+ link to Driver summary information data structure.
+
+ @param[in, out] DriverSummaryInfoData Driver summary information data structure.
+ @param[in] AllocInfo Pointer to memory profile alloc info.
+
+ @return Pointer to next memory profile alloc info.
+
+**/
+MEMORY_PROFILE_ALLOC_INFO *
+CreateAllocSummaryInfo (
+ IN OUT MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA *DriverSummaryInfoData,
+ IN MEMORY_PROFILE_ALLOC_INFO *AllocInfo
+ )
+{
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *AllocSummaryInfoData;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO *AllocSummaryInfo;
+
+ if (AllocInfo->Header.Signature != MEMORY_PROFILE_ALLOC_INFO_SIGNATURE) {
+ return NULL;
+ }
+
+ AllocSummaryInfoData = GetAllocSummaryInfoByCallerAddress (AllocInfo->CallerAddress, DriverSummaryInfoData);
+ if (AllocSummaryInfoData == NULL) {
+ AllocSummaryInfoData = AllocatePool (sizeof (*AllocSummaryInfoData));
+ if (AllocSummaryInfoData == NULL) {
+ return NULL;
+ }
+
+ AllocSummaryInfoData->Signature = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE;
+ AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;
+ AllocSummaryInfo->Header.Signature = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE;
+ AllocSummaryInfo->Header.Length = sizeof (*AllocSummaryInfo);
+ AllocSummaryInfo->Header.Revision = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_REVISION;
+ AllocSummaryInfo->CallerAddress = AllocInfo->CallerAddress;
+ AllocSummaryInfo->Action = AllocInfo->Action;
+ if (AllocInfo->ActionStringOffset != 0) {
+ AllocSummaryInfo->ActionString = (CHAR8 *) ((UINTN) AllocInfo + AllocInfo->ActionStringOffset);
+ } else {
+ AllocSummaryInfo->ActionString = NULL;
+ }
+ AllocSummaryInfo->AllocateCount = 0;
+ AllocSummaryInfo->TotalSize = 0;
+ InsertTailList (DriverSummaryInfoData->AllocSummaryInfoList, &AllocSummaryInfoData->Link);
+ }
+ AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;
+ AllocSummaryInfo->AllocateCount ++;
+ AllocSummaryInfo->TotalSize += AllocInfo->Size;
+
+ return (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) AllocInfo + AllocInfo->Header.Length);
+}
+
+/**
+ Create Driver summary information structure and
+ link to Context summary information data structure.
+
+ @param[in, out] ContextSummaryData Context summary information data structure.
+ @param[in] DriverInfo Pointer to memory profile driver info.
+
+ @return Pointer to next memory profile driver info.
+
+**/
+MEMORY_PROFILE_DRIVER_INFO *
+CreateDriverSummaryInfo (
+ IN OUT MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *ContextSummaryData,
+ IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo
+ )
+{
+ MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA *DriverSummaryInfoData;
+ MEMORY_PROFILE_ALLOC_INFO *AllocInfo;
+ UINTN AllocIndex;
+
+ if (DriverInfo->Header.Signature != MEMORY_PROFILE_DRIVER_INFO_SIGNATURE) {
+ return NULL;
+ }
+
+ DriverSummaryInfoData = AllocatePool (sizeof (*DriverSummaryInfoData) + sizeof (LIST_ENTRY));
+ if (DriverSummaryInfoData == NULL) {
+ return NULL;
+ }
+ DriverSummaryInfoData->Signature = MEMORY_PROFILE_DRIVER_INFO_SIGNATURE;
+ DriverSummaryInfoData->DriverInfo = DriverInfo;
+ DriverSummaryInfoData->AllocSummaryInfoList = (LIST_ENTRY *) (DriverSummaryInfoData + 1);
+ InitializeListHead (DriverSummaryInfoData->AllocSummaryInfoList);
+ InsertTailList (ContextSummaryData->DriverSummaryInfoList, &DriverSummaryInfoData->Link);
+
+ AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) DriverInfo + DriverInfo->Header.Length);
+ for (AllocIndex = 0; AllocIndex < DriverInfo->AllocRecordCount; AllocIndex++) {
+ AllocInfo = CreateAllocSummaryInfo (DriverSummaryInfoData, AllocInfo);
+ if (AllocInfo == NULL) {
+ return NULL;
+ }
+ }
+ return (MEMORY_PROFILE_DRIVER_INFO *) AllocInfo;
+}
+
+/**
+ Create Context summary information structure.
+
+ @param[in] ProfileBuffer Memory profile base address.
+ @param[in] ProfileSize Memory profile size.
+
+ @return Context summary information structure.
+
+**/
+MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *
+CreateContextSummaryData (
+ IN PHYSICAL_ADDRESS ProfileBuffer,
+ IN UINT64 ProfileSize
+ )
+{
+ MEMORY_PROFILE_CONTEXT *Context;
+ MEMORY_PROFILE_DRIVER_INFO *DriverInfo;
+ UINTN DriverIndex;
+
+ Context = (MEMORY_PROFILE_CONTEXT *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_CONTEXT_SIGNATURE);
+ if (Context == NULL) {
+ return NULL;
+ }
+
+ mMemoryProfileContextSummary.Signature = MEMORY_PROFILE_CONTEXT_SIGNATURE;
+ mMemoryProfileContextSummary.Context = Context;
+ mMemoryProfileContextSummary.DriverSummaryInfoList = &mImageSummaryQueue;
+
+ DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *) ((UINTN) Context + Context->Header.Length);
+ for (DriverIndex = 0; DriverIndex < Context->ImageCount; DriverIndex++) {
+ DriverInfo = CreateDriverSummaryInfo (&mMemoryProfileContextSummary, DriverInfo);
+ if (DriverInfo == NULL) {
+ return NULL;
+ }
+ }
+
+ return &mMemoryProfileContextSummary;
+}
+
+/**
+ Dump Context summary information.
+
+ @param[in] ContextSummaryData Context summary information data.
+ @param[in] IsForSmm TRUE - SMRAM profile.
+ FALSE - UEFI memory profile.
+
+**/
+VOID
+DumpContextSummaryData (
+ IN MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *ContextSummaryData,
+ IN BOOLEAN IsForSmm
+ )
+{
+ MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA *DriverSummaryInfoData;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *AllocSummaryInfoData;
+ LIST_ENTRY *DriverSummaryInfoList;
+ LIST_ENTRY *DriverSummaryLink;
+ LIST_ENTRY *AllocSummaryInfoList;
+ LIST_ENTRY *AllocSummaryLink;
+ MEMORY_PROFILE_DRIVER_INFO *DriverInfo;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO *AllocSummaryInfo;
+ CHAR8 *NameString;
+
+ if (ContextSummaryData == NULL) {
+ return ;
+ }
+
+ Print (L"\nSummary Data:\n");
+
+ DriverSummaryInfoList = ContextSummaryData->DriverSummaryInfoList;
+ for (DriverSummaryLink = DriverSummaryInfoList->ForwardLink;
+ DriverSummaryLink != DriverSummaryInfoList;
+ DriverSummaryLink = DriverSummaryLink->ForwardLink) {
+ DriverSummaryInfoData = CR (
+ DriverSummaryLink,
+ MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA,
+ Link,
+ MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
+ );
+ DriverInfo = DriverSummaryInfoData->DriverInfo;
+
+ NameString = GetDriverNameString (DriverInfo);
+ Print (L"\nDriver - %a (Usage - 0x%08x)", NameString, DriverInfo->CurrentUsage);
+ if (DriverInfo->CurrentUsage == 0) {
+ Print (L"\n");
+ continue;
+ }
+
+ if (DriverInfo->PdbStringOffset != 0) {
+ Print (L" (Pdb - %a)\n", (CHAR8 *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset));
+ } else {
+ Print (L"\n");
+ }
+ Print (L"Caller List:\n");
+ Print(L" Count Size RVA Action\n");
+ Print(L"========== ================== ================== (================================)\n");
+ AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;
+ for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;
+ AllocSummaryLink != AllocSummaryInfoList;
+ AllocSummaryLink = AllocSummaryLink->ForwardLink) {
+ AllocSummaryInfoData = CR (
+ AllocSummaryLink,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,
+ Link,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE
+ );
+ AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;
+
+ Print(L"0x%08x 0x%016lx <== 0x%016lx",
+ AllocSummaryInfo->AllocateCount,
+ AllocSummaryInfo->TotalSize,
+ AllocSummaryInfo->CallerAddress - DriverInfo->ImageBase
+ );
+ Print (L" (%a)\n", ProfileActionToStr (AllocSummaryInfo->Action, AllocSummaryInfo->ActionString, IsForSmm));
+ }
+ }
+ return ;
+}
+
+/**
+ Destroy Context summary information.
+
+ @param[in, out] ContextSummaryData Context summary information data.
+
+**/
+VOID
+DestroyContextSummaryData (
+ IN OUT MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *ContextSummaryData
+ )
+{
+ MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA *DriverSummaryInfoData;
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *AllocSummaryInfoData;
+ LIST_ENTRY *DriverSummaryInfoList;
+ LIST_ENTRY *DriverSummaryLink;
+ LIST_ENTRY *AllocSummaryInfoList;
+ LIST_ENTRY *AllocSummaryLink;
+
+ if (ContextSummaryData == NULL) {
+ return ;
+ }
+
+ DriverSummaryInfoList = ContextSummaryData->DriverSummaryInfoList;
+ for (DriverSummaryLink = DriverSummaryInfoList->ForwardLink;
+ DriverSummaryLink != DriverSummaryInfoList;
+ ) {
+ DriverSummaryInfoData = CR (
+ DriverSummaryLink,
+ MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA,
+ Link,
+ MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
+ );
+ DriverSummaryLink = DriverSummaryLink->ForwardLink;
+
+ AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;
+ for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;
+ AllocSummaryLink != AllocSummaryInfoList;
+ ) {
+ AllocSummaryInfoData = CR (
+ AllocSummaryLink,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,
+ Link,
+ MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE
+ );
+ AllocSummaryLink = AllocSummaryLink->ForwardLink;
+
+ RemoveEntryList (&AllocSummaryInfoData->Link);
+ FreePool (AllocSummaryInfoData);
+ }
+
+ RemoveEntryList (&DriverSummaryInfoData->Link);
+ FreePool (DriverSummaryInfoData);
+ }
+ return ;
+}
+
+/**
Get and dump UEFI memory profile data.
@return EFI_SUCCESS Get the memory profile data successfully.
@@ -564,10 +1025,12 @@ GetUefiMemoryProfileData ( VOID
)
{
- EFI_STATUS Status;
- EDKII_MEMORY_PROFILE_PROTOCOL *ProfileProtocol;
- VOID *Data;
- UINT64 Size;
+ EFI_STATUS Status;
+ EDKII_MEMORY_PROFILE_PROTOCOL *ProfileProtocol;
+ VOID *Data;
+ UINT64 Size;
+ MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *MemoryProfileContextSummaryData;
+ BOOLEAN RecordingState;
Status = gBS->LocateProtocol (&gEdkiiMemoryProfileGuid, NULL, (VOID **) &ProfileProtocol);
if (EFI_ERROR (Status)) {
@@ -575,6 +1038,15 @@ GetUefiMemoryProfileData ( return Status;
}
+ //
+ // Set recording state if needed.
+ //
+ RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;
+ Status = ProfileProtocol->GetRecordingState (ProfileProtocol, &RecordingState);
+ if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {
+ ProfileProtocol->SetRecordingState (ProfileProtocol, MEMORY_PROFILE_RECORDING_DISABLE);
+ }
+
Size = 0;
Data = NULL;
Status = ProfileProtocol->GetData (
@@ -584,13 +1056,9 @@ GetUefiMemoryProfileData ( );
if (Status != EFI_BUFFER_TOO_SMALL) {
Print (L"UefiMemoryProfile: GetData - %r\n", Status);
- return Status;
+ goto Done;
}
- //
- // Add one sizeof (MEMORY_PROFILE_ALLOC_INFO) to Size for this AllocatePool action.
- //
- Size = Size + sizeof (MEMORY_PROFILE_ALLOC_INFO);
Data = AllocateZeroPool ((UINTN) Size);
if (Data == NULL) {
Status = EFI_OUT_OF_RESOURCES;
@@ -604,20 +1072,39 @@ GetUefiMemoryProfileData ( Data
);
if (EFI_ERROR (Status)) {
- FreePool (Data);
Print (L"UefiMemoryProfile: GetData - %r\n", Status);
- return Status;
+ goto Done;
}
Print (L"UefiMemoryProfileSize - 0x%x\n", Size);
Print (L"======= UefiMemoryProfile begin =======\n");
- DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) Data, Size);
+ DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) Data, Size, FALSE);
+
+ //
+ // Dump summary information
+ //
+ MemoryProfileContextSummaryData = CreateContextSummaryData ((PHYSICAL_ADDRESS) (UINTN) Data, Size);
+ if (MemoryProfileContextSummaryData != NULL) {
+ DumpContextSummaryData (MemoryProfileContextSummaryData, FALSE);
+ DestroyContextSummaryData (MemoryProfileContextSummaryData);
+ }
+
Print (L"======= UefiMemoryProfile end =======\n\n\n");
- FreePool (Data);
+Done:
+ if (Data != NULL) {
+ FreePool (Data);
+ }
- return EFI_SUCCESS;
+ //
+ // Restore recording state if needed.
+ //
+ if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {
+ ProfileProtocol->SetRecordingState (ProfileProtocol, MEMORY_PROFILE_RECORDING_ENABLE);
+ }
+
+ return Status;
}
/**
@@ -638,6 +1125,7 @@ GetSmramProfileData ( EFI_SMM_COMMUNICATE_HEADER *CommHeader;
SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO *CommGetProfileInfo;
SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET *CommGetProfileData;
+ SMRAM_PROFILE_PARAMETER_RECORDING_STATE *CommRecordingState;
UINTN ProfileSize;
VOID *ProfileBuffer;
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
@@ -648,6 +1136,10 @@ GetSmramProfileData ( VOID *Buffer;
UINTN Size;
UINTN Offset;
+ MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *MemoryProfileContextSummaryData;
+ BOOLEAN RecordingState;
+
+ ProfileBuffer = NULL;
Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &SmmCommunication);
if (EFI_ERROR (Status)) {
@@ -658,7 +1150,8 @@ GetSmramProfileData ( MinimalSizeNeeded = sizeof (EFI_GUID) +
sizeof (UINTN) +
MAX (sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO),
- sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET));
+ MAX (sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET),
+ sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE)));
MinimalSizeNeeded += MAX (sizeof (MEMORY_PROFILE_CONTEXT),
MAX (sizeof (MEMORY_PROFILE_DRIVER_INFO),
MAX (sizeof (MEMORY_PROFILE_ALLOC_INFO),
@@ -690,6 +1183,48 @@ GetSmramProfileData ( CommBuffer = (UINT8 *) (UINTN) Entry->PhysicalStart;
//
+ // Set recording state if needed.
+ //
+ RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;
+
+ CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];
+ CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));
+ CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);
+
+ CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
+ CommRecordingState->Header.Command = SMRAM_PROFILE_COMMAND_GET_RECORDING_STATE;
+ CommRecordingState->Header.DataLength = sizeof (*CommRecordingState);
+ CommRecordingState->Header.ReturnStatus = (UINT64)-1;
+ CommRecordingState->RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;
+
+ CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;
+ Status = SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((EFI_D_ERROR, "SmramProfile: SmmCommunication - %r\n", Status));
+ return Status;
+ }
+
+ if (CommRecordingState->Header.ReturnStatus != 0) {
+ Print (L"SmramProfile: GetRecordingState - 0x%0x\n", CommRecordingState->Header.ReturnStatus);
+ return EFI_SUCCESS;
+ }
+ RecordingState = CommRecordingState->RecordingState;
+ if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {
+ CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];
+ CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));
+ CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);
+
+ CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
+ CommRecordingState->Header.Command = SMRAM_PROFILE_COMMAND_SET_RECORDING_STATE;
+ CommRecordingState->Header.DataLength = sizeof (*CommRecordingState);
+ CommRecordingState->Header.ReturnStatus = (UINT64)-1;
+ CommRecordingState->RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;
+
+ CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;
+ SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);
+ }
+
+ //
// Get Size
//
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];
@@ -704,14 +1239,12 @@ GetSmramProfileData ( CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;
Status = SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);
- if (EFI_ERROR (Status)) {
- DEBUG ((EFI_D_ERROR, "SmramProfile: SmmCommunication - %r\n", Status));
- return Status;
- }
+ ASSERT_EFI_ERROR (Status);
if (CommGetProfileInfo->Header.ReturnStatus != 0) {
+ Status = EFI_SUCCESS;
Print (L"SmramProfile: GetProfileInfo - 0x%0x\n", CommGetProfileInfo->Header.ReturnStatus);
- return EFI_SUCCESS;
+ goto Done;
}
ProfileSize = (UINTN) CommGetProfileInfo->ProfileSize;
@@ -720,10 +1253,10 @@ GetSmramProfileData ( // Get Data
//
ProfileBuffer = AllocateZeroPool (ProfileSize);
- if (ProfileBuffer == 0) {
+ if (ProfileBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
Print (L"SmramProfile: AllocateZeroPool (0x%x) for profile buffer - %r\n", ProfileSize, Status);
- return Status;
+ goto Done;
}
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];
@@ -752,9 +1285,9 @@ GetSmramProfileData ( ASSERT_EFI_ERROR (Status);
if (CommGetProfileData->Header.ReturnStatus != 0) {
- FreePool (ProfileBuffer);
+ Status = EFI_SUCCESS;
Print (L"GetProfileData - 0x%x\n", CommGetProfileData->Header.ReturnStatus);
- return EFI_SUCCESS;
+ goto Done;
}
CopyMem ((UINT8 *) ProfileBuffer + Offset, (VOID *) (UINTN) CommGetProfileData->ProfileBuffer, (UINTN) CommGetProfileData->ProfileSize);
}
@@ -762,21 +1295,52 @@ GetSmramProfileData ( Print (L"SmramProfileSize - 0x%x\n", ProfileSize);
Print (L"======= SmramProfile begin =======\n");
- DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) ProfileBuffer, ProfileSize);
+ DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) ProfileBuffer, ProfileSize, TRUE);
+
+ //
+ // Dump summary information
+ //
+ MemoryProfileContextSummaryData = CreateContextSummaryData ((PHYSICAL_ADDRESS) (UINTN) ProfileBuffer, ProfileSize);
+ if (MemoryProfileContextSummaryData != NULL) {
+ DumpContextSummaryData (MemoryProfileContextSummaryData, TRUE);
+ DestroyContextSummaryData (MemoryProfileContextSummaryData);
+ }
+
Print (L"======= SmramProfile end =======\n\n\n");
- FreePool (ProfileBuffer);
+Done:
+ if (ProfileBuffer != NULL) {
+ FreePool (ProfileBuffer);
+ }
- return EFI_SUCCESS;
+ //
+ // Restore recording state if needed.
+ //
+ if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {
+ CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];
+ CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));
+ CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);
+
+ CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
+ CommRecordingState->Header.Command = SMRAM_PROFILE_COMMAND_SET_RECORDING_STATE;
+ CommRecordingState->Header.DataLength = sizeof (*CommRecordingState);
+ CommRecordingState->Header.ReturnStatus = (UINT64)-1;
+ CommRecordingState->RecordingState = MEMORY_PROFILE_RECORDING_ENABLE;
+
+ CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;
+ SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);
+ }
+
+ return Status;
}
/**
The user Entry Point for Application. The user code starts with this function
as the real entry point for the image goes into a library that calls this function.
- @param[in] ImageHandle The firmware allocated handle for the EFI image.
+ @param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
-
+
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
@@ -788,7 +1352,7 @@ UefiMain ( IN EFI_SYSTEM_TABLE *SystemTable
)
{
- EFI_STATUS Status;
+ EFI_STATUS Status;
Status = GetUefiMemoryProfileData ();
if (EFI_ERROR (Status)) {
diff --git a/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf b/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf index a1bc675..c512a3f 100644 --- a/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf +++ b/MdeModulePkg/Application/MemoryProfileInfo/MemoryProfileInfo.inf @@ -46,9 +46,8 @@ UefiLib
MemoryAllocationLib
DxeServicesLib
- PeCoffGetEntryPointLib
PrintLib
-
+
[Guids]
## SOMETIMES_CONSUMES ## GUID # Locate protocol
## SOMETIMES_CONSUMES ## GUID # SmiHandlerRegister
|