[mirror_edk2.git] / MdeModulePkg / Application / MemoryProfileInfo / MemoryProfileInfo.c

/** @file\r
\r
  Copyright (c) 2014 - 2017, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Uefi.h>\r
#include <PiDxe.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/UefiApplicationEntryPoint.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiRuntimeServicesTableLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/DxeServicesLib.h>\r
#include <Library/PrintLib.h>\r
\r
#include <Protocol/SmmCommunication.h>\r
#include <Protocol/SmmAccess2.h>\r
\r
#include <Guid/MemoryProfile.h>\r
#include <Guid/PiSmmCommunicationRegionTable.h>\r
\r
CHAR8 *mActionString[] = {\r
  "Unknown",\r
  "gBS->AllocatePages",\r
  "gBS->FreePages",\r
  "gBS->AllocatePool",\r
  "gBS->FreePool",\r
};\r
\r
CHAR8 *mSmmActionString[] = {\r
  "SmmUnknown",\r
  "gSmst->SmmAllocatePages",\r
  "gSmst->SmmFreePages",\r
  "gSmst->SmmAllocatePool",\r
  "gSmst->SmmFreePool",\r
};\r
\r
typedef struct {\r
  MEMORY_PROFILE_ACTION  Action;\r
  CHAR8                 *String;\r
} ACTION_STRING;\r
\r
ACTION_STRING mExtActionString[] = {\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_PAGES,                    "Lib:AllocatePages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_PAGES,            "Lib:AllocateRuntimePages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_PAGES,           "Lib:AllocateReservedPages"},\r
  {MEMORY_PROFILE_ACTION_LIB_FREE_PAGES,                        "Lib:FreePages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_PAGES,            "Lib:AllocateAlignedPages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_RUNTIME_PAGES,    "Lib:AllocateAlignedRuntimePages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ALIGNED_RESERVED_PAGES,   "Lib:AllocateAlignedReservedPages"},\r
  {MEMORY_PROFILE_ACTION_LIB_FREE_ALIGNED_PAGES,                "Lib:FreeAlignedPages"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_POOL,                     "Lib:AllocatePool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_POOL,             "Lib:AllocateRuntimePool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_POOL,            "Lib:AllocateReservedPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_FREE_POOL,                         "Lib:FreePool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_ZERO_POOL,                "Lib:AllocateZeroPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_ZERO_POOL,        "Lib:AllocateRuntimeZeroPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_ZERO_POOL,       "Lib:AllocateReservedZeroPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_COPY_POOL,                "Lib:AllocateCopyPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RUNTIME_COPY_POOL,        "Lib:AllocateRuntimeCopyPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_ALLOCATE_RESERVED_COPY_POOL,       "Lib:AllocateReservedCopyPool"},\r
  {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_POOL,                   "Lib:ReallocatePool"},\r
  {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_RUNTIME_POOL,           "Lib:ReallocateRuntimePool"},\r
  {MEMORY_PROFILE_ACTION_LIB_REALLOCATE_RESERVED_POOL,          "Lib:ReallocateReservedPool"},\r
};\r
\r
CHAR8 mUserDefinedActionString[] = {"UserDefined-0x80000000"};\r
\r
CHAR8 *mMemoryTypeString[] = {\r
  "EfiReservedMemoryType",\r
  "EfiLoaderCode",\r
  "EfiLoaderData",\r
  "EfiBootServicesCode",\r
  "EfiBootServicesData",\r
  "EfiRuntimeServicesCode",\r
  "EfiRuntimeServicesData",\r
  "EfiConventionalMemory",\r
  "EfiUnusableMemory",\r
  "EfiACPIReclaimMemory",\r
  "EfiACPIMemoryNVS",\r
  "EfiMemoryMappedIO",\r
  "EfiMemoryMappedIOPortSpace",\r
  "EfiPalCode",\r
  "EfiPersistentMemory",\r
  "EfiOSReserved",\r
  "EfiOemReserved",\r
};\r
\r
CHAR8 *mSubsystemString[] = {\r
  "Unknown",\r
  "NATIVE",\r
  "WINDOWS_GUI",\r
  "WINDOWS_CUI",\r
  "Unknown",\r
  "Unknown",\r
  "Unknown",\r
  "POSIX_CUI",\r
  "Unknown",\r
  "WINDOWS_CE_GUI",\r
  "EFI_APPLICATION",\r
  "EFI_BOOT_SERVICE_DRIVER",\r
  "EFI_RUNTIME_DRIVER",\r
  "EFI_ROM",\r
  "XBOX",\r
  "Unknown",\r
};\r
\r
CHAR8 *mFileTypeString[] = {\r
  "Unknown",\r
  "RAW",\r
  "FREEFORM",\r
  "SECURITY_CORE",\r
  "PEI_CORE",\r
  "DXE_CORE",\r
  "PEIM",\r
  "DRIVER",\r
  "COMBINED_PEIM_DRIVER",\r
  "APPLICATION",\r
  "SMM",\r
  "FIRMWARE_VOLUME_IMAGE",\r
  "COMBINED_SMM_DXE",\r
  "SMM_CORE",\r
};\r
\r
#define PROFILE_NAME_STRING_LENGTH  64\r
CHAR8 mNameString[PROFILE_NAME_STRING_LENGTH + 1];\r
\r
//\r
// Profile summary information\r
//\r
#define MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE SIGNATURE_32 ('M','P','A','S')\r
#define MEMORY_PROFILE_ALLOC_SUMMARY_INFO_REVISION 0x0001\r
\r
typedef struct {\r
  MEMORY_PROFILE_COMMON_HEADER  Header;\r
  PHYSICAL_ADDRESS              CallerAddress;\r
  MEMORY_PROFILE_ACTION         Action;\r
  CHAR8                         *ActionString;\r
  UINT32                        AllocateCount;\r
  UINT64                        TotalSize;\r
} MEMORY_PROFILE_ALLOC_SUMMARY_INFO;\r
\r
typedef struct {\r
  UINT32                            Signature;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO AllocSummaryInfo;\r
  LIST_ENTRY                        Link;\r
} MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA;\r
\r
typedef struct {\r
  UINT32                        Signature;\r
  MEMORY_PROFILE_DRIVER_INFO    *DriverInfo;\r
  LIST_ENTRY                    *AllocSummaryInfoList;\r
  LIST_ENTRY                    Link;\r
} MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA;\r
\r
typedef struct {\r
  UINT32                        Signature;\r
  MEMORY_PROFILE_CONTEXT        *Context;\r
  LIST_ENTRY                    *DriverSummaryInfoList;\r
} MEMORY_PROFILE_CONTEXT_SUMMARY_DATA;\r
\r
LIST_ENTRY  mImageSummaryQueue = INITIALIZE_LIST_HEAD_VARIABLE (mImageSummaryQueue);\r
MEMORY_PROFILE_CONTEXT_SUMMARY_DATA mMemoryProfileContextSummary;\r
\r
/**\r
  Get the file name portion of the Pdb File Name.\r
\r
  The portion of the Pdb File Name between the last backslash and\r
  either a following period or the end of the string is copied into\r
  AsciiBuffer.  The name is truncated, if necessary, to ensure that\r
  AsciiBuffer is not overrun.\r
\r
  @param[in]  PdbFileName     Pdb file name.\r
  @param[out] AsciiBuffer     The resultant Ascii File Name.\r
\r
**/\r
VOID\r
GetShortPdbFileName (\r
  IN  CHAR8     *PdbFileName,\r
  OUT CHAR8     *AsciiBuffer\r
  )\r
{\r
  UINTN IndexPdb;     // Current work location within a Pdb string.\r
  UINTN IndexBuffer;  // Current work location within a Buffer string.\r
  UINTN StartIndex;\r
  UINTN EndIndex;\r
\r
  ZeroMem (AsciiBuffer, PROFILE_NAME_STRING_LENGTH + 1);\r
\r
  if (PdbFileName == NULL) {\r
    AsciiStrnCpyS (AsciiBuffer, PROFILE_NAME_STRING_LENGTH + 1, " ", 1);\r
  } else {\r
    StartIndex = 0;\r
    for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++);\r
    for (IndexPdb = 0; PdbFileName[IndexPdb] != 0; IndexPdb++) {\r
      if ((PdbFileName[IndexPdb] == '\\') || (PdbFileName[IndexPdb] == '/')) {\r
        StartIndex = IndexPdb + 1;\r
      }\r
\r
      if (PdbFileName[IndexPdb] == '.') {\r
        EndIndex = IndexPdb;\r
      }\r
    }\r
\r
    IndexBuffer = 0;\r
    for (IndexPdb = StartIndex; IndexPdb < EndIndex; IndexPdb++) {\r
      AsciiBuffer[IndexBuffer] = PdbFileName[IndexPdb];\r
      IndexBuffer++;\r
      if (IndexBuffer >= PROFILE_NAME_STRING_LENGTH) {\r
        AsciiBuffer[PROFILE_NAME_STRING_LENGTH] = 0;\r
        break;\r
      }\r
    }\r
  }\r
}\r
\r
/**\r
  Get a human readable name for an image.\r
  The following methods will be tried orderly:\r
    1. Image PDB\r
    2. FFS UI section\r
    3. Image GUID\r
\r
  @param[in] DriverInfo Pointer to memory profile driver info.\r
\r
  @return The resulting Ascii name string is stored in the mNameString global array.\r
\r
**/\r
CHAR8 *\r
GetDriverNameString (\r
 IN MEMORY_PROFILE_DRIVER_INFO  *DriverInfo\r
 )\r
{\r
  EFI_STATUS                  Status;\r
  CHAR16                      *NameString;\r
  UINTN                       StringSize;\r
\r
  //\r
  // Method 1: Get the name string from image PDB\r
  //\r
  if (DriverInfo->PdbStringOffset != 0) {\r
    GetShortPdbFileName ((CHAR8 *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset), mNameString);\r
    return mNameString;\r
  }\r
\r
  if (!IsZeroGuid (&DriverInfo->FileName)) {\r
    //\r
    // Try to get the image's FFS UI section by image GUID\r
    //\r
    NameString = NULL;\r
    StringSize = 0;\r
    Status = GetSectionFromAnyFv (\r
              &DriverInfo->FileName,\r
              EFI_SECTION_USER_INTERFACE,\r
              0,\r
              (VOID **) &NameString,\r
              &StringSize\r
              );\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Method 2: Get the name string from FFS UI section\r
      //\r
      if (StrLen (NameString) > PROFILE_NAME_STRING_LENGTH) {\r
        NameString[PROFILE_NAME_STRING_LENGTH] = 0;\r
      }\r
      UnicodeStrToAsciiStrS (NameString, mNameString, sizeof (mNameString));\r
      FreePool (NameString);\r
      return mNameString;\r
    }\r
  }\r
