MdeModulePkg/Core/Dxe/Mem/MemoryProfileRecord.c

   1 /** @file
   2   Support routines for UEFI memory profile.
   3
   4   Copyright (c) 2014 - 2018, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "DxeMain.h"
  16 #include "Imem.h"
  17
  18 #define IS_UEFI_MEMORY_PROFILE_ENABLED ((PcdGet8 (PcdMemoryProfilePropertyMask) & BIT0) != 0)
  19
  20 #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
  21   ((ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1)))
  22
  23 typedef struct {
  24   UINT32                        Signature;
  25   MEMORY_PROFILE_CONTEXT        Context;
  26   LIST_ENTRY                    *DriverInfoList;
  27 } MEMORY_PROFILE_CONTEXT_DATA;
  28
  29 typedef struct {
  30   UINT32                        Signature;
  31   MEMORY_PROFILE_DRIVER_INFO    DriverInfo;
  32   LIST_ENTRY                    *AllocInfoList;
  33   CHAR8                         *PdbString;
  34   LIST_ENTRY                    Link;
  35 } MEMORY_PROFILE_DRIVER_INFO_DATA;
  36
  37 typedef struct {
  38   UINT32                        Signature;
  39   MEMORY_PROFILE_ALLOC_INFO     AllocInfo;
  40   CHAR8                         *ActionString;
  41   LIST_ENTRY                    Link;
  42 } MEMORY_PROFILE_ALLOC_INFO_DATA;
  43
  44
  45 GLOBAL_REMOVE_IF_UNREFERENCED LIST_ENTRY  mImageQueue = INITIALIZE_LIST_HEAD_VARIABLE (mImageQueue);
  46 GLOBAL_REMOVE_IF_UNREFERENCED MEMORY_PROFILE_CONTEXT_DATA mMemoryProfileContext = {
  47   MEMORY_PROFILE_CONTEXT_SIGNATURE,
  48   {
  49     {
  50       MEMORY_PROFILE_CONTEXT_SIGNATURE,
  51       sizeof (MEMORY_PROFILE_CONTEXT),
  52       MEMORY_PROFILE_CONTEXT_REVISION
  53     },
  54     0,
  55     0,
  56     {0},
  57     {0},
  58     0,
  59     0,
  60     0
  61   },
  62   &mImageQueue,
  63 };
  64 GLOBAL_REMOVE_IF_UNREFERENCED MEMORY_PROFILE_CONTEXT_DATA *mMemoryProfileContextPtr = NULL;
  65
  66 GLOBAL_REMOVE_IF_UNREFERENCED EFI_LOCK mMemoryProfileLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
  67 GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN mMemoryProfileGettingStatus = FALSE;
  68 GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN mMemoryProfileRecordingEnable = MEMORY_PROFILE_RECORDING_DISABLE;
  69 GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_PROTOCOL *mMemoryProfileDriverPath;
  70 GLOBAL_REMOVE_IF_UNREFERENCED UINTN                    mMemoryProfileDriverPathSize;
  71
  72 /**
  73   Get memory profile data.
  74
  75   @param[in]      This              The EDKII_MEMORY_PROFILE_PROTOCOL instance.
  76   @param[in, out] ProfileSize       On entry, points to the size in bytes of the ProfileBuffer.
  77                                     On return, points to the size of the data returned in ProfileBuffer.
  78   @param[out]     ProfileBuffer     Profile buffer.
  79
  80   @return EFI_SUCCESS               Get the memory profile data successfully.
  81   @return EFI_UNSUPPORTED           Memory profile is unsupported.
  82   @return EFI_BUFFER_TO_SMALL       The ProfileSize is too small for the resulting data.
  83                                     ProfileSize is updated with the size required.
  84
  85 **/
  86 EFI_STATUS
  87 EFIAPI
  88 ProfileProtocolGetData (
  89   IN     EDKII_MEMORY_PROFILE_PROTOCOL  *This,
  90   IN OUT UINT64                         *ProfileSize,
  91      OUT VOID                           *ProfileBuffer
  92   );
  93
  94 /**
  95   Register image to memory profile.
  96
  97   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
  98   @param[in] FilePath           File path of the image.
  99   @param[in] ImageBase          Image base address.
 100   @param[in] ImageSize          Image size.
 101   @param[in] FileType           File type of the image.
 102
 103   @return EFI_SUCCESS           Register successfully.
 104   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 105                                 or memory profile for the image is not required.
 106   @return EFI_OUT_OF_RESOURCE   No enough resource for this register.
 107
 108 **/
 109 EFI_STATUS
 110 EFIAPI
 111 ProfileProtocolRegisterImage (
 112   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
 113   IN EFI_DEVICE_PATH_PROTOCOL           *FilePath,
 114   IN PHYSICAL_ADDRESS                   ImageBase,
 115   IN UINT64                             ImageSize,
 116   IN EFI_FV_FILETYPE                    FileType
 117   );
 118
 119 /**
 120   Unregister image from memory profile.
 121
 122   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
 123   @param[in] FilePath           File path of the image.
 124   @param[in] ImageBase          Image base address.
 125   @param[in] ImageSize          Image size.
 126
 127   @return EFI_SUCCESS           Unregister successfully.
 128   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 129                                 or memory profile for the image is not required.
 130   @return EFI_NOT_FOUND         The image is not found.
 131
 132 **/
 133 EFI_STATUS
 134 EFIAPI
 135 ProfileProtocolUnregisterImage (
 136   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
 137   IN EFI_DEVICE_PATH_PROTOCOL           *FilePath,
 138   IN PHYSICAL_ADDRESS                   ImageBase,
 139   IN UINT64                             ImageSize
 140   );
 141
 142 /**
 143   Get memory profile recording state.
 144
 145   @param[in]  This              The EDKII_MEMORY_PROFILE_PROTOCOL instance.
 146   @param[out] RecordingState    Recording state.
 147
 148   @return EFI_SUCCESS           Memory profile recording state is returned.
 149   @return EFI_UNSUPPORTED       Memory profile is unsupported.
 150   @return EFI_INVALID_PARAMETER RecordingState is NULL.
 151
 152 **/
 153 EFI_STATUS
 154 EFIAPI
 155 ProfileProtocolGetRecordingState (
 156   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
 157   OUT BOOLEAN                           *RecordingState
 158   );
 159
 160 /**
 161   Set memory profile recording state.
 162
 163   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
 164   @param[in] RecordingState     Recording state.
 165
 166   @return EFI_SUCCESS           Set memory profile recording state successfully.
 167   @return EFI_UNSUPPORTED       Memory profile is unsupported.
 168
 169 **/
 170 EFI_STATUS
 171 EFIAPI
 172 ProfileProtocolSetRecordingState (
 173   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
 174   IN BOOLEAN                            RecordingState
 175   );
 176
 177 /**
 178   Record memory profile of multilevel caller.
 179
 180   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
 181   @param[in] CallerAddress      Address of caller.
 182   @param[in] Action             Memory profile action.
 183   @param[in] MemoryType         Memory type.
 184                                 EfiMaxMemoryType means the MemoryType is unknown.
 185   @param[in] Buffer             Buffer address.
 186   @param[in] Size               Buffer size.
 187   @param[in] ActionString       String for memory profile action.
 188                                 Only needed for user defined allocate action.
 189
 190   @return EFI_SUCCESS           Memory profile is updated.
 191   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 192                                 or memory profile for the image is not required,
 193                                 or memory profile for the memory type is not required.
 194   @return EFI_ACCESS_DENIED     It is during memory profile data getting.
 195   @return EFI_ABORTED           Memory profile recording is not enabled.
 196   @return EFI_OUT_OF_RESOURCES  No enough resource to update memory profile for allocate action.
 197   @return EFI_NOT_FOUND         No matched allocate info found for free action.
 198
 199 **/
 200 EFI_STATUS
 201 EFIAPI
 202 ProfileProtocolRecord (
 203   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
 204   IN PHYSICAL_ADDRESS                   CallerAddress,
 205   IN MEMORY_PROFILE_ACTION              Action,
 206   IN EFI_MEMORY_TYPE                    MemoryType,
 207   IN VOID                               *Buffer,
 208   IN UINTN                              Size,
 209   IN CHAR8                              *ActionString OPTIONAL
 210   );
 211
 212 GLOBAL_REMOVE_IF_UNREFERENCED EDKII_MEMORY_PROFILE_PROTOCOL mProfileProtocol = {
 213   ProfileProtocolGetData,
 214   ProfileProtocolRegisterImage,
 215   ProfileProtocolUnregisterImage,
 216   ProfileProtocolGetRecordingState,
 217   ProfileProtocolSetRecordingState,
 218   ProfileProtocolRecord,
 219 };
 220
 221 /**
 222   Acquire lock on mMemoryProfileLock.
 223 **/
 224 VOID
 225 CoreAcquireMemoryProfileLock (
 226   VOID
 227   )
 228 {
 229   CoreAcquireLock (&mMemoryProfileLock);
 230 }
 231
 232 /**
 233   Release lock on mMemoryProfileLock.
 234 **/
 235 VOID
 236 CoreReleaseMemoryProfileLock (
 237   VOID
 238   )
 239 {
 240   CoreReleaseLock (&mMemoryProfileLock);
 241 }
 242
 243 /**
 244   Return memory profile context.
 245
 246   @return Memory profile context.
 247
 248 **/
 249 MEMORY_PROFILE_CONTEXT_DATA *
 250 GetMemoryProfileContext (
 251   VOID
 252   )
 253 {
 254   return mMemoryProfileContextPtr;
 255 }
 256
 257 /**
 258   Retrieves and returns the Subsystem of a PE/COFF image that has been loaded into system memory.
 259   If Pe32Data is NULL, then ASSERT().
 260
 261   @param Pe32Data   The pointer to the PE/COFF image that is loaded in system memory.
 262
 263   @return The Subsystem of the PE/COFF image.
 264
 265 **/
 266 UINT16
 267 InternalPeCoffGetSubsystem (
 268   IN VOID  *Pe32Data
 269   )
 270 {
 271   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;
 272   EFI_IMAGE_DOS_HEADER                 *DosHdr;
 273   UINT16                               Magic;
 274
 275   ASSERT (Pe32Data != NULL);
 276
 277   DosHdr = (EFI_IMAGE_DOS_HEADER *) Pe32Data;
 278   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
 279     //
 280     // DOS image header is present, so read the PE header after the DOS image header.
 281     //
 282     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *) ((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
 283   } else {
 284     //
 285     // DOS image header is not present, so PE header is at the image base.
 286     //
 287     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *) Pe32Data;
 288   }
 289
 290   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 291     return Hdr.Te->Subsystem;
 292   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE)  {
 293     Magic = Hdr.Pe32->OptionalHeader.Magic;
 294     if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 295       return Hdr.Pe32->OptionalHeader.Subsystem;
 296     } else if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
 297       return Hdr.Pe32Plus->OptionalHeader.Subsystem;
 298     }
 299   }
 300
 301   return 0x0000;
 302 }
 303
 304 /**
 305   Retrieves and returns a pointer to the entry point to a PE/COFF image that has been loaded
 306   into system memory with the PE/COFF Loader Library functions.
 307
 308   Retrieves the entry point to the PE/COFF image specified by Pe32Data and returns this entry
 309   point in EntryPoint.  If the entry point could not be retrieved from the PE/COFF image, then
 310   return RETURN_INVALID_PARAMETER.  Otherwise return RETURN_SUCCESS.
 311   If Pe32Data is NULL, then ASSERT().
 312   If EntryPoint is NULL, then ASSERT().
 313
 314   @param  Pe32Data                  The pointer to the PE/COFF image that is loaded in system memory.
 315   @param  EntryPoint                The pointer to entry point to the PE/COFF image to return.
 316
 317   @retval RETURN_SUCCESS            EntryPoint was returned.
 318   @retval RETURN_INVALID_PARAMETER  The entry point could not be found in the PE/COFF image.
 319
 320 **/
 321 RETURN_STATUS
 322 InternalPeCoffGetEntryPoint (
 323   IN  VOID  *Pe32Data,
 324   OUT VOID  **EntryPoint
 325   )
 326 {
 327   EFI_IMAGE_DOS_HEADER                  *DosHdr;
 328   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
 329
 330   ASSERT (Pe32Data   != NULL);
 331   ASSERT (EntryPoint != NULL);
 332
 333   DosHdr = (EFI_IMAGE_DOS_HEADER *) Pe32Data;
 334   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
 335     //
 336     // DOS image header is present, so read the PE header after the DOS image header.
 337     //
 338     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *) ((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
 339   } else {
 340     //
 341     // DOS image header is not present, so PE header is at the image base.
 342     //
 343     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *) Pe32Data;
 344   }
 345
 346   //
 347   // Calculate the entry point relative to the start of the image.
 348   // AddressOfEntryPoint is common for PE32 & PE32+
 349   //
 350   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 351     *EntryPoint = (VOID *) ((UINTN) Pe32Data + (UINTN) (Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize);
 352     return RETURN_SUCCESS;
 353   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
 354     *EntryPoint = (VOID *) ((UINTN) Pe32Data + (UINTN) (Hdr.Pe32->OptionalHeader.AddressOfEntryPoint & 0x0ffffffff));
 355     return RETURN_SUCCESS;
 356   }
 357
 358   return RETURN_UNSUPPORTED;
 359 }
 360
 361 /**
 362   Build driver info.
 363
 364   @param ContextData    Memory profile context.
 365   @param FileName       File name of the image.
 366   @param ImageBase      Image base address.
 367   @param ImageSize      Image size.
 368   @param EntryPoint     Entry point of the image.
 369   @param ImageSubsystem Image subsystem of the image.
 370   @param FileType       File type of the image.
 371
 372   @return Pointer to memory profile driver info.
 373
 374 **/
 375 MEMORY_PROFILE_DRIVER_INFO_DATA *
 376 BuildDriverInfo (
 377   IN MEMORY_PROFILE_CONTEXT_DATA    *ContextData,
 378   IN EFI_GUID                       *FileName,
 379   IN PHYSICAL_ADDRESS               ImageBase,
 380   IN UINT64                         ImageSize,
 381   IN PHYSICAL_ADDRESS               EntryPoint,
 382   IN UINT16                         ImageSubsystem,
 383   IN EFI_FV_FILETYPE                FileType
 384   )
 385 {
 386   EFI_STATUS                        Status;
 387   MEMORY_PROFILE_DRIVER_INFO        *DriverInfo;
 388   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 389   VOID                              *EntryPointInImage;
 390   CHAR8                             *PdbString;
 391   UINTN                             PdbSize;
 392   UINTN                             PdbOccupiedSize;
 393
 394   PdbSize = 0;
 395   PdbOccupiedSize = 0;
 396   PdbString = NULL;
 397   if (ImageBase != 0) {
 398     PdbString = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageBase);
 399     if (PdbString != NULL) {
 400       PdbSize = AsciiStrSize (PdbString);
 401       PdbOccupiedSize = GET_OCCUPIED_SIZE (PdbSize, sizeof (UINT64));
 402     }
 403   }
 404
 405   //
 406   // Use CoreInternalAllocatePool() that will not update profile for this AllocatePool action.
 407   //
 408   Status = CoreInternalAllocatePool (
 409              EfiBootServicesData,
 410              sizeof (*DriverInfoData) + sizeof (LIST_ENTRY) + PdbSize,
 411              (VOID **) &DriverInfoData
 412              );
 413   if (EFI_ERROR (Status)) {
 414     return NULL;
 415   }
 416   ASSERT (DriverInfoData != NULL);
 417
 418   ZeroMem (DriverInfoData, sizeof (*DriverInfoData));
 419
 420   DriverInfo = &DriverInfoData->DriverInfo;
 421   DriverInfoData->Signature = MEMORY_PROFILE_DRIVER_INFO_SIGNATURE;
 422   DriverInfo->Header.Signature = MEMORY_PROFILE_DRIVER_INFO_SIGNATURE;
 423   DriverInfo->Header.Length = (UINT16) (sizeof (MEMORY_PROFILE_DRIVER_INFO) + PdbOccupiedSize);
 424   DriverInfo->Header.Revision = MEMORY_PROFILE_DRIVER_INFO_REVISION;
 425   if (FileName != NULL) {
 426     CopyMem (&DriverInfo->FileName, FileName, sizeof (EFI_GUID));
 427   }
 428   DriverInfo->ImageBase = ImageBase;
 429   DriverInfo->ImageSize = ImageSize;
 430   DriverInfo->EntryPoint = EntryPoint;
 431   DriverInfo->ImageSubsystem = ImageSubsystem;
 432   if ((EntryPoint != 0) && ((EntryPoint < ImageBase) || (EntryPoint >= (ImageBase + ImageSize)))) {
 433     //
 434     // If the EntryPoint is not in the range of image buffer, it should come from emulation environment.
 435     // So patch ImageBuffer here to align the EntryPoint.
 436     //
 437     Status = InternalPeCoffGetEntryPoint ((VOID *) (UINTN) ImageBase, &EntryPointInImage);
 438     ASSERT_EFI_ERROR (Status);
 439     DriverInfo->ImageBase = ImageBase + EntryPoint - (PHYSICAL_ADDRESS) (UINTN) EntryPointInImage;
 440   }
 441   DriverInfo->FileType = FileType;
 442   DriverInfoData->AllocInfoList = (LIST_ENTRY *) (DriverInfoData + 1);
 443   InitializeListHead (DriverInfoData->AllocInfoList);
 444   DriverInfo->CurrentUsage = 0;
 445   DriverInfo->PeakUsage = 0;
 446   DriverInfo->AllocRecordCount = 0;
 447   if (PdbSize != 0) {
 448     DriverInfo->PdbStringOffset = (UINT16) sizeof (MEMORY_PROFILE_DRIVER_INFO);
 449     DriverInfoData->PdbString = (CHAR8 *) (DriverInfoData->AllocInfoList + 1);
 450     CopyMem (DriverInfoData->PdbString, PdbString, PdbSize);
 451   } else {
 452     DriverInfo->PdbStringOffset = 0;
 453     DriverInfoData->PdbString = NULL;
 454   }
 455
 456   InsertTailList (ContextData->DriverInfoList, &DriverInfoData->Link);
 457   ContextData->Context.ImageCount ++;
 458   ContextData->Context.TotalImageSize += DriverInfo->ImageSize;
 459
 460   return DriverInfoData;
 461 }
 462
 463 /**
 464   Return if record for this driver is needed..
 465
 466   @param DriverFilePath     Driver file path.
 467
 468   @retval TRUE              Record for this driver is needed.
 469   @retval FALSE             Record for this driver is not needed.
 470
 471 **/
 472 BOOLEAN
 473 NeedRecordThisDriver (
 474   IN EFI_DEVICE_PATH_PROTOCOL       *DriverFilePath
 475   )
 476 {
 477   EFI_DEVICE_PATH_PROTOCOL          *TmpDevicePath;
 478   EFI_DEVICE_PATH_PROTOCOL          *DevicePathInstance;
 479   UINTN                             DevicePathSize;
 480   UINTN                             FilePathSize;
 481
 482   if (!IsDevicePathValid (mMemoryProfileDriverPath, mMemoryProfileDriverPathSize)) {
 483     //
 484     // Invalid Device Path means record all.
 485     //
 486     return TRUE;
 487   }
 488
 489   //
 490   // Record FilePath without END node.
 491   //
 492   FilePathSize = GetDevicePathSize (DriverFilePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);
 493
 494   DevicePathInstance = mMemoryProfileDriverPath;
 495   do {
 496     //
 497     // Find END node (it might be END_ENTIRE or END_INSTANCE).
 498     //
 499     TmpDevicePath = DevicePathInstance;
 500     while (!IsDevicePathEndType (TmpDevicePath)) {
 501       TmpDevicePath = NextDevicePathNode (TmpDevicePath);
 502     }
 503
 504     //
 505     // Do not compare END node.
 506     //
 507     DevicePathSize = (UINTN)TmpDevicePath - (UINTN)DevicePathInstance;
 508     if ((FilePathSize == DevicePathSize) &&
 509         (CompareMem (DriverFilePath, DevicePathInstance, DevicePathSize) == 0)) {
 510       return TRUE;
 511     }
 512
 513     //
 514     // Get next instance.
 515     //
 516     DevicePathInstance = (EFI_DEVICE_PATH_PROTOCOL *)((UINTN)DevicePathInstance + DevicePathSize + DevicePathNodeLength(TmpDevicePath));
 517   } while (DevicePathSubType (TmpDevicePath) != END_ENTIRE_DEVICE_PATH_SUBTYPE);
 518
 519   return FALSE;
 520 }
 521
 522 /**
 523   Register DXE Core to memory profile.
 524
 525   @param HobStart       The start address of the HOB.
 526   @param ContextData    Memory profile context.
 527
 528   @retval TRUE      Register success.
 529   @retval FALSE     Register fail.
 530
 531 **/
 532 BOOLEAN
 533 RegisterDxeCore (
 534   IN VOID                           *HobStart,
 535   IN MEMORY_PROFILE_CONTEXT_DATA    *ContextData
 536   )
 537 {
 538   EFI_PEI_HOB_POINTERS              DxeCoreHob;
 539   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 540   PHYSICAL_ADDRESS                  ImageBase;
 541   UINT8                             TempBuffer[sizeof(MEDIA_FW_VOL_FILEPATH_DEVICE_PATH) + sizeof(EFI_DEVICE_PATH_PROTOCOL)];
 542   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FilePath;
 543
 544   ASSERT (ContextData != NULL);
 545
 546   //
 547   // Searching for image hob
 548   //
 549   DxeCoreHob.Raw          = HobStart;
 550   while ((DxeCoreHob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, DxeCoreHob.Raw)) != NULL) {
 551     if (CompareGuid (&DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.Name, &gEfiHobMemoryAllocModuleGuid)) {
 552       //
 553       // Find Dxe Core HOB
 554       //
 555       break;
 556     }
 557     DxeCoreHob.Raw = GET_NEXT_HOB (DxeCoreHob);
 558   }
 559   ASSERT (DxeCoreHob.Raw != NULL);
 560
 561   FilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) TempBuffer;
 562   EfiInitializeFwVolDevicepathNode (FilePath, &DxeCoreHob.MemoryAllocationModule->ModuleName);
 563   SetDevicePathEndNode (FilePath + 1);
 564
 565   if (!NeedRecordThisDriver ((EFI_DEVICE_PATH_PROTOCOL *) FilePath)) {
 566     return FALSE;
 567   }
 568
 569   ImageBase = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryBaseAddress;
 570   DriverInfoData = BuildDriverInfo (
 571                      ContextData,
 572                      &DxeCoreHob.MemoryAllocationModule->ModuleName,
 573                      ImageBase,
 574                      DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryLength,
 575                      DxeCoreHob.MemoryAllocationModule->EntryPoint,
 576                      InternalPeCoffGetSubsystem ((VOID *) (UINTN) ImageBase),
 577                      EFI_FV_FILETYPE_DXE_CORE
 578                      );
 579   if (DriverInfoData == NULL) {
 580     return FALSE;
 581   }
 582
 583   return TRUE;
 584 }
 585
 586 /**
 587   Initialize memory profile.
 588
 589   @param HobStart   The start address of the HOB.
 590
 591 **/
 592 VOID
 593 MemoryProfileInit (
 594   IN VOID   *HobStart
 595   )
 596 {
 597   MEMORY_PROFILE_CONTEXT_DATA   *ContextData;
 598
 599   if (!IS_UEFI_MEMORY_PROFILE_ENABLED) {
 600     return;
 601   }
 602
 603   ContextData = GetMemoryProfileContext ();
 604   if (ContextData != NULL) {
 605     return;
 606   }
 607
 608   mMemoryProfileGettingStatus = FALSE;
 609   if ((PcdGet8 (PcdMemoryProfilePropertyMask) & BIT7) != 0) {
 610     mMemoryProfileRecordingEnable = MEMORY_PROFILE_RECORDING_DISABLE;
 611   } else {
 612     mMemoryProfileRecordingEnable = MEMORY_PROFILE_RECORDING_ENABLE;
 613   }
 614   mMemoryProfileDriverPathSize = PcdGetSize (PcdMemoryProfileDriverPath);
 615   mMemoryProfileDriverPath = AllocateCopyPool (mMemoryProfileDriverPathSize, PcdGetPtr (PcdMemoryProfileDriverPath));
 616   mMemoryProfileContextPtr = &mMemoryProfileContext;
 617
 618   RegisterDxeCore (HobStart, &mMemoryProfileContext);
 619
 620   DEBUG ((EFI_D_INFO, "MemoryProfileInit MemoryProfileContext - 0x%x\n", &mMemoryProfileContext));
 621 }
 622
 623 /**
 624   Install memory profile protocol.
 625
 626 **/
 627 VOID
 628 MemoryProfileInstallProtocol (
 629   VOID
 630   )
 631 {
 632   EFI_HANDLE    Handle;
 633   EFI_STATUS    Status;
 634
 635   if (!IS_UEFI_MEMORY_PROFILE_ENABLED) {
 636     return;
 637   }
 638
 639   Handle = NULL;
 640   Status = CoreInstallMultipleProtocolInterfaces (
 641              &Handle,
 642              &gEdkiiMemoryProfileGuid,
 643              &mProfileProtocol,
 644              NULL
 645              );
 646   ASSERT_EFI_ERROR (Status);
 647 }
 648
 649 /**
 650   Get the GUID file name from the file path.
 651
 652   @param FilePath  File path.
 653
 654   @return The GUID file name from the file path.
 655
 656 **/
 657 EFI_GUID *
 658 GetFileNameFromFilePath (
 659   IN EFI_DEVICE_PATH_PROTOCOL   *FilePath
 660   )
 661 {
 662   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH     *ThisFilePath;
 663   EFI_GUID                              *FileName;
 664
 665   FileName = NULL;
 666   if (FilePath != NULL) {
 667     ThisFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) FilePath;
 668     while (!IsDevicePathEnd (ThisFilePath)) {
 669       FileName = EfiGetNameGuidFromFwVolDevicePathNode (ThisFilePath);
 670       if (FileName != NULL) {
 671         break;
 672       }
 673       ThisFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) NextDevicePathNode (ThisFilePath);
 674     }
 675   }
 676
 677   return FileName;
 678 }
 679
 680 /**
 681   Register image to memory profile.
 682
 683   @param DriverEntry    Image info.
 684   @param FileType       Image file type.
 685
 686   @return EFI_SUCCESS           Register successfully.
 687   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 688                                 or memory profile for the image is not required.
 689   @return EFI_OUT_OF_RESOURCES  No enough resource for this register.
 690
 691 **/
 692 EFI_STATUS
 693 RegisterMemoryProfileImage (
 694   IN LOADED_IMAGE_PRIVATE_DATA  *DriverEntry,
 695   IN EFI_FV_FILETYPE            FileType
 696   )
 697 {
 698   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
 699   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 700
 701   if (!IS_UEFI_MEMORY_PROFILE_ENABLED) {
 702     return EFI_UNSUPPORTED;
 703   }
 704
 705   if (!NeedRecordThisDriver (DriverEntry->Info.FilePath)) {
 706     return EFI_UNSUPPORTED;
 707   }
 708
 709   ContextData = GetMemoryProfileContext ();
 710   if (ContextData == NULL) {
 711     return EFI_UNSUPPORTED;
 712   }
 713
 714   DriverInfoData = BuildDriverInfo (
 715                      ContextData,
 716                      GetFileNameFromFilePath (DriverEntry->Info.FilePath),
 717                      DriverEntry->ImageContext.ImageAddress,
 718                      DriverEntry->ImageContext.ImageSize,
 719                      DriverEntry->ImageContext.EntryPoint,
 720                      DriverEntry->ImageContext.ImageType,
 721                      FileType
 722                      );
 723   if (DriverInfoData == NULL) {
 724     return EFI_OUT_OF_RESOURCES;
 725   }
 726
 727   return EFI_SUCCESS;
 728 }
 729
 730 /**
 731   Search image from memory profile.
 732
 733   @param ContextData    Memory profile context.
 734   @param FileName       Image file name.
 735   @param Address        Image Address.
 736
 737   @return Pointer to memory profile driver info.
 738
 739 **/
 740 MEMORY_PROFILE_DRIVER_INFO_DATA *
 741 GetMemoryProfileDriverInfoByFileNameAndAddress (
 742   IN MEMORY_PROFILE_CONTEXT_DATA    *ContextData,
 743   IN EFI_GUID                       *FileName,
 744   IN PHYSICAL_ADDRESS               Address
 745   )
 746 {
 747   MEMORY_PROFILE_DRIVER_INFO        *DriverInfo;
 748   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 749   LIST_ENTRY                        *DriverLink;
 750   LIST_ENTRY                        *DriverInfoList;
 751
 752   DriverInfoList = ContextData->DriverInfoList;
 753
 754   for (DriverLink = DriverInfoList->ForwardLink;
 755        DriverLink != DriverInfoList;
 756        DriverLink = DriverLink->ForwardLink) {
 757     DriverInfoData = CR (
 758                        DriverLink,
 759                        MEMORY_PROFILE_DRIVER_INFO_DATA,
 760                        Link,
 761                        MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
 762                        );
 763     DriverInfo = &DriverInfoData->DriverInfo;
 764     if ((CompareGuid (&DriverInfo->FileName, FileName)) &&
 765         (Address >= DriverInfo->ImageBase) &&
 766         (Address < (DriverInfo->ImageBase + DriverInfo->ImageSize))) {
 767       return DriverInfoData;
 768     }
 769   }
 770
 771   return NULL;
 772 }
 773
 774 /**
 775   Search image from memory profile.
 776   It will return image, if (Address >= ImageBuffer) AND (Address < ImageBuffer + ImageSize).
 777
 778   @param ContextData    Memory profile context.
 779   @param Address        Image or Function address.
 780
 781   @return Pointer to memory profile driver info.
 782
 783 **/
 784 MEMORY_PROFILE_DRIVER_INFO_DATA *
 785 GetMemoryProfileDriverInfoFromAddress (
 786   IN MEMORY_PROFILE_CONTEXT_DATA    *ContextData,
 787   IN PHYSICAL_ADDRESS               Address
 788   )
 789 {
 790   MEMORY_PROFILE_DRIVER_INFO        *DriverInfo;
 791   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 792   LIST_ENTRY                        *DriverLink;
 793   LIST_ENTRY                        *DriverInfoList;
 794
 795   DriverInfoList = ContextData->DriverInfoList;
 796
 797   for (DriverLink = DriverInfoList->ForwardLink;
 798        DriverLink != DriverInfoList;
 799        DriverLink = DriverLink->ForwardLink) {
 800     DriverInfoData = CR (
 801                        DriverLink,
 802                        MEMORY_PROFILE_DRIVER_INFO_DATA,
 803                        Link,
 804                        MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
 805                        );
 806     DriverInfo = &DriverInfoData->DriverInfo;
 807     if ((Address >= DriverInfo->ImageBase) &&
 808         (Address < (DriverInfo->ImageBase + DriverInfo->ImageSize))) {
 809       return DriverInfoData;
 810     }
 811   }
 812
 813   return NULL;
 814 }
 815
 816 /**
 817   Unregister image from memory profile.
 818
 819   @param DriverEntry    Image info.
 820
 821   @return EFI_SUCCESS           Unregister successfully.
 822   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 823                                 or memory profile for the image is not required.
 824   @return EFI_NOT_FOUND         The image is not found.
 825
 826 **/
 827 EFI_STATUS
 828 UnregisterMemoryProfileImage (
 829   IN LOADED_IMAGE_PRIVATE_DATA      *DriverEntry
 830   )
 831 {
 832   EFI_STATUS                        Status;
 833   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
 834   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 835   EFI_GUID                          *FileName;
 836   PHYSICAL_ADDRESS                  ImageAddress;
 837   VOID                              *EntryPointInImage;
 838
 839   if (!IS_UEFI_MEMORY_PROFILE_ENABLED) {
 840     return EFI_UNSUPPORTED;
 841   }
 842
 843   if (!NeedRecordThisDriver (DriverEntry->Info.FilePath)) {
 844     return EFI_UNSUPPORTED;
 845   }
 846
 847   ContextData = GetMemoryProfileContext ();
 848   if (ContextData == NULL) {
 849     return EFI_UNSUPPORTED;
 850   }
 851
 852   DriverInfoData = NULL;
 853   FileName = GetFileNameFromFilePath (DriverEntry->Info.FilePath);
 854   ImageAddress = DriverEntry->ImageContext.ImageAddress;
 855   if ((DriverEntry->ImageContext.EntryPoint < ImageAddress) || (DriverEntry->ImageContext.EntryPoint >= (ImageAddress + DriverEntry->ImageContext.ImageSize))) {
 856     //
 857     // If the EntryPoint is not in the range of image buffer, it should come from emulation environment.
 858     // So patch ImageAddress here to align the EntryPoint.
 859     //
 860     Status = InternalPeCoffGetEntryPoint ((VOID *) (UINTN) ImageAddress, &EntryPointInImage);
 861     ASSERT_EFI_ERROR (Status);
 862     ImageAddress = ImageAddress + (UINTN) DriverEntry->ImageContext.EntryPoint - (UINTN) EntryPointInImage;
 863   }
 864   if (FileName != NULL) {
 865     DriverInfoData = GetMemoryProfileDriverInfoByFileNameAndAddress (ContextData, FileName, ImageAddress);
 866   }
 867   if (DriverInfoData == NULL) {
 868     DriverInfoData = GetMemoryProfileDriverInfoFromAddress (ContextData, ImageAddress);
 869   }
 870   if (DriverInfoData == NULL) {
 871     return EFI_NOT_FOUND;
 872   }
 873
 874   ContextData->Context.TotalImageSize -= DriverInfoData->DriverInfo.ImageSize;
 875
 876   // Keep the ImageBase for RVA calculation in Application.
 877   //DriverInfoData->DriverInfo.ImageBase = 0;
 878   DriverInfoData->DriverInfo.ImageSize = 0;
 879
 880   if (DriverInfoData->DriverInfo.PeakUsage == 0) {
 881     ContextData->Context.ImageCount --;
 882     RemoveEntryList (&DriverInfoData->Link);
 883     //
 884     // Use CoreInternalFreePool() that will not update profile for this FreePool action.
 885     //
 886     CoreInternalFreePool (DriverInfoData, NULL);
 887   }
 888
 889   return EFI_SUCCESS;
 890 }
 891
 892 /**
 893   Return if this memory type needs to be recorded into memory profile.
 894   If BIOS memory type (0 ~ EfiMaxMemoryType - 1), it checks bit (1 << MemoryType).
 895   If OS memory type (0x80000000 ~ 0xFFFFFFFF), it checks bit63 - 0x8000000000000000.
 896   If OEM memory type (0x70000000 ~ 0x7FFFFFFF), it checks bit62 - 0x4000000000000000.
 897
 898   @param MemoryType     Memory type.
 899
 900   @retval TRUE          This memory type need to be recorded.
 901   @retval FALSE         This memory type need not to be recorded.
 902
 903 **/
 904 BOOLEAN
 905 CoreNeedRecordProfile (
 906   IN EFI_MEMORY_TYPE    MemoryType
 907   )
 908 {
 909   UINT64 TestBit;
 910
 911   if ((UINT32) MemoryType >= MEMORY_TYPE_OS_RESERVED_MIN) {
 912     TestBit = BIT63;
 913   } else if ((UINT32) MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {
 914     TestBit = BIT62;
 915   } else {
 916     TestBit = LShiftU64 (1, MemoryType);
 917   }
 918
 919   if ((PcdGet64 (PcdMemoryProfileMemoryType) & TestBit) != 0) {
 920     return TRUE;
 921   } else {
 922     return FALSE;
 923   }
 924 }
 925
 926 /**
 927   Convert EFI memory type to profile memory index. The rule is:
 928   If BIOS memory type (0 ~ EfiMaxMemoryType - 1), ProfileMemoryIndex = MemoryType.
 929   If OS memory type (0x80000000 ~ 0xFFFFFFFF), ProfileMemoryIndex = EfiMaxMemoryType.
 930   If OEM memory type (0x70000000 ~ 0x7FFFFFFF), ProfileMemoryIndex = EfiMaxMemoryType + 1.
 931
 932   @param MemoryType     Memory type.
 933
 934   @return Profile memory index.
 935
 936 **/
 937 UINTN
 938 GetProfileMemoryIndex (
 939   IN EFI_MEMORY_TYPE    MemoryType
 940   )
 941 {
 942   if ((UINT32) MemoryType >= MEMORY_TYPE_OS_RESERVED_MIN) {
 943     return EfiMaxMemoryType;
 944   } else if ((UINT32) MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {
 945     return EfiMaxMemoryType + 1;
 946   } else {
 947     return MemoryType;
 948   }
 949 }
 950
 951 /**
 952   Update memory profile Allocate information.
 953
 954   @param CallerAddress  Address of caller who call Allocate.
 955   @param Action         This Allocate action.
 956   @param MemoryType     Memory type.
 957   @param Size           Buffer size.
 958   @param Buffer         Buffer address.
 959   @param ActionString   String for memory profile action.
 960
 961   @return EFI_SUCCESS           Memory profile is updated.
 962   @return EFI_UNSUPPORTED       Memory profile is unsupported,
 963                                 or memory profile for the image is not required.
 964   @return EFI_OUT_OF_RESOURCES  No enough resource to update memory profile for allocate action.
 965
 966 **/
 967 EFI_STATUS
 968 CoreUpdateProfileAllocate (
 969   IN PHYSICAL_ADDRESS       CallerAddress,
 970   IN MEMORY_PROFILE_ACTION  Action,
 971   IN EFI_MEMORY_TYPE        MemoryType,
 972   IN UINTN                  Size,
 973   IN VOID                   *Buffer,
 974   IN CHAR8                  *ActionString OPTIONAL
 975   )
 976 {
 977   EFI_STATUS                        Status;
 978   MEMORY_PROFILE_CONTEXT            *Context;
 979   MEMORY_PROFILE_DRIVER_INFO        *DriverInfo;
 980   MEMORY_PROFILE_ALLOC_INFO         *AllocInfo;
 981   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
 982   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
 983   MEMORY_PROFILE_ALLOC_INFO_DATA    *AllocInfoData;
 984   UINTN                             ProfileMemoryIndex;
 985   MEMORY_PROFILE_ACTION             BasicAction;
 986   UINTN                             ActionStringSize;
 987   UINTN                             ActionStringOccupiedSize;
 988
 989   BasicAction = Action & MEMORY_PROFILE_ACTION_BASIC_MASK;
 990
 991   ContextData = GetMemoryProfileContext ();
 992   if (ContextData == NULL) {
 993     return EFI_UNSUPPORTED;
 994   }
 995
 996   DriverInfoData = GetMemoryProfileDriverInfoFromAddress (ContextData, CallerAddress);
 997   if (DriverInfoData == NULL) {
 998     return EFI_UNSUPPORTED;
 999   }
1000
1001   ActionStringSize = 0;
1002   ActionStringOccupiedSize = 0;
1003   if (ActionString != NULL) {
1004     ActionStringSize = AsciiStrSize (ActionString);
1005     ActionStringOccupiedSize = GET_OCCUPIED_SIZE (ActionStringSize, sizeof (UINT64));
1006   }
1007
1008   //
1009   // Use CoreInternalAllocatePool() that will not update profile for this AllocatePool action.
1010   //
1011   AllocInfoData = NULL;
1012   Status = CoreInternalAllocatePool (
1013              EfiBootServicesData,
1014              sizeof (*AllocInfoData) + ActionStringSize,
1015              (VOID **) &AllocInfoData
1016              );
1017   if (EFI_ERROR (Status)) {
1018     return EFI_OUT_OF_RESOURCES;
1019   }
1020   ASSERT (AllocInfoData != NULL);
1021
1022   //
1023   // Only update SequenceCount if and only if it is basic action.
1024   //
1025   if (Action == BasicAction) {
1026     ContextData->Context.SequenceCount ++;
1027   }
1028
1029   AllocInfo = &AllocInfoData->AllocInfo;
1030   AllocInfoData->Signature      = MEMORY_PROFILE_ALLOC_INFO_SIGNATURE;
1031   AllocInfo->Header.Signature   = MEMORY_PROFILE_ALLOC_INFO_SIGNATURE;
1032   AllocInfo->Header.Length      = (UINT16) (sizeof (MEMORY_PROFILE_ALLOC_INFO) + ActionStringOccupiedSize);
1033   AllocInfo->Header.Revision    = MEMORY_PROFILE_ALLOC_INFO_REVISION;
1034   AllocInfo->CallerAddress      = CallerAddress;
1035   AllocInfo->SequenceId         = ContextData->Context.SequenceCount;
1036   AllocInfo->Action             = Action;
1037   AllocInfo->MemoryType         = MemoryType;
1038   AllocInfo->Buffer             = (PHYSICAL_ADDRESS) (UINTN) Buffer;
1039   AllocInfo->Size               = Size;
1040   if (ActionString != NULL) {
1041     AllocInfo->ActionStringOffset = (UINT16) sizeof (MEMORY_PROFILE_ALLOC_INFO);
1042     AllocInfoData->ActionString = (CHAR8 *) (AllocInfoData + 1);
1043     CopyMem (AllocInfoData->ActionString, ActionString, ActionStringSize);
1044   } else {
1045     AllocInfo->ActionStringOffset = 0;
1046     AllocInfoData->ActionString = NULL;
1047   }
1048
1049   InsertTailList (DriverInfoData->AllocInfoList, &AllocInfoData->Link);
1050
1051   Context = &ContextData->Context;
1052   DriverInfo = &DriverInfoData->DriverInfo;
1053   DriverInfo->AllocRecordCount ++;
1054
1055   //
1056   // Update summary if and only if it is basic action.
1057   //
1058   if (Action == BasicAction) {
1059     ProfileMemoryIndex = GetProfileMemoryIndex (MemoryType);
1060
1061     DriverInfo->CurrentUsage += Size;
1062     if (DriverInfo->PeakUsage < DriverInfo->CurrentUsage) {
1063       DriverInfo->PeakUsage = DriverInfo->CurrentUsage;
1064     }
1065     DriverInfo->CurrentUsageByType[ProfileMemoryIndex] += Size;
1066     if (DriverInfo->PeakUsageByType[ProfileMemoryIndex] < DriverInfo->CurrentUsageByType[ProfileMemoryIndex]) {
1067       DriverInfo->PeakUsageByType[ProfileMemoryIndex] = DriverInfo->CurrentUsageByType[ProfileMemoryIndex];
1068     }
1069
1070     Context->CurrentTotalUsage += Size;
1071     if (Context->PeakTotalUsage < Context->CurrentTotalUsage) {
1072       Context->PeakTotalUsage = Context->CurrentTotalUsage;
1073     }
1074     Context->CurrentTotalUsageByType[ProfileMemoryIndex] += Size;
1075     if (Context->PeakTotalUsageByType[ProfileMemoryIndex] < Context->CurrentTotalUsageByType[ProfileMemoryIndex]) {
1076       Context->PeakTotalUsageByType[ProfileMemoryIndex] = Context->CurrentTotalUsageByType[ProfileMemoryIndex];
1077     }
1078   }
1079
1080   return EFI_SUCCESS;
1081 }
1082
1083 /**
1084   Get memory profile alloc info from memory profile.
1085
1086   @param DriverInfoData     Driver info.
1087   @param BasicAction        This Free basic action.
1088   @param Size               Buffer size.
1089   @param Buffer             Buffer address.
1090
1091   @return Pointer to memory profile alloc info.
1092
1093 **/
1094 MEMORY_PROFILE_ALLOC_INFO_DATA *
1095 GetMemoryProfileAllocInfoFromAddress (
1096   IN MEMORY_PROFILE_DRIVER_INFO_DATA    *DriverInfoData,
1097   IN MEMORY_PROFILE_ACTION              BasicAction,
1098   IN UINTN                              Size,
1099   IN VOID                               *Buffer
1100   )
1101 {
1102   LIST_ENTRY                        *AllocInfoList;
1103   LIST_ENTRY                        *AllocLink;
1104   MEMORY_PROFILE_ALLOC_INFO         *AllocInfo;
1105   MEMORY_PROFILE_ALLOC_INFO_DATA    *AllocInfoData;
1106
1107   AllocInfoList = DriverInfoData->AllocInfoList;
1108
1109   for (AllocLink = AllocInfoList->ForwardLink;
1110        AllocLink != AllocInfoList;
1111        AllocLink = AllocLink->ForwardLink) {
1112     AllocInfoData = CR (
1113                       AllocLink,
1114                       MEMORY_PROFILE_ALLOC_INFO_DATA,
1115                       Link,
1116                       MEMORY_PROFILE_ALLOC_INFO_SIGNATURE
1117                       );
1118     AllocInfo = &AllocInfoData->AllocInfo;
1119     if ((AllocInfo->Action & MEMORY_PROFILE_ACTION_BASIC_MASK) != BasicAction) {
1120       continue;
1121     }
1122     switch (BasicAction) {
1123       case MemoryProfileActionAllocatePages:
1124         if ((AllocInfo->Buffer <= (PHYSICAL_ADDRESS) (UINTN) Buffer) &&
1125             ((AllocInfo->Buffer + AllocInfo->Size) >= ((PHYSICAL_ADDRESS) (UINTN) Buffer + Size))) {
1126           return AllocInfoData;
1127         }
1128         break;
1129       case MemoryProfileActionAllocatePool:
1130         if (AllocInfo->Buffer == (PHYSICAL_ADDRESS) (UINTN) Buffer) {
1131           return AllocInfoData;
1132         }
1133         break;
1134       default:
1135         ASSERT (FALSE);
1136         break;
1137     }
1138   }
1139
1140   return NULL;
1141 }
1142
1143 /**
1144   Update memory profile Free information.
1145
1146   @param CallerAddress  Address of caller who call Free.
1147   @param Action         This Free action.
1148   @param Size           Buffer size.
1149   @param Buffer         Buffer address.
1150
1151   @return EFI_SUCCESS           Memory profile is updated.
1152   @return EFI_UNSUPPORTED       Memory profile is unsupported.
1153   @return EFI_NOT_FOUND         No matched allocate info found for free action.
1154
1155 **/
1156 EFI_STATUS
1157 CoreUpdateProfileFree (
1158   IN PHYSICAL_ADDRESS       CallerAddress,
1159   IN MEMORY_PROFILE_ACTION  Action,
1160   IN UINTN                  Size,
1161   IN VOID                   *Buffer
1162   )
1163 {
1164   MEMORY_PROFILE_CONTEXT           *Context;
1165   MEMORY_PROFILE_DRIVER_INFO       *DriverInfo;
1166   MEMORY_PROFILE_ALLOC_INFO        *AllocInfo;
1167   MEMORY_PROFILE_CONTEXT_DATA      *ContextData;
1168   MEMORY_PROFILE_DRIVER_INFO_DATA  *DriverInfoData;
1169   LIST_ENTRY                       *DriverLink;
1170   LIST_ENTRY                       *DriverInfoList;
1171   MEMORY_PROFILE_DRIVER_INFO_DATA  *ThisDriverInfoData;
1172   MEMORY_PROFILE_ALLOC_INFO_DATA   *AllocInfoData;
1173   UINTN                            ProfileMemoryIndex;
1174   MEMORY_PROFILE_ACTION            BasicAction;
1175   BOOLEAN                          Found;
1176
1177   BasicAction = Action & MEMORY_PROFILE_ACTION_BASIC_MASK;
1178
1179   ContextData = GetMemoryProfileContext ();
1180   if (ContextData == NULL) {
1181     return EFI_UNSUPPORTED;
1182   }
1183
1184   DriverInfoData = GetMemoryProfileDriverInfoFromAddress (ContextData, CallerAddress);
1185
1186   //
1187   // Do not return if DriverInfoData == NULL here,
1188   // because driver A might free memory allocated by driver B.
1189   //
1190
1191   //
1192   // Need use do-while loop to find all possible records,
1193   // because one address might be recorded multiple times.
1194   //
1195   Found = FALSE;
1196   AllocInfoData = NULL;
1197   do {
1198     if (DriverInfoData != NULL) {
1199       switch (BasicAction) {
1200         case MemoryProfileActionFreePages:
1201           AllocInfoData = GetMemoryProfileAllocInfoFromAddress (DriverInfoData, MemoryProfileActionAllocatePages, Size, Buffer);
1202           break;
1203         case MemoryProfileActionFreePool:
1204           AllocInfoData = GetMemoryProfileAllocInfoFromAddress (DriverInfoData, MemoryProfileActionAllocatePool, 0, Buffer);
1205           break;
1206         default:
1207           ASSERT (FALSE);
1208           AllocInfoData = NULL;
1209           break;
1210       }
1211     }
1212     if (AllocInfoData == NULL) {
1213       //
1214       // Legal case, because driver A might free memory allocated by driver B, by some protocol.
1215       //
1216       DriverInfoList = ContextData->DriverInfoList;
1217
1218       for (DriverLink = DriverInfoList->ForwardLink;
1219            DriverLink != DriverInfoList;
1220            DriverLink = DriverLink->ForwardLink) {
1221         ThisDriverInfoData = CR (
1222                                DriverLink,
1223                                MEMORY_PROFILE_DRIVER_INFO_DATA,
1224                                Link,
1225                                MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
1226                                );
1227         switch (BasicAction) {
1228           case MemoryProfileActionFreePages:
1229             AllocInfoData = GetMemoryProfileAllocInfoFromAddress (ThisDriverInfoData, MemoryProfileActionAllocatePages, Size, Buffer);
1230             break;
1231           case MemoryProfileActionFreePool:
1232             AllocInfoData = GetMemoryProfileAllocInfoFromAddress (ThisDriverInfoData, MemoryProfileActionAllocatePool, 0, Buffer);
1233             break;
1234           default:
1235             ASSERT (FALSE);
1236             AllocInfoData = NULL;
1237             break;
1238         }
1239         if (AllocInfoData != NULL) {
1240           DriverInfoData = ThisDriverInfoData;
1241           break;
1242         }
1243       }
1244
1245       if (AllocInfoData == NULL) {
1246         //
1247         // If (!Found), no matched allocate info is found for this free action.
1248         // It is because the specified memory type allocate actions have been filtered by
1249         // CoreNeedRecordProfile(), but free actions may have no memory type information,
1250         // they can not be filtered by CoreNeedRecordProfile(). Then, they will be
1251         // filtered here.
1252         //
1253         // If (Found), it is normal exit path.
1254         return (Found ? EFI_SUCCESS : EFI_NOT_FOUND);
1255       }
1256     }
1257
1258     ASSERT (DriverInfoData != NULL);
1259     ASSERT (AllocInfoData != NULL);
1260
1261     Found = TRUE;
1262
1263     Context = &ContextData->Context;
1264     DriverInfo = &DriverInfoData->DriverInfo;
1265     AllocInfo = &AllocInfoData->AllocInfo;
1266
1267     DriverInfo->AllocRecordCount --;
1268     //
1269     // Update summary if and only if it is basic action.
1270     //
1271     if (AllocInfo->Action == (AllocInfo->Action & MEMORY_PROFILE_ACTION_BASIC_MASK)) {
1272       ProfileMemoryIndex = GetProfileMemoryIndex (AllocInfo->MemoryType);
1273
1274       Context->CurrentTotalUsage -= AllocInfo->Size;
1275       Context->CurrentTotalUsageByType[ProfileMemoryIndex] -= AllocInfo->Size;
1276
1277       DriverInfo->CurrentUsage -= AllocInfo->Size;
1278       DriverInfo->CurrentUsageByType[ProfileMemoryIndex] -= AllocInfo->Size;
1279     }
1280
1281     RemoveEntryList (&AllocInfoData->Link);
1282
1283     if (BasicAction == MemoryProfileActionFreePages) {
1284       if (AllocInfo->Buffer != (PHYSICAL_ADDRESS) (UINTN) Buffer) {
1285         CoreUpdateProfileAllocate (
1286           AllocInfo->CallerAddress,
1287           AllocInfo->Action,
1288           AllocInfo->MemoryType,
1289           (UINTN) ((PHYSICAL_ADDRESS) (UINTN) Buffer - AllocInfo->Buffer),
1290           (VOID *) (UINTN) AllocInfo->Buffer,
1291           AllocInfoData->ActionString
1292           );
1293       }
1294       if (AllocInfo->Buffer + AllocInfo->Size != ((PHYSICAL_ADDRESS) (UINTN) Buffer + Size)) {
1295         CoreUpdateProfileAllocate (
1296           AllocInfo->CallerAddress,
1297           AllocInfo->Action,
1298           AllocInfo->MemoryType,
1299           (UINTN) ((AllocInfo->Buffer + AllocInfo->Size) - ((PHYSICAL_ADDRESS) (UINTN) Buffer + Size)),
1300           (VOID *) ((UINTN) Buffer + Size),
1301           AllocInfoData->ActionString
1302           );
1303       }
1304     }
1305
1306     //
1307     // Use CoreInternalFreePool() that will not update profile for this FreePool action.
1308     //
1309     CoreInternalFreePool (AllocInfoData, NULL);
1310   } while (TRUE);
1311 }
1312
1313 /**
1314   Update memory profile information.
1315
1316   @param CallerAddress  Address of caller who call Allocate or Free.
1317   @param Action         This Allocate or Free action.
1318   @param MemoryType     Memory type.
1319                         EfiMaxMemoryType means the MemoryType is unknown.
1320   @param Size           Buffer size.
1321   @param Buffer         Buffer address.
1322   @param ActionString   String for memory profile action.
1323                         Only needed for user defined allocate action.
1324
1325   @return EFI_SUCCESS           Memory profile is updated.
1326   @return EFI_UNSUPPORTED       Memory profile is unsupported,
1327                                 or memory profile for the image is not required,
1328                                 or memory profile for the memory type is not required.
1329   @return EFI_ACCESS_DENIED     It is during memory profile data getting.
1330   @return EFI_ABORTED           Memory profile recording is not enabled.
1331   @return EFI_OUT_OF_RESOURCES  No enough resource to update memory profile for allocate action.
1332   @return EFI_NOT_FOUND         No matched allocate info found for free action.
1333
1334 **/
1335 EFI_STATUS
1336 EFIAPI
1337 CoreUpdateProfile (
1338   IN PHYSICAL_ADDRESS       CallerAddress,
1339   IN MEMORY_PROFILE_ACTION  Action,
1340   IN EFI_MEMORY_TYPE        MemoryType,
1341   IN UINTN                  Size,       // Valid for AllocatePages/FreePages/AllocatePool
1342   IN VOID                   *Buffer,
1343   IN CHAR8                  *ActionString OPTIONAL
1344   )
1345 {
1346   EFI_STATUS                    Status;
1347   MEMORY_PROFILE_CONTEXT_DATA   *ContextData;
1348   MEMORY_PROFILE_ACTION         BasicAction;
1349
1350   if (!IS_UEFI_MEMORY_PROFILE_ENABLED) {
1351     return EFI_UNSUPPORTED;
1352   }
1353
1354   if (mMemoryProfileGettingStatus) {
1355     return EFI_ACCESS_DENIED;
1356   }
1357
1358   if (!mMemoryProfileRecordingEnable) {
1359     return EFI_ABORTED;
1360   }
1361
1362   //
1363   // Get the basic action to know how to process the record
1364   //
1365   BasicAction = Action & MEMORY_PROFILE_ACTION_BASIC_MASK;
1366
1367   //
1368   // EfiMaxMemoryType means the MemoryType is unknown.
1369   //
1370   if (MemoryType != EfiMaxMemoryType) {
1371     //
1372     // Only record limited MemoryType.
1373     //
1374     if (!CoreNeedRecordProfile (MemoryType)) {
1375       return EFI_UNSUPPORTED;
1376     }
1377   }
1378
1379   ContextData = GetMemoryProfileContext ();
1380   if (ContextData == NULL) {
1381     return EFI_UNSUPPORTED;
1382   }
1383
1384   CoreAcquireMemoryProfileLock ();
1385   switch (BasicAction) {
1386     case MemoryProfileActionAllocatePages:
1387       Status = CoreUpdateProfileAllocate (CallerAddress, Action, MemoryType, Size, Buffer, ActionString);
1388       break;
1389     case MemoryProfileActionFreePages:
1390       Status = CoreUpdateProfileFree (CallerAddress, Action, Size, Buffer);
1391       break;
1392     case MemoryProfileActionAllocatePool:
1393       Status = CoreUpdateProfileAllocate (CallerAddress, Action, MemoryType, Size, Buffer, ActionString);
1394       break;
1395     case MemoryProfileActionFreePool:
1396       Status = CoreUpdateProfileFree (CallerAddress, Action, 0, Buffer);
1397       break;
1398     default:
1399       ASSERT (FALSE);
1400       Status = EFI_UNSUPPORTED;
1401       break;
1402   }
1403   CoreReleaseMemoryProfileLock ();
1404
1405   return Status;
1406 }
1407
1408 ////////////////////
1409
1410 /**
1411   Get memory profile data size.
1412
1413   @return Memory profile data size.
1414
1415 **/
1416 UINTN
1417 MemoryProfileGetDataSize (
1418   VOID
1419   )
1420 {
1421   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
1422   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
1423   MEMORY_PROFILE_ALLOC_INFO_DATA    *AllocInfoData;
1424   LIST_ENTRY                        *DriverInfoList;
1425   LIST_ENTRY                        *DriverLink;
1426   LIST_ENTRY                        *AllocInfoList;
1427   LIST_ENTRY                        *AllocLink;
1428   UINTN                             TotalSize;
1429
1430
1431   ContextData = GetMemoryProfileContext ();
1432   if (ContextData == NULL) {
1433     return 0;
1434   }
1435
1436   TotalSize = sizeof (MEMORY_PROFILE_CONTEXT);
1437
1438   DriverInfoList = ContextData->DriverInfoList;
1439   for (DriverLink = DriverInfoList->ForwardLink;
1440        DriverLink != DriverInfoList;
1441        DriverLink = DriverLink->ForwardLink) {
1442     DriverInfoData = CR (
1443                        DriverLink,
1444                        MEMORY_PROFILE_DRIVER_INFO_DATA,
1445                        Link,
1446                        MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
1447                        );
1448     TotalSize += DriverInfoData->DriverInfo.Header.Length;
1449
1450     AllocInfoList = DriverInfoData->AllocInfoList;
1451     for (AllocLink = AllocInfoList->ForwardLink;
1452          AllocLink != AllocInfoList;
1453          AllocLink = AllocLink->ForwardLink) {
1454       AllocInfoData = CR (
1455                         AllocLink,
1456                         MEMORY_PROFILE_ALLOC_INFO_DATA,
1457                         Link,
1458                         MEMORY_PROFILE_ALLOC_INFO_SIGNATURE
1459                         );
1460       TotalSize += AllocInfoData->AllocInfo.Header.Length;
1461     }
1462   }
1463
1464   return TotalSize;
1465 }
1466
1467 /**
1468   Copy memory profile data.
1469
1470   @param ProfileBuffer  The buffer to hold memory profile data.
1471
1472 **/
1473 VOID
1474 MemoryProfileCopyData (
1475   IN VOID   *ProfileBuffer
1476   )
1477 {
1478   MEMORY_PROFILE_CONTEXT            *Context;
1479   MEMORY_PROFILE_DRIVER_INFO        *DriverInfo;
1480   MEMORY_PROFILE_ALLOC_INFO         *AllocInfo;
1481   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
1482   MEMORY_PROFILE_DRIVER_INFO_DATA   *DriverInfoData;
1483   MEMORY_PROFILE_ALLOC_INFO_DATA    *AllocInfoData;
1484   LIST_ENTRY                        *DriverInfoList;
1485   LIST_ENTRY                        *DriverLink;
1486   LIST_ENTRY                        *AllocInfoList;
1487   LIST_ENTRY                        *AllocLink;
1488   UINTN                             PdbSize;
1489   UINTN                             ActionStringSize;
1490
1491   ContextData = GetMemoryProfileContext ();
1492   if (ContextData == NULL) {
1493     return ;
1494   }
1495
1496   Context = ProfileBuffer;
1497   CopyMem (Context, &ContextData->Context, sizeof (MEMORY_PROFILE_CONTEXT));
1498   DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *) (Context + 1);
1499
1500   DriverInfoList = ContextData->DriverInfoList;
1501   for (DriverLink = DriverInfoList->ForwardLink;
1502        DriverLink != DriverInfoList;
1503        DriverLink = DriverLink->ForwardLink) {
1504     DriverInfoData = CR (
1505                        DriverLink,
1506                        MEMORY_PROFILE_DRIVER_INFO_DATA,
1507                        Link,
1508                        MEMORY_PROFILE_DRIVER_INFO_SIGNATURE
1509                        );
1510     CopyMem (DriverInfo, &DriverInfoData->DriverInfo, sizeof (MEMORY_PROFILE_DRIVER_INFO));
1511     if (DriverInfo->PdbStringOffset != 0) {
1512       PdbSize = AsciiStrSize (DriverInfoData->PdbString);
1513       CopyMem ((VOID *) ((UINTN) DriverInfo + DriverInfo->PdbStringOffset), DriverInfoData->PdbString, PdbSize);
1514     }
1515     AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) DriverInfo + DriverInfo->Header.Length);
1516
1517     AllocInfoList = DriverInfoData->AllocInfoList;
1518     for (AllocLink = AllocInfoList->ForwardLink;
1519          AllocLink != AllocInfoList;
1520          AllocLink = AllocLink->ForwardLink) {
1521       AllocInfoData = CR (
1522                         AllocLink,
1523                         MEMORY_PROFILE_ALLOC_INFO_DATA,
1524                         Link,
1525                         MEMORY_PROFILE_ALLOC_INFO_SIGNATURE
1526                         );
1527       CopyMem (AllocInfo, &AllocInfoData->AllocInfo, sizeof (MEMORY_PROFILE_ALLOC_INFO));
1528       if (AllocInfo->ActionStringOffset != 0) {
1529         ActionStringSize = AsciiStrSize (AllocInfoData->ActionString);
1530         CopyMem ((VOID *) ((UINTN) AllocInfo + AllocInfo->ActionStringOffset), AllocInfoData->ActionString, ActionStringSize);
1531       }
1532       AllocInfo = (MEMORY_PROFILE_ALLOC_INFO *) ((UINTN) AllocInfo + AllocInfo->Header.Length);
1533     }
1534
1535     DriverInfo = (MEMORY_PROFILE_DRIVER_INFO *)  AllocInfo;
1536   }
1537 }
1538
1539 /**
1540   Get memory profile data.
1541
1542   @param[in]      This              The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1543   @param[in, out] ProfileSize       On entry, points to the size in bytes of the ProfileBuffer.
1544                                     On return, points to the size of the data returned in ProfileBuffer.
1545   @param[out]     ProfileBuffer     Profile buffer.
1546
1547   @return EFI_SUCCESS               Get the memory profile data successfully.
1548   @return EFI_UNSUPPORTED           Memory profile is unsupported.
1549   @return EFI_BUFFER_TO_SMALL       The ProfileSize is too small for the resulting data.
1550                                     ProfileSize is updated with the size required.
1551
1552 **/
1553 EFI_STATUS
1554 EFIAPI
1555 ProfileProtocolGetData (
1556   IN     EDKII_MEMORY_PROFILE_PROTOCOL  *This,
1557   IN OUT UINT64                         *ProfileSize,
1558      OUT VOID                           *ProfileBuffer
1559   )
1560 {
1561   UINTN                                 Size;
1562   MEMORY_PROFILE_CONTEXT_DATA           *ContextData;
1563   BOOLEAN                               MemoryProfileGettingStatus;
1564
1565   ContextData = GetMemoryProfileContext ();
1566   if (ContextData == NULL) {
1567     return EFI_UNSUPPORTED;
1568   }
1569
1570   MemoryProfileGettingStatus = mMemoryProfileGettingStatus;
1571   mMemoryProfileGettingStatus = TRUE;
1572
1573   Size = MemoryProfileGetDataSize ();
1574
1575   if (*ProfileSize < Size) {
1576     *ProfileSize = Size;
1577     mMemoryProfileGettingStatus = MemoryProfileGettingStatus;
1578     return EFI_BUFFER_TOO_SMALL;
1579   }
1580
1581   *ProfileSize = Size;
1582   MemoryProfileCopyData (ProfileBuffer);
1583
1584   mMemoryProfileGettingStatus = MemoryProfileGettingStatus;
1585   return EFI_SUCCESS;
1586 }
1587
1588 /**
1589   Register image to memory profile.
1590
1591   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1592   @param[in] FilePath           File path of the image.
1593   @param[in] ImageBase          Image base address.
1594   @param[in] ImageSize          Image size.
1595   @param[in] FileType           File type of the image.
1596
1597   @return EFI_SUCCESS           Register successfully.
1598   @return EFI_UNSUPPORTED       Memory profile is unsupported,
1599                                 or memory profile for the image is not required.
1600   @return EFI_OUT_OF_RESOURCES  No enough resource for this register.
1601
1602 **/
1603 EFI_STATUS
1604 EFIAPI
1605 ProfileProtocolRegisterImage (
1606   IN EDKII_MEMORY_PROFILE_PROTOCOL  *This,
1607   IN EFI_DEVICE_PATH_PROTOCOL       *FilePath,
1608   IN PHYSICAL_ADDRESS               ImageBase,
1609   IN UINT64                         ImageSize,
1610   IN EFI_FV_FILETYPE                FileType
1611   )
1612 {
1613   EFI_STATUS                        Status;
1614   LOADED_IMAGE_PRIVATE_DATA         DriverEntry;
1615   VOID                              *EntryPointInImage;
1616
1617   ZeroMem (&DriverEntry, sizeof (DriverEntry));
1618   DriverEntry.Info.FilePath = FilePath;
1619   DriverEntry.ImageContext.ImageAddress = ImageBase;
1620   DriverEntry.ImageContext.ImageSize = ImageSize;
1621   Status = InternalPeCoffGetEntryPoint ((VOID *) (UINTN) ImageBase, &EntryPointInImage);
1622   ASSERT_EFI_ERROR (Status);
1623   DriverEntry.ImageContext.EntryPoint = (PHYSICAL_ADDRESS) (UINTN) EntryPointInImage;
1624   DriverEntry.ImageContext.ImageType = InternalPeCoffGetSubsystem ((VOID *) (UINTN) ImageBase);
1625
1626   return RegisterMemoryProfileImage (&DriverEntry, FileType);
1627 }
1628
1629 /**
1630   Unregister image from memory profile.
1631
1632   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1633   @param[in] FilePath           File path of the image.
1634   @param[in] ImageBase          Image base address.
1635   @param[in] ImageSize          Image size.
1636
1637   @return EFI_SUCCESS           Unregister successfully.
1638   @return EFI_UNSUPPORTED       Memory profile is unsupported,
1639                                 or memory profile for the image is not required.
1640   @return EFI_NOT_FOUND         The image is not found.
1641
1642 **/
1643 EFI_STATUS
1644 EFIAPI
1645 ProfileProtocolUnregisterImage (
1646   IN EDKII_MEMORY_PROFILE_PROTOCOL  *This,
1647   IN EFI_DEVICE_PATH_PROTOCOL       *FilePath,
1648   IN PHYSICAL_ADDRESS               ImageBase,
1649   IN UINT64                         ImageSize
1650   )
1651 {
1652   EFI_STATUS                        Status;
1653   LOADED_IMAGE_PRIVATE_DATA         DriverEntry;
1654   VOID                              *EntryPointInImage;
1655
1656   ZeroMem (&DriverEntry, sizeof (DriverEntry));
1657   DriverEntry.Info.FilePath = FilePath;
1658   DriverEntry.ImageContext.ImageAddress = ImageBase;
1659   DriverEntry.ImageContext.ImageSize = ImageSize;
1660   Status = InternalPeCoffGetEntryPoint ((VOID *) (UINTN) ImageBase, &EntryPointInImage);
1661   ASSERT_EFI_ERROR (Status);
1662   DriverEntry.ImageContext.EntryPoint = (PHYSICAL_ADDRESS) (UINTN) EntryPointInImage;
1663
1664   return UnregisterMemoryProfileImage (&DriverEntry);
1665 }
1666
1667 /**
1668   Get memory profile recording state.
1669
1670   @param[in]  This              The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1671   @param[out] RecordingState    Recording state.
1672
1673   @return EFI_SUCCESS           Memory profile recording state is returned.
1674   @return EFI_UNSUPPORTED       Memory profile is unsupported.
1675   @return EFI_INVALID_PARAMETER RecordingState is NULL.
1676
1677 **/
1678 EFI_STATUS
1679 EFIAPI
1680 ProfileProtocolGetRecordingState (
1681   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
1682   OUT BOOLEAN                           *RecordingState
1683   )
1684 {
1685   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
1686
1687   ContextData = GetMemoryProfileContext ();
1688   if (ContextData == NULL) {
1689     return EFI_UNSUPPORTED;
1690   }
1691
1692   if (RecordingState == NULL) {
1693     return EFI_INVALID_PARAMETER;
1694   }
1695   *RecordingState = mMemoryProfileRecordingEnable;
1696   return EFI_SUCCESS;
1697 }
1698
1699 /**
1700   Set memory profile recording state.
1701
1702   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1703   @param[in] RecordingState     Recording state.
1704
1705   @return EFI_SUCCESS           Set memory profile recording state successfully.
1706   @return EFI_UNSUPPORTED       Memory profile is unsupported.
1707
1708 **/
1709 EFI_STATUS
1710 EFIAPI
1711 ProfileProtocolSetRecordingState (
1712   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
1713   IN BOOLEAN                            RecordingState
1714   )
1715 {
1716   MEMORY_PROFILE_CONTEXT_DATA       *ContextData;
1717
1718   ContextData = GetMemoryProfileContext ();
1719   if (ContextData == NULL) {
1720     return EFI_UNSUPPORTED;
1721   }
1722
1723   mMemoryProfileRecordingEnable = RecordingState;
1724   return EFI_SUCCESS;
1725 }
1726
1727 /**
1728   Record memory profile of multilevel caller.
1729
1730   @param[in] This               The EDKII_MEMORY_PROFILE_PROTOCOL instance.
1731   @param[in] CallerAddress      Address of caller.
1732   @param[in] Action             Memory profile action.
1733   @param[in] MemoryType         Memory type.
1734                                 EfiMaxMemoryType means the MemoryType is unknown.
1735   @param[in] Buffer             Buffer address.
1736   @param[in] Size               Buffer size.
1737   @param[in] ActionString       String for memory profile action.
1738                                 Only needed for user defined allocate action.
1739
1740   @return EFI_SUCCESS           Memory profile is updated.
1741   @return EFI_UNSUPPORTED       Memory profile is unsupported,
1742                                 or memory profile for the image is not required,
1743                                 or memory profile for the memory type is not required.
1744   @return EFI_ACCESS_DENIED     It is during memory profile data getting.
1745   @return EFI_ABORTED           Memory profile recording is not enabled.
1746   @return EFI_OUT_OF_RESOURCES  No enough resource to update memory profile for allocate action.
1747   @return EFI_NOT_FOUND         No matched allocate info found for free action.
1748
1749 **/
1750 EFI_STATUS
1751 EFIAPI
1752 ProfileProtocolRecord (
1753   IN EDKII_MEMORY_PROFILE_PROTOCOL      *This,
1754   IN PHYSICAL_ADDRESS                   CallerAddress,
1755   IN MEMORY_PROFILE_ACTION              Action,
1756   IN EFI_MEMORY_TYPE                    MemoryType,
1757   IN VOID                               *Buffer,
1758   IN UINTN                              Size,
1759   IN CHAR8                              *ActionString OPTIONAL
1760   )
1761 {
1762   return CoreUpdateProfile (CallerAddress, Action, MemoryType, Size, Buffer, ActionString);
1763 }
1764
1765 ////////////////////