\r
  //\r
  // Method 3: Get the name string from image GUID\r
  //\r
  AsciiSPrint (mNameString, sizeof (mNameString), "%g", &DriverInfo->FileName);\r
  return mNameString;\r
}\r
\r
/**\r
  Memory type to string.\r
\r
  @param[in] MemoryType Memory type.\r
\r
  @return Pointer to string.\r
\r
**/\r
CHAR8 *\r
ProfileMemoryTypeToStr (\r
  IN EFI_MEMORY_TYPE    MemoryType\r
  )\r
{\r
  UINTN     Index;\r
\r
  if ((UINT32) MemoryType >= 0x80000000) {\r
    //\r
    // OS reserved memory type.\r
    //\r
    Index = EfiMaxMemoryType;\r
  } else if ((UINT32) MemoryType >= 0x70000000) {\r
    //\r
    // OEM reserved memory type.\r
    //\r
    Index = EfiMaxMemoryType + 1;\r
  } else {\r
    Index = MemoryType;\r
  }\r
\r
  return mMemoryTypeString[Index];\r
}\r
\r
/**\r
  Action to string.\r
\r
  @param[in] Action                     Profile action.\r
  @param[in] UserDefinedActionString    Pointer to user defined action string.\r
  @param[in] IsForSmm                   TRUE  - SMRAM profile.\r
                                        FALSE - UEFI memory profile.\r
\r
  @return Pointer to string.\r
\r
**/\r
CHAR8 *\r
ProfileActionToStr (\r
  IN MEMORY_PROFILE_ACTION  Action,\r
  IN CHAR8                  *UserDefinedActionString,\r
  IN BOOLEAN                IsForSmm\r
  )\r
{\r
  UINTN     Index;\r
  UINTN     ActionStringCount;\r
  CHAR8     **ActionString;\r
\r
  if (IsForSmm) {\r
    ActionString = mSmmActionString;\r
    ActionStringCount = ARRAY_SIZE (mSmmActionString);\r
  } else {\r
    ActionString = mActionString;\r
    ActionStringCount = ARRAY_SIZE (mActionString);\r
  }\r
\r
  if ((UINTN) (UINT32) Action < ActionStringCount) {\r
    return ActionString[Action];\r
  }\r
  for (Index = 0; Index < ARRAY_SIZE (mExtActionString); Index++) {\r
    if (mExtActionString[Index].Action == Action) {\r
      return mExtActionString[Index].String;\r
    }\r
  }\r
  if ((Action & MEMORY_PROFILE_ACTION_USER_DEFINED_MASK) != 0) {\r
    if (UserDefinedActionString != NULL) {\r
      return UserDefinedActionString;\r
    }\r
    AsciiSPrint (mUserDefinedActionString, sizeof (mUserDefinedActionString), "UserDefined-0x%08x", Action);\r
    return mUserDefinedActionString;\r
  }\r
\r
  return ActionString[0];\r
}\r
\r
/**\r
  Dump memory profile allocate information.\r
\r
  @param[in] DriverInfo         Pointer to memory profile driver info.\r
  @param[in] AllocIndex         Memory profile alloc info index.\r
  @param[in] AllocInfo          Pointer to memory profile alloc info.\r
  @param[in] IsForSmm           TRUE  - SMRAM profile.\r
                                FALSE - UEFI memory profile.\r
\r
  @return Pointer to next memory profile alloc info.\r
\r
**/\r
MEMORY_PROFILE_ALLOC_INFO *\r
DumpMemoryProfileAllocInfo (\r
  IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo,\r
  IN UINTN                      AllocIndex,\r
  IN MEMORY_PROFILE_ALLOC_INFO  *AllocInfo,\r
  IN BOOLEAN                    IsForSmm\r
  )\r
{\r
  CHAR8     *ActionString;\r
\r
  if (AllocInfo->Header.Signature != MEMORY_PROFILE_ALLOC_INFO_SIGNATURE) {\r
    return NULL;\r
  }\r
\r
  if (AllocInfo->ActionStringOffset != 0) {\r
    ActionString = (CHAR8 *) ((UINTN) AllocInfo + AllocInfo->ActionStringOffset);\r
  } else {\r
    ActionString = NULL;\r
  }\r
\r
  Print (L"    MEMORY_PROFILE_ALLOC_INFO (0x%x)\n", AllocIndex);\r
  Print (L"      Signature     - 0x%08x\n", AllocInfo->Header.Signature);\r
  Print (L"      Length        - 0x%04x\n", AllocInfo->Header.Length);\r
  Print (L"      Revision      - 0x%04x\n", AllocInfo->Header.Revision);\r
  Print (L"      CallerAddress - 0x%016lx (Offset: 0x%08x)\n", AllocInfo->CallerAddress, (UINTN) (AllocInfo->CallerAddress - DriverInfo->ImageBase));\r
  Print (L"      SequenceId    - 0x%08x\n", AllocInfo->SequenceId);\r
  Print (L"      Action        - 0x%08x (%a)\n", AllocInfo->Action, ProfileActionToStr (AllocInfo->Action, ActionString, IsForSmm));\r
  Print (L"      MemoryType    - 0x%08x (%a)\n", AllocInfo->MemoryType, ProfileMemoryTypeToStr (AllocInfo->MemoryType));\r
  Print (L"      Buffer        - 0x%016lx\n", AllocInfo->Buffer);\r
  Print (L"      Size          - 0x%016lx\n", AllocInfo->Size);\r
\r
  return (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) AllocInfo + AllocInfo->Header.Length);\r
}\r
\r
/**\r
  Dump memory profile driver information.\r
\r
  @param[in] DriverIndex        Memory profile driver info index.\r
  @param[in] DriverInfo         Pointer to memory profile driver info.\r
  @param[in] IsForSmm           TRUE  - SMRAM profile.\r
                                FALSE - UEFI memory profile.\r
\r
  @return Pointer to next memory profile driver info.\r
\r
**/\r
MEMORY_PROFILE_DRIVER_INFO *\r
DumpMemoryProfileDriverInfo (\r
  IN UINTN                      DriverIndex,\r
  IN MEMORY_PROFILE_DRIVER_INFO *DriverInfo,\r
  IN BOOLEAN                    IsForSmm\r
  )\r
{\r
  UINTN                         TypeIndex;\r
  MEMORY_PROFILE_ALLOC_INFO     *AllocInfo;\r
  UINTN                         AllocIndex;\r
  CHAR8                         *NameString;\r
\r
  if (DriverInfo->Header.Signature != MEMORY_PROFILE_DRIVER_INFO_SIGNATURE) {\r
    return NULL;\r
  }\r
  Print (L"  MEMORY_PROFILE_DRIVER_INFO (0x%x)\n", DriverIndex);\r
  Print (L"    Signature               - 0x%08x\n", DriverInfo->Header.Signature);\r
  Print (L"    Length                  - 0x%04x\n", DriverInfo->Header.Length);\r
  Print (L"    Revision                - 0x%04x\n", DriverInfo->Header.Revision);\r
  NameString = GetDriverNameString (DriverInfo);\r
  Print (L"    FileName                - %a\n", NameString);\r
  if (DriverInfo->PdbStringOffset != 0) {\r
    Print (L"    Pdb                     - %a\n", (CHAR8 *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset));\r
  }\r
  Print (L"    ImageBase               - 0x%016lx\n", DriverInfo->ImageBase);\r
  Print (L"    ImageSize               - 0x%016lx\n", DriverInfo->ImageSize);\r
  Print (L"    EntryPoint              - 0x%016lx\n", DriverInfo->EntryPoint);\r
  Print (L"    ImageSubsystem          - 0x%04x (%a)\n", DriverInfo->ImageSubsystem, mSubsystemString[(DriverInfo->ImageSubsystem < sizeof(mSubsystemString)/sizeof(mSubsystemString[0])) ? DriverInfo->ImageSubsystem : 0]);\r
  Print (L"    FileType                - 0x%02x (%a)\n", DriverInfo->FileType, mFileTypeString[(DriverInfo->FileType < sizeof(mFileTypeString)/sizeof(mFileTypeString[0])) ? DriverInfo->FileType : 0]);\r
  Print (L"    CurrentUsage            - 0x%016lx\n", DriverInfo->CurrentUsage);\r
  Print (L"    PeakUsage               - 0x%016lx\n", DriverInfo->PeakUsage);\r
  for (TypeIndex = 0; TypeIndex < sizeof (DriverInfo->CurrentUsageByType) / sizeof (DriverInfo->CurrentUsageByType[0]); TypeIndex++) {\r
    if ((DriverInfo->CurrentUsageByType[TypeIndex] != 0) ||\r
        (DriverInfo->PeakUsageByType[TypeIndex] != 0)) {\r
      Print (L"    CurrentUsage[0x%02x]      - 0x%016lx (%a)\n", TypeIndex, DriverInfo->CurrentUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);\r
      Print (L"    PeakUsage[0x%02x]         - 0x%016lx (%a)\n", TypeIndex, DriverInfo->PeakUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);\r
    }\r
  }\r
  Print (L"    AllocRecordCount        - 0x%08x\n", DriverInfo->AllocRecordCount);\r
\r
  AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) DriverInfo + DriverInfo->Header.Length);\r
  for (AllocIndex = 0; AllocIndex < DriverInfo->AllocRecordCount; AllocIndex++) {\r
    AllocInfo = DumpMemoryProfileAllocInfo (DriverInfo, AllocIndex, AllocInfo, IsForSmm);\r
    if (AllocInfo == NULL) {\r
      return NULL;\r
    }\r
  }\r
  return (MEMORY_PROFILE_DRIVER_INFO *) AllocInfo;\r
}\r
\r
/**\r
  Dump memory profile context information.\r
\r
  @param[in] Context            Pointer to memory profile context.\r
  @param[in] IsForSmm           TRUE  - SMRAM profile.\r
                                FALSE - UEFI memory profile.\r
\r
  @return Pointer to the end of memory profile context buffer.\r
\r
**/\r
VOID *\r
DumpMemoryProfileContext (\r
  IN MEMORY_PROFILE_CONTEXT     *Context,\r
  IN BOOLEAN                    IsForSmm\r
  )\r
{\r
  UINTN                         TypeIndex;\r
  MEMORY_PROFILE_DRIVER_INFO    *DriverInfo;\r
  UINTN                         DriverIndex;\r
\r
  if (Context->Header.Signature != MEMORY_PROFILE_CONTEXT_SIGNATURE) {\r
    return NULL;\r
  }\r
  Print (L"MEMORY_PROFILE_CONTEXT\n");\r
  Print (L"  Signature                     - 0x%08x\n", Context->Header.Signature);\r
  Print (L"  Length                        - 0x%04x\n", Context->Header.Length);\r
  Print (L"  Revision                      - 0x%04x\n", Context->Header.Revision);\r
  Print (L"  CurrentTotalUsage             - 0x%016lx\n", Context->CurrentTotalUsage);\r
  Print (L"  PeakTotalUsage                - 0x%016lx\n", Context->PeakTotalUsage);\r
  for (TypeIndex = 0; TypeIndex < sizeof (Context->CurrentTotalUsageByType) / sizeof (Context->CurrentTotalUsageByType[0]); TypeIndex++) {\r
    if ((Context->CurrentTotalUsageByType[TypeIndex] != 0) ||\r
        (Context->PeakTotalUsageByType[TypeIndex] != 0)) {\r
      Print (L"  CurrentTotalUsage[0x%02x]       - 0x%016lx (%a)\n", TypeIndex, Context->CurrentTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);\r
      Print (L"  PeakTotalUsage[0x%02x]          - 0x%016lx (%a)\n", TypeIndex, Context->PeakTotalUsageByType[TypeIndex], mMemoryTypeString[TypeIndex]);\r
    }\r
  }\r
  Print (L"  TotalImageSize                - 0x%016lx\n", Context->TotalImageSize);\r
  Print (L"  ImageCount                    - 0x%08x\n", Context->ImageCount);\r
  Print (L"  SequenceCount                 - 0x%08x\n", Context->SequenceCount);\r
\r
  DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *) ((UINTN) Context + Context->Header.Length);\r
  for (DriverIndex = 0; DriverIndex < Context->ImageCount; DriverIndex++) {\r
    DriverInfo = DumpMemoryProfileDriverInfo (DriverIndex, DriverInfo, IsForSmm);\r
    if (DriverInfo == NULL) {\r
      return NULL;\r
    }\r
  }\r
  return (VOID *) DriverInfo;\r
}\r
\r
/**\r
  Dump memory profile descriptor information.\r
\r
  @param[in] DescriptorIndex    Memory profile descriptor index.\r
  @param[in] Descriptor         Pointer to memory profile descriptor.\r
\r
  @return Pointer to next memory profile descriptor.\r
\r
**/\r
MEMORY_PROFILE_DESCRIPTOR *\r
DumpMemoryProfileDescriptor (\r
  IN UINTN                      DescriptorIndex,\r
  IN MEMORY_PROFILE_DESCRIPTOR  *Descriptor\r
  )\r
{\r
  if (Descriptor->Header.Signature != MEMORY_PROFILE_DESCRIPTOR_SIGNATURE) {\r
    return NULL;\r
  }\r
  Print (L"  MEMORY_PROFILE_DESCRIPTOR (0x%x)\n", DescriptorIndex);\r
  Print (L"    Signature               - 0x%08x\n", Descriptor->Header.Signature);\r
  Print (L"    Length                  - 0x%04x\n", Descriptor->Header.Length);\r
  Print (L"    Revision                - 0x%04x\n", Descriptor->Header.Revision);\r
  Print (L"    Address                 - 0x%016lx\n", Descriptor->Address);\r
  Print (L"    Size                    - 0x%016lx\n", Descriptor->Size);\r
\r
  return (MEMORY_PROFILE_DESCRIPTOR *) ((UINTN) Descriptor + Descriptor->Header.Length);\r
}\r
\r
/**\r
  Dump memory profile free memory information.\r
\r
  @param[in] FreeMemory         Pointer to memory profile free memory.\r
\r
  @return Pointer to the end of memory profile free memory buffer.\r
\r
**/\r
VOID *\r
DumpMemoryProfileFreeMemory (\r
  IN MEMORY_PROFILE_FREE_MEMORY *FreeMemory\r
  )\r
{\r
  MEMORY_PROFILE_DESCRIPTOR     *Descriptor;\r
  UINTN                         DescriptorIndex;\r
\r
  if (FreeMemory->Header.Signature != MEMORY_PROFILE_FREE_MEMORY_SIGNATURE) {\r
    return NULL;\r
  }\r
  Print (L"MEMORY_PROFILE_FREE_MEMORY\n");\r
  Print (L"  Signature                     - 0x%08x\n", FreeMemory->Header.Signature);\r
  Print (L"  Length                        - 0x%04x\n", FreeMemory->Header.Length);\r
  Print (L"  Revision                      - 0x%04x\n", FreeMemory->Header.Revision);\r
  Print (L"  TotalFreeMemoryPages          - 0x%016lx\n", FreeMemory->TotalFreeMemoryPages);\r
  Print (L"  FreeMemoryEntryCount          - 0x%08x\n", FreeMemory->FreeMemoryEntryCount);\r
\r
  Descriptor = (MEMORY_PROFILE_DESCRIPTOR *) ((UINTN) FreeMemory + FreeMemory->Header.Length);\r
  for (DescriptorIndex = 0; DescriptorIndex < FreeMemory->FreeMemoryEntryCount; DescriptorIndex++) {\r
    Descriptor = DumpMemoryProfileDescriptor (DescriptorIndex, Descriptor);\r
    if (Descriptor == NULL) {\r
      return NULL;\r
    }\r
  }\r
\r
  return (VOID *) Descriptor;\r
}\r
\r
/**\r
  Dump memory profile memory range information.\r
\r
  @param[in] MemoryRange        Pointer to memory profile memory range.\r
\r
  @return Pointer to the end of memory profile memory range buffer.\r
\r
**/\r
VOID *\r
DumpMemoryProfileMemoryRange (\r
  IN MEMORY_PROFILE_MEMORY_RANGE    *MemoryRange\r
  )\r
{\r
  MEMORY_PROFILE_DESCRIPTOR     *Descriptor;\r
  UINTN                         DescriptorIndex;\r
\r
  if (MemoryRange->Header.Signature != MEMORY_PROFILE_MEMORY_RANGE_SIGNATURE) {\r
    return NULL;\r
  }\r
  Print (L"MEMORY_PROFILE_MEMORY_RANGE\n");\r
  Print (L"  Signature                     - 0x%08x\n", MemoryRange->Header.Signature);\r
  Print (L"  Length                        - 0x%04x\n", MemoryRange->Header.Length);\r
  Print (L"  Revision                      - 0x%04x\n", MemoryRange->Header.Revision);\r
  Print (L"  MemoryRangeCount              - 0x%08x\n", MemoryRange->MemoryRangeCount);\r
\r
  Descriptor = (MEMORY_PROFILE_DESCRIPTOR *) ((UINTN) MemoryRange + MemoryRange->Header.Length);\r
  for (DescriptorIndex = 0; DescriptorIndex < MemoryRange->MemoryRangeCount; DescriptorIndex++) {\r
    Descriptor = DumpMemoryProfileDescriptor (DescriptorIndex, Descriptor);\r
    if (Descriptor == NULL) {\r
      return NULL;\r
    }\r
  }\r
\r
  return (VOID *) Descriptor;\r
}\r
\r
/**\r
  Scan memory profile by Signature.\r
\r
  @param[in] ProfileBuffer      Memory profile base address.\r
  @param[in] ProfileSize        Memory profile size.\r
  @param[in] Signature          Signature.\r
\r
  @return Pointer to the stucture with the signature.\r
\r
**/\r
VOID *\r
ScanMemoryProfileBySignature (\r
  IN PHYSICAL_ADDRESS           ProfileBuffer,\r
  IN UINT64                     ProfileSize,\r
  IN UINT32                     Signature\r
  )\r
{\r
  MEMORY_PROFILE_COMMON_HEADER  *CommonHeader;\r
  UINTN                          ProfileEnd;\r
\r
  ProfileEnd = (UINTN) (ProfileBuffer + ProfileSize);\r
  CommonHeader = (MEMORY_PROFILE_COMMON_HEADER *) (UINTN) ProfileBuffer;\r
  while ((UINTN) CommonHeader < ProfileEnd) {\r
    if (CommonHeader->Signature == Signature) {\r
      //\r
      // Found it.\r
      //\r
      return (VOID *) CommonHeader;\r
    }\r
    if (CommonHeader->Length == 0) {\r
      ASSERT (FALSE);\r
      return NULL;\r
    }\r
    CommonHeader = (MEMORY_PROFILE_COMMON_HEADER *) ((UINTN) CommonHeader + CommonHeader->Length);\r
  }\r
\r
  return NULL;\r
}\r
\r
/**\r
  Dump memory profile information.\r
\r
  @param[in] ProfileBuffer      Memory profile base address.\r
  @param[in] ProfileSize        Memory profile size.\r
  @param[in] IsForSmm           TRUE  - SMRAM profile.\r
                                FALSE - UEFI memory profile.\r
\r
**/\r
VOID\r
DumpMemoryProfile (\r
  IN PHYSICAL_ADDRESS           ProfileBuffer,\r
  IN UINT64                     ProfileSize,\r
  IN BOOLEAN                    IsForSmm\r
  )\r
{\r
  MEMORY_PROFILE_CONTEXT        *Context;\r
  MEMORY_PROFILE_FREE_MEMORY    *FreeMemory;\r
  MEMORY_PROFILE_MEMORY_RANGE   *MemoryRange;\r
\r
  Context = (MEMORY_PROFILE_CONTEXT *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_CONTEXT_SIGNATURE);\r
  if (Context != NULL) {\r
    DumpMemoryProfileContext (Context, IsForSmm);\r
  }\r
\r
  FreeMemory = (MEMORY_PROFILE_FREE_MEMORY *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_FREE_MEMORY_SIGNATURE);\r
  if (FreeMemory != NULL) {\r
    DumpMemoryProfileFreeMemory (FreeMemory);\r
  }\r
\r
  MemoryRange = (MEMORY_PROFILE_MEMORY_RANGE *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_MEMORY_RANGE_SIGNATURE);\r
  if (MemoryRange != NULL) {\r
    DumpMemoryProfileMemoryRange (MemoryRange);\r
  }\r
}\r
\r
/**\r
  Get Allocate summary information structure by caller address.\r
\r
  @param[in] CallerAddress          Caller address.\r
  @param[in] DriverSummaryInfoData  Driver summary information data structure.\r
\r
  @return Allocate summary information structure by caller address.\r
\r
**/\r
MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA *\r
GetAllocSummaryInfoByCallerAddress (\r
  IN PHYSICAL_ADDRESS                           CallerAddress,\r
  IN MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA    *DriverSummaryInfoData\r
  )\r
{\r
  LIST_ENTRY                                    *AllocSummaryInfoList;\r
  LIST_ENTRY                                    *AllocSummaryLink;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO             *AllocSummaryInfo;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA        *AllocSummaryInfoData;\r
\r
  AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;\r
\r
  for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;\r
       AllocSummaryLink != AllocSummaryInfoList;\r
       AllocSummaryLink = AllocSummaryLink->ForwardLink) {\r
    AllocSummaryInfoData = CR (\r
                             AllocSummaryLink,\r
                             MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,\r
                             Link,\r
                             MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE\r
                             );\r
    AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;\r
    if (AllocSummaryInfo->CallerAddress == CallerAddress) {\r
      return AllocSummaryInfoData;\r
    }\r
  }\r
  return NULL;\r
}\r
\r
/**\r
  Create Allocate summary information structure and\r
  link to Driver summary information data structure.\r
\r
  @param[in, out] DriverSummaryInfoData Driver summary information data structure.\r
  @param[in]      AllocInfo             Pointer to memory profile alloc info.\r
\r
  @return Pointer to next memory profile alloc info.\r
\r
**/\r
MEMORY_PROFILE_ALLOC_INFO *\r
CreateAllocSummaryInfo (\r
  IN OUT MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA    *DriverSummaryInfoData,\r
  IN MEMORY_PROFILE_ALLOC_INFO                      *AllocInfo\r
  )\r
{\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA            *AllocSummaryInfoData;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO                 *AllocSummaryInfo;\r
\r
  if (AllocInfo->Header.Signature != MEMORY_PROFILE_ALLOC_INFO_SIGNATURE) {\r
    return NULL;\r
  }\r
\r
  AllocSummaryInfoData = GetAllocSummaryInfoByCallerAddress (AllocInfo->CallerAddress, DriverSummaryInfoData);\r
  if (AllocSummaryInfoData == NULL) {\r
    AllocSummaryInfoData = AllocatePool (sizeof (*AllocSummaryInfoData));\r
    if (AllocSummaryInfoData == NULL) {\r
      return NULL;\r
    }\r
\r
    AllocSummaryInfoData->Signature = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE;\r
    AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;\r
    AllocSummaryInfo->Header.Signature = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE;\r
    AllocSummaryInfo->Header.Length    = sizeof (*AllocSummaryInfo);\r
    AllocSummaryInfo->Header.Revision  = MEMORY_PROFILE_ALLOC_SUMMARY_INFO_REVISION;\r
    AllocSummaryInfo->CallerAddress = AllocInfo->CallerAddress;\r
    AllocSummaryInfo->Action        = AllocInfo->Action;\r
    if (AllocInfo->ActionStringOffset != 0) {\r
      AllocSummaryInfo->ActionString = (CHAR8 *) ((UINTN) AllocInfo + AllocInfo->ActionStringOffset);\r
    } else {\r
      AllocSummaryInfo->ActionString  = NULL;\r
    }\r
    AllocSummaryInfo->AllocateCount = 0;\r
    AllocSummaryInfo->TotalSize     = 0;\r
    InsertTailList (DriverSummaryInfoData->AllocSummaryInfoList, &AllocSummaryInfoData->Link);\r
  }\r
  AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;\r
  AllocSummaryInfo->AllocateCount ++;\r
  AllocSummaryInfo->TotalSize += AllocInfo->Size;\r
\r
  return (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) AllocInfo + AllocInfo->Header.Length);\r
}\r
\r
/**\r
  Create Driver summary information structure and\r
  link to Context summary information data structure.\r
\r
  @param[in, out] ContextSummaryData    Context summary information data structure.\r
  @param[in]      DriverInfo            Pointer to memory profile driver info.\r
\r
  @return Pointer to next memory profile driver info.\r
\r
**/\r
MEMORY_PROFILE_DRIVER_INFO *\r
CreateDriverSummaryInfo (\r
  IN OUT MEMORY_PROFILE_CONTEXT_SUMMARY_DATA    *ContextSummaryData,\r
  IN MEMORY_PROFILE_DRIVER_INFO                 *DriverInfo\r
  )\r
{\r
  MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA       *DriverSummaryInfoData;\r
  MEMORY_PROFILE_ALLOC_INFO                     *AllocInfo;\r
  UINTN                                         AllocIndex;\r
\r
  if (DriverInfo->Header.Signature != MEMORY_PROFILE_DRIVER_INFO_SIGNATURE) {\r
    return NULL;\r
  }\r
\r
  DriverSummaryInfoData = AllocatePool (sizeof (*DriverSummaryInfoData) + sizeof (LIST_ENTRY));\r
  if (DriverSummaryInfoData == NULL) {\r
    return NULL;\r
  }\r
  DriverSummaryInfoData->Signature = MEMORY_PROFILE_DRIVER_INFO_SIGNATURE;\r
  DriverSummaryInfoData->DriverInfo = DriverInfo;\r
  DriverSummaryInfoData->AllocSummaryInfoList = (LIST_ENTRY *) (DriverSummaryInfoData + 1);\r
  InitializeListHead (DriverSummaryInfoData->AllocSummaryInfoList);\r
  InsertTailList (ContextSummaryData->DriverSummaryInfoList, &DriverSummaryInfoData->Link);\r
\r
  AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) DriverInfo + DriverInfo->Header.Length);\r
  for (AllocIndex = 0; AllocIndex < DriverInfo->AllocRecordCount; AllocIndex++) {\r
    AllocInfo = CreateAllocSummaryInfo (DriverSummaryInfoData, AllocInfo);\r
    if (AllocInfo == NULL) {\r
      return NULL;\r
    }\r
  }\r
  return (MEMORY_PROFILE_DRIVER_INFO *) AllocInfo;\r
}\r
\r
/**\r
  Create Context summary information structure.\r
\r
  @param[in] ProfileBuffer      Memory profile base address.\r
  @param[in] ProfileSize        Memory profile size.\r
\r
  @return Context summary information structure.\r
\r
**/\r
MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *\r
CreateContextSummaryData (\r
  IN PHYSICAL_ADDRESS           ProfileBuffer,\r
  IN UINT64                     ProfileSize\r
  )\r
{\r
  MEMORY_PROFILE_CONTEXT        *Context;\r
  MEMORY_PROFILE_DRIVER_INFO    *DriverInfo;\r
  UINTN                         DriverIndex;\r
\r
  Context = (MEMORY_PROFILE_CONTEXT *) ScanMemoryProfileBySignature (ProfileBuffer, ProfileSize, MEMORY_PROFILE_CONTEXT_SIGNATURE);\r
  if (Context == NULL) {\r
    return NULL;\r
  }\r
\r
  mMemoryProfileContextSummary.Signature = MEMORY_PROFILE_CONTEXT_SIGNATURE;\r
  mMemoryProfileContextSummary.Context = Context;\r
  mMemoryProfileContextSummary.DriverSummaryInfoList = &mImageSummaryQueue;\r
\r
  DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *) ((UINTN) Context + Context->Header.Length);\r
  for (DriverIndex = 0; DriverIndex < Context->ImageCount; DriverIndex++) {\r
    DriverInfo = CreateDriverSummaryInfo (&mMemoryProfileContextSummary, DriverInfo);\r
    if (DriverInfo == NULL) {\r
      return NULL;\r
    }\r
  }\r
\r
  return &mMemoryProfileContextSummary;\r
}\r
\r
/**\r
  Dump Context summary information.\r
\r
  @param[in] ContextSummaryData Context summary information data.\r
  @param[in] IsForSmm           TRUE  - SMRAM profile.\r
                                FALSE - UEFI memory profile.\r
\r
**/\r
VOID\r
DumpContextSummaryData (\r
  IN MEMORY_PROFILE_CONTEXT_SUMMARY_DATA    *ContextSummaryData,\r
  IN BOOLEAN                                IsForSmm\r
  )\r
{\r
  MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA   *DriverSummaryInfoData;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA    *AllocSummaryInfoData;\r
  LIST_ENTRY                                *DriverSummaryInfoList;\r
  LIST_ENTRY                                *DriverSummaryLink;\r
  LIST_ENTRY                                *AllocSummaryInfoList;\r
  LIST_ENTRY                                *AllocSummaryLink;\r
  MEMORY_PROFILE_DRIVER_INFO                *DriverInfo;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO         *AllocSummaryInfo;\r
  CHAR8                                     *NameString;\r
\r
  if (ContextSummaryData == NULL) {\r
    return ;\r
  }\r
\r
  Print (L"\nSummary Data:\n");\r
\r
  DriverSummaryInfoList = ContextSummaryData->DriverSummaryInfoList;\r
  for (DriverSummaryLink = DriverSummaryInfoList->ForwardLink;\r
       DriverSummaryLink != DriverSummaryInfoList;\r
       DriverSummaryLink = DriverSummaryLink->ForwardLink) {\r
    DriverSummaryInfoData = CR (\r
                              DriverSummaryLink,\r
                              MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA,\r
                              Link,\r
                              MEMORY_PROFILE_DRIVER_INFO_SIGNATURE\r
                              );\r
    DriverInfo = DriverSummaryInfoData->DriverInfo;\r
\r
    NameString = GetDriverNameString (DriverInfo);\r
    Print (L"\nDriver - %a (Usage - 0x%08x)", NameString, DriverInfo->CurrentUsage);\r
    if (DriverInfo->CurrentUsage == 0) {\r
      Print (L"\n");\r
      continue;\r
    }\r
\r
    if (DriverInfo->PdbStringOffset != 0) {\r
      Print (L" (Pdb - %a)\n", (CHAR8 *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset));\r
    } else {\r
      Print (L"\n");\r
    }\r
    Print (L"Caller List:\n");\r
    Print(L"  Count            Size                   RVA              Action\n");\r
    Print(L"==========  ==================     ================== (================================)\n");\r
    AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;\r
    for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;\r
         AllocSummaryLink != AllocSummaryInfoList;\r
         AllocSummaryLink = AllocSummaryLink->ForwardLink) {\r
      AllocSummaryInfoData = CR (\r
                               AllocSummaryLink,\r
                               MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,\r
                               Link,\r
                               MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE\r
                               );\r
      AllocSummaryInfo = &AllocSummaryInfoData->AllocSummaryInfo;\r
\r
      Print(L"0x%08x  0x%016lx <== 0x%016lx",\r
        AllocSummaryInfo->AllocateCount,\r
        AllocSummaryInfo->TotalSize,\r
        AllocSummaryInfo->CallerAddress - DriverInfo->ImageBase\r
        );\r
      Print (L" (%a)\n", ProfileActionToStr (AllocSummaryInfo->Action, AllocSummaryInfo->ActionString, IsForSmm));\r
    }\r
  }\r
  return ;\r
}\r
\r
/**\r
  Destroy Context summary information.\r
\r
  @param[in, out] ContextSummaryData    Context summary information data.\r
\r
**/\r
VOID\r
DestroyContextSummaryData (\r
  IN OUT MEMORY_PROFILE_CONTEXT_SUMMARY_DATA    *ContextSummaryData\r
  )\r
{\r
  MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA       *DriverSummaryInfoData;\r
  MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA        *AllocSummaryInfoData;\r
  LIST_ENTRY                                    *DriverSummaryInfoList;\r
  LIST_ENTRY                                    *DriverSummaryLink;\r
  LIST_ENTRY                                    *AllocSummaryInfoList;\r
  LIST_ENTRY                                    *AllocSummaryLink;\r
\r
  if (ContextSummaryData == NULL) {\r
    return ;\r
  }\r
\r
  DriverSummaryInfoList = ContextSummaryData->DriverSummaryInfoList;\r
  for (DriverSummaryLink = DriverSummaryInfoList->ForwardLink;\r
       DriverSummaryLink != DriverSummaryInfoList;\r
       ) {\r
    DriverSummaryInfoData = CR (\r
                              DriverSummaryLink,\r
                              MEMORY_PROFILE_DRIVER_SUMMARY_INFO_DATA,\r
                              Link,\r
                              MEMORY_PROFILE_DRIVER_INFO_SIGNATURE\r
                              );\r
    DriverSummaryLink = DriverSummaryLink->ForwardLink;\r
\r
    AllocSummaryInfoList = DriverSummaryInfoData->AllocSummaryInfoList;\r
    for (AllocSummaryLink = AllocSummaryInfoList->ForwardLink;\r
         AllocSummaryLink != AllocSummaryInfoList;\r
         ) {\r
      AllocSummaryInfoData = CR (\r
                               AllocSummaryLink,\r
                               MEMORY_PROFILE_ALLOC_SUMMARY_INFO_DATA,\r
                               Link,\r
                               MEMORY_PROFILE_ALLOC_SUMMARY_INFO_SIGNATURE\r
                               );\r
      AllocSummaryLink = AllocSummaryLink->ForwardLink;\r
\r
      RemoveEntryList (&AllocSummaryInfoData->Link);\r
      FreePool (AllocSummaryInfoData);\r
    }\r
\r
    RemoveEntryList (&DriverSummaryInfoData->Link);\r
    FreePool (DriverSummaryInfoData);\r
  }\r
  return ;\r
}\r
\r
/**\r
  Get and dump UEFI memory profile data.\r
\r
  @return EFI_SUCCESS   Get the memory profile data successfully.\r
  @return other         Fail to get the memory profile data.\r
\r
**/\r
EFI_STATUS\r
GetUefiMemoryProfileData (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  EDKII_MEMORY_PROFILE_PROTOCOL       *ProfileProtocol;\r
  VOID                                *Data;\r
  UINT64                              Size;\r
  MEMORY_PROFILE_CONTEXT_SUMMARY_DATA *MemoryProfileContextSummaryData;\r
  BOOLEAN                             RecordingState;\r
\r
  Status = gBS->LocateProtocol (&gEdkiiMemoryProfileGuid, NULL, (VOID **) &ProfileProtocol);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "UefiMemoryProfile: Locate MemoryProfile protocol - %r\n", Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Set recording state if needed.\r
  //\r
  RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;\r
  Status = ProfileProtocol->GetRecordingState (ProfileProtocol, &RecordingState);\r
  if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {\r
    ProfileProtocol->SetRecordingState (ProfileProtocol, MEMORY_PROFILE_RECORDING_DISABLE);\r
  }\r
\r
  Size = 0;\r
  Data = NULL;\r
  Status = ProfileProtocol->GetData (\r
                              ProfileProtocol,\r
                              &Size,\r
                              Data\r
                              );\r
  if (Status != EFI_BUFFER_TOO_SMALL) {\r
    Print (L"UefiMemoryProfile: GetData - %r\n", Status);\r
    goto Done;\r
  }\r
\r
  Data = AllocateZeroPool ((UINTN) Size);\r
  if (Data == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    Print (L"UefiMemoryProfile: AllocateZeroPool (0x%x) - %r\n", Size, Status);\r
    return Status;\r
  }\r
\r
  Status = ProfileProtocol->GetData (\r
                              ProfileProtocol,\r
                              &Size,\r
                              Data\r
                              );\r
  if (EFI_ERROR (Status)) {\r
    Print (L"UefiMemoryProfile: GetData - %r\n", Status);\r
    goto Done;\r
  }\r
\r
\r
  Print (L"UefiMemoryProfileSize - 0x%x\n", Size);\r
  Print (L"======= UefiMemoryProfile begin =======\n");\r
  DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) Data, Size, FALSE);\r
\r
  //\r
  // Dump summary information\r
  //\r
  MemoryProfileContextSummaryData = CreateContextSummaryData ((PHYSICAL_ADDRESS) (UINTN) Data, Size);\r
  if (MemoryProfileContextSummaryData != NULL) {\r
    DumpContextSummaryData (MemoryProfileContextSummaryData, FALSE);\r
    DestroyContextSummaryData (MemoryProfileContextSummaryData);\r
  }\r
\r
  Print (L"======= UefiMemoryProfile end =======\n\n\n");\r
\r
Done:\r
  if (Data != NULL) {\r
    FreePool (Data);\r
  }\r
\r
  //\r
  // Restore recording state if needed.\r
  //\r
  if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {\r
    ProfileProtocol->SetRecordingState (ProfileProtocol, MEMORY_PROFILE_RECORDING_ENABLE);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Get and dump SMRAM profile data.\r
\r
  @return EFI_SUCCESS   Get the SMRAM profile data successfully.\r
  @return other         Fail to get the SMRAM profile data.\r
\r
**/\r
EFI_STATUS\r
GetSmramProfileData (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  UINTN                                         CommSize;\r
  UINT8                                         *CommBuffer;\r
  EFI_SMM_COMMUNICATE_HEADER                    *CommHeader;\r
  SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO      *CommGetProfileInfo;\r
  SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET *CommGetProfileData;\r
  SMRAM_PROFILE_PARAMETER_RECORDING_STATE       *CommRecordingState;\r
  UINTN                                         ProfileSize;\r
  VOID                                          *ProfileBuffer;\r
  EFI_SMM_COMMUNICATION_PROTOCOL                *SmmCommunication;\r
  UINTN                                         MinimalSizeNeeded;\r
  EDKII_PI_SMM_COMMUNICATION_REGION_TABLE       *PiSmmCommunicationRegionTable;\r
  UINT32                                        Index;\r
  EFI_MEMORY_DESCRIPTOR                         *Entry;\r
  VOID                                          *Buffer;\r
  UINTN                                         Size;\r
  UINTN                                         Offset;\r
  MEMORY_PROFILE_CONTEXT_SUMMARY_DATA           *MemoryProfileContextSummaryData;\r
  BOOLEAN                                       RecordingState;\r
\r
  ProfileBuffer = NULL;\r
\r
  Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &SmmCommunication);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "SmramProfile: Locate SmmCommunication protocol - %r\n", Status));\r
    return Status;\r
  }\r
\r
  MinimalSizeNeeded = sizeof (EFI_GUID) +\r
                      sizeof (UINTN) +\r
                      MAX (sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO),\r
                           MAX (sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET),\r
                                sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE)));\r
  MinimalSizeNeeded += MAX (sizeof (MEMORY_PROFILE_CONTEXT),\r
                            MAX (sizeof (MEMORY_PROFILE_DRIVER_INFO),\r
                                 MAX (sizeof (MEMORY_PROFILE_ALLOC_INFO),\r
                                      MAX (sizeof (MEMORY_PROFILE_DESCRIPTOR),\r
                                           MAX (sizeof (MEMORY_PROFILE_FREE_MEMORY),\r
                                                sizeof (MEMORY_PROFILE_MEMORY_RANGE))))));\r
\r
  Status = EfiGetSystemConfigurationTable (\r
             &gEdkiiPiSmmCommunicationRegionTableGuid,\r
             (VOID **) &PiSmmCommunicationRegionTable\r
             );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "SmramProfile: Get PiSmmCommunicationRegionTable - %r\n", Status));\r
    return Status;\r
  }\r
  ASSERT (PiSmmCommunicationRegionTable != NULL);\r
  Entry = (EFI_MEMORY_DESCRIPTOR *) (PiSmmCommunicationRegionTable + 1);\r
  Size = 0;\r
  for (Index = 0; Index < PiSmmCommunicationRegionTable->NumberOfEntries; Index++) {\r
    if (Entry->Type == EfiConventionalMemory) {\r
      Size = EFI_PAGES_TO_SIZE ((UINTN) Entry->NumberOfPages);\r
      if (Size >= MinimalSizeNeeded) {\r
        break;\r
      }\r
    }\r
    Entry = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) Entry + PiSmmCommunicationRegionTable->DescriptorSize);\r
  }\r
  ASSERT (Index < PiSmmCommunicationRegionTable->NumberOfEntries);\r
  CommBuffer = (UINT8 *) (UINTN) Entry->PhysicalStart;\r
\r
  //\r
  // Set recording state if needed.\r
  //\r
  RecordingState = MEMORY_PROFILE_RECORDING_DISABLE;\r
\r
  CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];\r
  CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));\r
  CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);\r
\r
  CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];\r
  CommRecordingState->Header.Command      = SMRAM_PROFILE_COMMAND_GET_RECORDING_STATE;\r
  CommRecordingState->Header.DataLength   = sizeof (*CommRecordingState);\r
  CommRecordingState->Header.ReturnStatus = (UINT64)-1;\r
  CommRecordingState->RecordingState      = MEMORY_PROFILE_RECORDING_DISABLE;\r
\r
  CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;\r
  Status = SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "SmramProfile: SmmCommunication - %r\n", Status));\r
    return Status;\r
  }\r
\r
  if (CommRecordingState->Header.ReturnStatus != 0) {\r
    Print (L"SmramProfile: GetRecordingState - 0x%0x\n", CommRecordingState->Header.ReturnStatus);\r
    return EFI_SUCCESS;\r
  }\r
  RecordingState = CommRecordingState->RecordingState;\r
  if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {\r
    CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];\r
    CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));\r
    CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);\r
\r
    CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];\r
    CommRecordingState->Header.Command      = SMRAM_PROFILE_COMMAND_SET_RECORDING_STATE;\r
    CommRecordingState->Header.DataLength   = sizeof (*CommRecordingState);\r
    CommRecordingState->Header.ReturnStatus = (UINT64)-1;\r
    CommRecordingState->RecordingState      = MEMORY_PROFILE_RECORDING_DISABLE;\r
\r
    CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;\r
    SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);\r
  }\r
\r
  //\r
  // Get Size\r
  //\r
  CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];\r
  CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));\r
  CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO);\r
\r
  CommGetProfileInfo = (SMRAM_PROFILE_PARAMETER_GET_PROFILE_INFO *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];\r
  CommGetProfileInfo->Header.Command      = SMRAM_PROFILE_COMMAND_GET_PROFILE_INFO;\r
  CommGetProfileInfo->Header.DataLength   = sizeof (*CommGetProfileInfo);\r
  CommGetProfileInfo->Header.ReturnStatus = (UINT64)-1;\r
  CommGetProfileInfo->ProfileSize         = 0;\r
\r
  CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;\r
  Status = SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (CommGetProfileInfo->Header.ReturnStatus != 0) {\r
    Status = EFI_SUCCESS;\r
    Print (L"SmramProfile: GetProfileInfo - 0x%0x\n", CommGetProfileInfo->Header.ReturnStatus);\r
    goto Done;\r
  }\r
\r
  ProfileSize = (UINTN) CommGetProfileInfo->ProfileSize;\r
\r
  //\r
  // Get Data\r
  //\r
  ProfileBuffer = AllocateZeroPool (ProfileSize);\r
  if (ProfileBuffer == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    Print (L"SmramProfile: AllocateZeroPool (0x%x) for profile buffer - %r\n", ProfileSize, Status);\r
    goto Done;\r
  }\r
\r
  CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];\r
  CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof(gEdkiiMemoryProfileGuid));\r
  CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET);\r
\r
  CommGetProfileData = (SMRAM_PROFILE_PARAMETER_GET_PROFILE_DATA_BY_OFFSET *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];\r
  CommGetProfileData->Header.Command      = SMRAM_PROFILE_COMMAND_GET_PROFILE_DATA_BY_OFFSET;\r
  CommGetProfileData->Header.DataLength   = sizeof (*CommGetProfileData);\r
  CommGetProfileData->Header.ReturnStatus = (UINT64)-1;\r
\r
  CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;\r
  Buffer = (UINT8 *) CommHeader + CommSize;\r
  Size -= CommSize;\r
\r
  CommGetProfileData->ProfileBuffer       = (PHYSICAL_ADDRESS) (UINTN) Buffer;\r
  CommGetProfileData->ProfileOffset       = 0;\r
  while (CommGetProfileData->ProfileOffset < ProfileSize) {\r
    Offset = (UINTN) CommGetProfileData->ProfileOffset;\r
    if (Size <= (ProfileSize - CommGetProfileData->ProfileOffset)) {\r
      CommGetProfileData->ProfileSize = (UINT64) Size;\r
    } else {\r
      CommGetProfileData->ProfileSize = (UINT64) (ProfileSize - CommGetProfileData->ProfileOffset);\r
    }\r
    Status = SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    if (CommGetProfileData->Header.ReturnStatus != 0) {\r
      Status = EFI_SUCCESS;\r
      Print (L"GetProfileData - 0x%x\n", CommGetProfileData->Header.ReturnStatus);\r
      goto Done;\r
    }\r
    CopyMem ((UINT8 *) ProfileBuffer + Offset, (VOID *) (UINTN) CommGetProfileData->ProfileBuffer, (UINTN) CommGetProfileData->ProfileSize);\r
  }\r
\r
\r
  Print (L"SmramProfileSize - 0x%x\n", ProfileSize);\r
  Print (L"======= SmramProfile begin =======\n");\r
  DumpMemoryProfile ((PHYSICAL_ADDRESS) (UINTN) ProfileBuffer, ProfileSize, TRUE);\r
\r
  //\r
  // Dump summary information\r
  //\r
  MemoryProfileContextSummaryData = CreateContextSummaryData ((PHYSICAL_ADDRESS) (UINTN) ProfileBuffer, ProfileSize);\r
  if (MemoryProfileContextSummaryData != NULL) {\r
    DumpContextSummaryData (MemoryProfileContextSummaryData, TRUE);\r
    DestroyContextSummaryData (MemoryProfileContextSummaryData);\r
  }\r
\r
  Print (L"======= SmramProfile end =======\n\n\n");\r
\r
Done:\r
  if (ProfileBuffer != NULL) {\r
    FreePool (ProfileBuffer);\r
  }\r
\r
  //\r
  // Restore recording state if needed.\r
  //\r
  if (RecordingState == MEMORY_PROFILE_RECORDING_ENABLE) {\r
    CommHeader = (EFI_SMM_COMMUNICATE_HEADER *) &CommBuffer[0];\r
    CopyMem (&CommHeader->HeaderGuid, &gEdkiiMemoryProfileGuid, sizeof (gEdkiiMemoryProfileGuid));\r
    CommHeader->MessageLength = sizeof (SMRAM_PROFILE_PARAMETER_RECORDING_STATE);\r
\r
    CommRecordingState = (SMRAM_PROFILE_PARAMETER_RECORDING_STATE *) &CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];\r
    CommRecordingState->Header.Command      = SMRAM_PROFILE_COMMAND_SET_RECORDING_STATE;\r
    CommRecordingState->Header.DataLength   = sizeof (*CommRecordingState);\r
    CommRecordingState->Header.ReturnStatus = (UINT64)-1;\r
    CommRecordingState->RecordingState      = MEMORY_PROFILE_RECORDING_ENABLE;\r
\r
    CommSize = sizeof (EFI_GUID) + sizeof (UINTN) + CommHeader->MessageLength;\r
    SmmCommunication->Communicate (SmmCommunication, CommBuffer, &CommSize);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  The user Entry Point for Application. The user code starts with this function\r
  as the real entry point for the image goes into a library that calls this function.\r
\r
  @param[in] ImageHandle    The firmware allocated handle for the EFI image.\r
  @param[in] SystemTable    A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS       The entry point is executed successfully.\r
  @retval other             Some error occurs when executing this entry point.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UefiMain (\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE   *SystemTable\r
  )\r
{\r
  EFI_STATUS                     Status;\r
\r
  Status = GetUefiMemoryProfileData ();\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "GetUefiMemoryProfileData - %r\n", Status));\r
  }\r
\r
  Status = GetSmramProfileData ();\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "GetSmramProfileData - %r\n", Status));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r