tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MdeModulePkg/PiSmmCore: Add MemoryAttributes support. 

The SMM memory attribute table concept is similar to UEFI
memory attribute table.

The new file MdeModulePkg/Core/PiSmmCore/MemoryAttributesTable.c
and the new code in MdeModulePkg/Core/PiSmmCore/Page.c
are based on the algorithms and implementation from
MdeModulePkg/Core/Dxe/Misc/MemoryAttributesTable.c
and MdeModulePkg/Core/Dxe/Mem/Page.c.

These new components are based on the Memory Attributes Table
feature from the UEFI Specification and the existing DXE Core
implementation that supports that feature.

This SMM MemoryAttributes table is produced at SmmEndOfDxe event.
So that the consumer (PiSmmCpu) may consult this table
to set memory attribute in page table.

This patch also installs LoadedImage protocol to SMM
protocol database, so that the SMM image info can be
got easily to construct the PiSmmMemoryAttributes table.

Cc: Jeff Fan <jeff.fan@intel.com>
Cc: Feng Tian <feng.tian@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Jiewen Yao <jiewen.yao@intel.com>
Tested-by: Laszlo Ersek <lersek@redhat.com>
Reviewed-by: Jeff Fan <jeff.fan@intel.com>
Reviewed-by: Michael D Kinney <michael.d.kinney@intel.com>
This commit is contained in:
Jiewen Yao 2016-10-23 23:14:00 +08:00
parent 33745854f4
commit 285a682c78
7 changed files with 2473 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
MdeModulePkg/Core/PiSmmCore/Dispatcher.c
View File

@ -580,6 +580,11 @@ SmmLoadImage (
DriverEntry->LoadedImage->SystemTable = gST;
DriverEntry->LoadedImage->DeviceHandle = DeviceHandle;
DriverEntry->SmmLoadedImage.Revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
DriverEntry->SmmLoadedImage.ParentHandle = gSmmCorePrivate->SmmIplImageHandle;
DriverEntry->SmmLoadedImage.SystemTable = gST;
DriverEntry->SmmLoadedImage.DeviceHandle = DeviceHandle;
//
// Make an EfiBootServicesData buffer copy of FilePath
//
@ -598,6 +603,25 @@ SmmLoadImage (
DriverEntry->LoadedImage->ImageCodeType = EfiRuntimeServicesCode;
DriverEntry->LoadedImage->ImageDataType = EfiRuntimeServicesData;
//
// Make a buffer copy of FilePath
//
Status = SmmAllocatePool (EfiRuntimeServicesData, GetDevicePathSize(FilePath), (VOID **)&DriverEntry->SmmLoadedImage.FilePath);
if (EFI_ERROR (Status)) {
if (Buffer != NULL) {
gBS->FreePool (Buffer);
}
gBS->FreePool (DriverEntry->LoadedImage->FilePath);
SmmFreePages (DstBuffer, PageCount);
return Status;
}
CopyMem (DriverEntry->SmmLoadedImage.FilePath, FilePath, GetDevicePathSize(FilePath));
DriverEntry->SmmLoadedImage.ImageBase = (VOID *)(UINTN)DriverEntry->ImageBuffer;
DriverEntry->SmmLoadedImage.ImageSize = ImageContext.ImageSize;
DriverEntry->SmmLoadedImage.ImageCodeType = EfiRuntimeServicesCode;
DriverEntry->SmmLoadedImage.ImageDataType = EfiRuntimeServicesData;
//
// Create a new image handle in the UEFI handle database for the SMM Driver
//
@ -608,6 +632,17 @@ SmmLoadImage (
NULL
);
//
// Create a new image handle in the SMM handle database for the SMM Driver
//
DriverEntry->SmmImageHandle = NULL;
Status = SmmInstallProtocolInterface (
&DriverEntry->SmmImageHandle,
&gEfiLoadedImageProtocolGuid,
EFI_NATIVE_INTERFACE,
&DriverEntry->SmmLoadedImage
);
PERF_START (DriverEntry->ImageHandle, "LoadImage:", NULL, Tick);
PERF_END (DriverEntry->ImageHandle, "LoadImage:", NULL, 0);
@ -896,6 +931,16 @@ SmmDispatcher (
}
gBS->FreePool (DriverEntry->LoadedImage);
}
Status = SmmUninstallProtocolInterface (
DriverEntry->SmmImageHandle,
&gEfiLoadedImageProtocolGuid,
&DriverEntry->SmmLoadedImage
);
if (!EFI_ERROR(Status)) {
if (DriverEntry->SmmLoadedImage.FilePath != NULL) {
SmmFreePool (DriverEntry->SmmLoadedImage.FilePath);
}
}
}
REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
@ -1327,6 +1372,27 @@ SmmDriverDispatchHandler (
mSmmCoreLoadedImage->DeviceHandle = FvHandle;
}
if (mSmmCoreDriverEntry->SmmLoadedImage.FilePath == NULL) {
//
// Maybe one special FV contains only one SMM_CORE module, so its device path must
// be initialized completely.
//
EfiInitializeFwVolDevicepathNode (&mFvDevicePath.File, &NameGuid);
SetDevicePathEndNode (&mFvDevicePath.End);
//
// Make a buffer copy FilePath
//
Status = SmmAllocatePool (
EfiRuntimeServicesData,
GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *)&mFvDevicePath),
(VOID **)&mSmmCoreDriverEntry->SmmLoadedImage.FilePath
);
ASSERT_EFI_ERROR (Status);
CopyMem (mSmmCoreDriverEntry->SmmLoadedImage.FilePath, &mFvDevicePath, GetDevicePathSize((EFI_DEVICE_PATH_PROTOCOL *)&mFvDevicePath));
mSmmCoreDriverEntry->SmmLoadedImage.DeviceHandle = FvHandle;
}
} else {
SmmAddToDriverList (Fv, FvHandle, &NameGuid);
}

1509
MdeModulePkg/Core/PiSmmCore/MemoryAttributesTable.c Normal file
View File

File diff suppressed because it is too large Load Diff

775
MdeModulePkg/Core/PiSmmCore/Page.c
View File

@ -2,22 +2,572 @@
SMM Memory page management functions.
Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available
under the terms and conditions of the BSD License which accompanies this
distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
This program and the accompanying materials are licensed and made available
under the terms and conditions of the BSD License which accompanies this
distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "PiSmmCore.h"
#include <Library/SmmServicesTableLib.h>
#define TRUNCATE_TO_PAGES(a) ((a) >> EFI_PAGE_SHIFT)
LIST_ENTRY mSmmMemoryMap = INITIALIZE_LIST_HEAD_VARIABLE (mSmmMemoryMap);
//
// For GetMemoryMap()
//
#define MEMORY_MAP_SIGNATURE SIGNATURE_32('m','m','a','p')
typedef struct {
UINTN Signature;
LIST_ENTRY Link;
BOOLEAN FromStack;
EFI_MEMORY_TYPE Type;
UINT64 Start;
UINT64 End;
} MEMORY_MAP;
LIST_ENTRY gMemoryMap = INITIALIZE_LIST_HEAD_VARIABLE (gMemoryMap);
#define MAX_MAP_DEPTH 6
///
/// mMapDepth - depth of new descriptor stack
///
UINTN mMapDepth = 0;
///
/// mMapStack - space to use as temp storage to build new map descriptors
///
MEMORY_MAP mMapStack[MAX_MAP_DEPTH];
UINTN mFreeMapStack = 0;
///
/// This list maintain the free memory map list
///
LIST_ENTRY mFreeMemoryMapEntryList = INITIALIZE_LIST_HEAD_VARIABLE (mFreeMemoryMapEntryList);
/**
Allocates pages from the memory map.
@param[in] Type The type of allocation to perform.
@param[in] MemoryType The type of memory to turn the allocated pages
into.
@param[in] NumberOfPages The number of pages to allocate.
@param[out] Memory A pointer to receive the base allocated memory
address.
@param[in] AddRegion If this memory is new added region.
@retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in spec.
@retval EFI_NOT_FOUND Could not allocate pages match the requirement.
@retval EFI_OUT_OF_RESOURCES No enough pages to allocate.
@retval EFI_SUCCESS Pages successfully allocated.
**/
EFI_STATUS
SmmInternalAllocatePagesEx (
IN EFI_ALLOCATE_TYPE Type,
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN NumberOfPages,
OUT EFI_PHYSICAL_ADDRESS *Memory,
IN BOOLEAN AddRegion
);
/**
Internal function. Deque a descriptor entry from the mFreeMemoryMapEntryList.
If the list is emtry, then allocate a new page to refuel the list.
Please Note this algorithm to allocate the memory map descriptor has a property
that the memory allocated for memory entries always grows, and will never really be freed.
@return The Memory map descriptor dequed from the mFreeMemoryMapEntryList
**/
MEMORY_MAP *
AllocateMemoryMapEntry (
VOID
)
{
EFI_PHYSICAL_ADDRESS Mem;
EFI_STATUS Status;
MEMORY_MAP* FreeDescriptorEntries;
MEMORY_MAP* Entry;
UINTN Index;
//DEBUG((DEBUG_INFO, "AllocateMemoryMapEntry\n"));
if (IsListEmpty (&mFreeMemoryMapEntryList)) {
//DEBUG((DEBUG_INFO, "mFreeMemoryMapEntryList is empty\n"));
//
// The list is empty, to allocate one page to refuel the list
//
Status = SmmInternalAllocatePagesEx (
AllocateAnyPages,
EfiRuntimeServicesData,
EFI_SIZE_TO_PAGES(DEFAULT_PAGE_ALLOCATION),
&Mem,
TRUE
);
ASSERT_EFI_ERROR (Status);
if(!EFI_ERROR (Status)) {
FreeDescriptorEntries = (MEMORY_MAP *)(UINTN)Mem;
//DEBUG((DEBUG_INFO, "New FreeDescriptorEntries - 0x%x\n", FreeDescriptorEntries));
//
// Enque the free memmory map entries into the list
//
for (Index = 0; Index< DEFAULT_PAGE_ALLOCATION / sizeof(MEMORY_MAP); Index++) {
FreeDescriptorEntries[Index].Signature = MEMORY_MAP_SIGNATURE;
InsertTailList (&mFreeMemoryMapEntryList, &FreeDescriptorEntries[Index].Link);
}
} else {
return NULL;
}
}
//
// dequeue the first descriptor from the list
//
Entry = CR (mFreeMemoryMapEntryList.ForwardLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
RemoveEntryList (&Entry->Link);
return Entry;
}
/**
Internal function. Moves any memory descriptors that are on the
temporary descriptor stack to heap.
**/
VOID
CoreFreeMemoryMapStack (
VOID
)
{
MEMORY_MAP *Entry;
//
// If already freeing the map stack, then return
//
if (mFreeMapStack != 0) {
ASSERT (FALSE);
return ;
}
//
// Move the temporary memory descriptor stack into pool
//
mFreeMapStack += 1;
while (mMapDepth != 0) {
//
// Deque an memory map entry from mFreeMemoryMapEntryList
//
Entry = AllocateMemoryMapEntry ();
ASSERT (Entry);
//
// Update to proper entry
//
mMapDepth -= 1;
if (mMapStack[mMapDepth].Link.ForwardLink != NULL) {
CopyMem (Entry , &mMapStack[mMapDepth], sizeof (MEMORY_MAP));
Entry->FromStack = FALSE;
//
// Move this entry to general memory
//
InsertTailList (&mMapStack[mMapDepth].Link, &Entry->Link);
RemoveEntryList (&mMapStack[mMapDepth].Link);
mMapStack[mMapDepth].Link.ForwardLink = NULL;
}
}
mFreeMapStack -= 1;
}
/**
Insert new entry from memory map.
@param[in] Link The old memory map entry to be linked.
@param[in] Start The start address of new memory map entry.
@param[in] End The end address of new memory map entry.
@param[in] Type The type of new memory map entry.
@param[in] Next If new entry is inserted to the next of old entry.
@param[in] AddRegion If this memory is new added region.
**/
VOID
InsertNewEntry (
IN LIST_ENTRY *Link,
IN UINT64 Start,
IN UINT64 End,
IN EFI_MEMORY_TYPE Type,
IN BOOLEAN Next,
IN BOOLEAN AddRegion
)
{
MEMORY_MAP *Entry;
Entry = &mMapStack[mMapDepth];
mMapDepth += 1;
ASSERT (mMapDepth < MAX_MAP_DEPTH);
Entry->FromStack = TRUE;
Entry->Signature = MEMORY_MAP_SIGNATURE;
Entry->Type = Type;
Entry->Start = Start;
Entry->End = End;
if (Next) {
InsertHeadList (Link, &Entry->Link);
} else {
InsertTailList (Link, &Entry->Link);
}
}
/**
Remove old entry from memory map.
@param[in] Entry Memory map entry to be removed.
**/
VOID
RemoveOldEntry (
IN MEMORY_MAP *Entry
)
{
RemoveEntryList (&Entry->Link);
if (!Entry->FromStack) {
InsertTailList (&mFreeMemoryMapEntryList, &Entry->Link);
}
}
/**
Update SMM memory map entry.
@param[in] Type The type of allocation to perform.
@param[in] Memory The base of memory address.
@param[in] NumberOfPages The number of pages to allocate.
@param[in] AddRegion If this memory is new added region.
**/
VOID
ConvertSmmMemoryMapEntry (
IN EFI_MEMORY_TYPE Type,
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NumberOfPages,
IN BOOLEAN AddRegion
)
{
LIST_ENTRY *Link;
MEMORY_MAP *Entry;
MEMORY_MAP *NextEntry;
LIST_ENTRY *NextLink;
MEMORY_MAP *PreviousEntry;
LIST_ENTRY *PreviousLink;
EFI_PHYSICAL_ADDRESS Start;
EFI_PHYSICAL_ADDRESS End;
Start = Memory;
End = Memory + EFI_PAGES_TO_SIZE(NumberOfPages) - 1;
//
// Exclude memory region
//
Link = gMemoryMap.ForwardLink;
while (Link != &gMemoryMap) {
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
Link = Link->ForwardLink;
//
// ---------------------------------------------------
// | +----------+ +------+ +------+ +------+ |
// ---|gMemoryMep|---|Entry1|---|Entry2|---|Entry3|---
// +----------+ ^ +------+ +------+ +------+
// |
// +------+
// |EntryX|
// +------+
//
if (Entry->Start > End) {
if ((Entry->Start == End + 1) && (Entry->Type == Type)) {
Entry->Start = Start;
return ;
}
InsertNewEntry (
&Entry->Link,
Start,
End,
Type,
FALSE,
AddRegion
);
return ;
}
if ((Entry->Start <= Start) && (Entry->End >= End)) {
if (Entry->Type != Type) {
if (Entry->Start < Start) {
//
// ---------------------------------------------------
// | +----------+ +------+ +------+ +------+ |
// ---|gMemoryMep|---|Entry1|---|EntryX|---|Entry3|---
// +----------+ +------+ ^ +------+ +------+
// |
// +------+
// |EntryA|
// +------+
//
InsertNewEntry (
&Entry->Link,
Entry->Start,
Start - 1,
Entry->Type,
FALSE,
AddRegion
);
}
if (Entry->End > End) {
//
// ---------------------------------------------------
// | +----------+ +------+ +------+ +------+ |
// ---|gMemoryMep|---|Entry1|---|EntryX|---|Entry3|---
// +----------+ +------+ +------+ ^ +------+
// |
// +------+
// |EntryZ|
// +------+
//
InsertNewEntry (
&Entry->Link,
End + 1,
Entry->End,
Entry->Type,
TRUE,
AddRegion
);
}
//
// Update this node
//
Entry->Start = Start;
Entry->End = End;
Entry->Type = Type;
//
// Check adjacent
//
NextLink = Entry->Link.ForwardLink;
if (NextLink != &gMemoryMap) {
NextEntry = CR (NextLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
//
// ---------------------------------------------------
// | +----------+ +------+ +-----------------+ |
// ---|gMemoryMep|---|Entry1|---|EntryX Entry3|---
// +----------+ +------+ +-----------------+
//
if ((Entry->Type == NextEntry->Type) && (Entry->End + 1 == NextEntry->Start)) {
Entry->End = NextEntry->End;
RemoveOldEntry (NextEntry);
}
}
PreviousLink = Entry->Link.BackLink;
if (PreviousLink != &gMemoryMap) {
PreviousEntry = CR (PreviousLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
//
// ---------------------------------------------------
// | +----------+ +-----------------+ +------+ |
// ---|gMemoryMep|---|Entry1 EntryX|---|Entry3|---
// +----------+ +-----------------+ +------+
//
if ((PreviousEntry->Type == Entry->Type) && (PreviousEntry->End + 1 == Entry->Start)) {
PreviousEntry->End = Entry->End;
RemoveOldEntry (Entry);
}
}
}
return ;
}
}
//
// ---------------------------------------------------
// | +----------+ +------+ +------+ +------+ |
// ---|gMemoryMep|---|Entry1|---|Entry2|---|Entry3|---
// +----------+ +------+ +------+ +------+ ^
// |
// +------+
// |EntryX|
// +------+
//
Link = gMemoryMap.BackLink;
if (Link != &gMemoryMap) {
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
if ((Entry->End + 1 == Start) && (Entry->Type == Type)) {
Entry->End = End;
return ;
}
}
InsertNewEntry (
&gMemoryMap,
Start,
End,
Type,
FALSE,
AddRegion
);
return ;
}
/**
Return the count of Smm memory map entry.
@return The count of Smm memory map entry.
**/
UINTN
GetSmmMemoryMapEntryCount (
VOID
)
{
LIST_ENTRY *Link;
UINTN Count;
Count = 0;
Link = gMemoryMap.ForwardLink;
while (Link != &gMemoryMap) {
Link = Link->ForwardLink;
Count++;
}
return Count;
}
/**
Dump Smm memory map entry.
**/
VOID
DumpSmmMemoryMapEntry (
VOID
)
{
LIST_ENTRY *Link;
MEMORY_MAP *Entry;
EFI_PHYSICAL_ADDRESS Last;
Last = 0;
DEBUG ((DEBUG_INFO, "DumpSmmMemoryMapEntry:\n"));
Link = gMemoryMap.ForwardLink;
while (Link != &gMemoryMap) {
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
Link = Link->ForwardLink;
if ((Last != 0) && (Last != (UINT64)-1)) {
if (Last + 1 != Entry->Start) {
Last = (UINT64)-1;
} else {
Last = Entry->End;
}
} else if (Last == 0) {
Last = Entry->End;
}
DEBUG ((DEBUG_INFO, "Entry (Link - 0x%x)\n", &Entry->Link));
DEBUG ((DEBUG_INFO, " Signature - 0x%x\n", Entry->Signature));
DEBUG ((DEBUG_INFO, " Link.ForwardLink - 0x%x\n", Entry->Link.ForwardLink));
DEBUG ((DEBUG_INFO, " Link.BackLink - 0x%x\n", Entry->Link.BackLink));
DEBUG ((DEBUG_INFO, " Type - 0x%x\n", Entry->Type));
DEBUG ((DEBUG_INFO, " Start - 0x%016lx\n", Entry->Start));
DEBUG ((DEBUG_INFO, " End - 0x%016lx\n", Entry->End));
}
ASSERT (Last != (UINT64)-1);
}
/**
Dump Smm memory map.
**/
VOID
DumpSmmMemoryMap (
VOID
)
{
LIST_ENTRY *Node;
FREE_PAGE_LIST *Pages;
DEBUG ((DEBUG_INFO, "DumpSmmMemoryMap\n"));
Pages = NULL;
Node = mSmmMemoryMap.ForwardLink;
while (Node != &mSmmMemoryMap) {
Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);
DEBUG ((DEBUG_INFO, "Pages - 0x%x\n", Pages));
DEBUG ((DEBUG_INFO, "Pages->NumberOfPages - 0x%x\n", Pages->NumberOfPages));
Node = Node->ForwardLink;
}
}
/**
Check if a Smm base~length is in Smm memory map.
@param[in] Base The base address of Smm memory to be checked.
@param[in] Length THe length of Smm memory to be checked.
@retval TRUE Smm base~length is in smm memory map.
@retval FALSE Smm base~length is in smm memory map.
**/
BOOLEAN
SmmMemoryMapConsistencyCheckRange (
IN EFI_PHYSICAL_ADDRESS Base,
IN UINTN Length
)
{
LIST_ENTRY *Link;
MEMORY_MAP *Entry;
BOOLEAN Result;
Result = FALSE;
Link = gMemoryMap.ForwardLink;
while (Link != &gMemoryMap) {
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
Link = Link->ForwardLink;
if (Entry->Type != EfiConventionalMemory) {
continue;
}
if (Entry->Start == Base && Entry->End == Base + Length - 1) {
Result = TRUE;
break;
}
}
return Result;
}
/**
Check the consistency of Smm memory map.
**/
VOID
SmmMemoryMapConsistencyCheck (
VOID
)
{
LIST_ENTRY *Node;
FREE_PAGE_LIST *Pages;
BOOLEAN Result;
Pages = NULL;
Node = mSmmMemoryMap.ForwardLink;
while (Node != &mSmmMemoryMap) {
Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);
Result = SmmMemoryMapConsistencyCheckRange ((EFI_PHYSICAL_ADDRESS)(UINTN)Pages, (UINTN)EFI_PAGES_TO_SIZE(Pages->NumberOfPages));
ASSERT (Result);
Node = Node->ForwardLink;
}
}
/**
Internal Function. Allocate n pages from given free page node.
@ -131,12 +681,13 @@ InternalAllocAddress (
/**
Allocates pages from the memory map.
@param Type The type of allocation to perform.
@param MemoryType The type of memory to turn the allocated pages
into.
@param NumberOfPages The number of pages to allocate.
@param Memory A pointer to receive the base allocated memory
address.
@param[in] Type The type of allocation to perform.
@param[in] MemoryType The type of memory to turn the allocated pages
into.
@param[in] NumberOfPages The number of pages to allocate.
@param[out] Memory A pointer to receive the base allocated memory
address.
@param[in] AddRegion If this memory is new added region.
@retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in spec.
@retval EFI_NOT_FOUND Could not allocate pages match the requirement.
@ -145,12 +696,12 @@ InternalAllocAddress (
**/
EFI_STATUS
EFIAPI
SmmInternalAllocatePages (
SmmInternalAllocatePagesEx (
IN EFI_ALLOCATE_TYPE Type,
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN NumberOfPages,
OUT EFI_PHYSICAL_ADDRESS *Memory
OUT EFI_PHYSICAL_ADDRESS *Memory,
IN BOOLEAN AddRegion
)
{
UINTN RequestedAddress;
@ -179,7 +730,7 @@ SmmInternalAllocatePages (
);
if (*Memory == (UINTN)-1) {
return EFI_OUT_OF_RESOURCES;
}
}
break;
case AllocateAddress:
*Memory = InternalAllocAddress (
@ -194,9 +745,46 @@ SmmInternalAllocatePages (
default:
return EFI_INVALID_PARAMETER;
}
//
// Update SmmMemoryMap here.
//
ConvertSmmMemoryMapEntry (MemoryType, *Memory, NumberOfPages, AddRegion);
if (!AddRegion) {
CoreFreeMemoryMapStack();
}
return EFI_SUCCESS;
}
/**
Allocates pages from the memory map.
@param[in] Type The type of allocation to perform.
@param[in] MemoryType The type of memory to turn the allocated pages
into.
@param[in] NumberOfPages The number of pages to allocate.
@param[out] Memory A pointer to receive the base allocated memory
address.
@retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in spec.
@retval EFI_NOT_FOUND Could not allocate pages match the requirement.
@retval EFI_OUT_OF_RESOURCES No enough pages to allocate.
@retval EFI_SUCCESS Pages successfully allocated.
**/
EFI_STATUS
EFIAPI
SmmInternalAllocatePages (
IN EFI_ALLOCATE_TYPE Type,
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN NumberOfPages,
OUT EFI_PHYSICAL_ADDRESS *Memory
)
{
return SmmInternalAllocatePagesEx (Type, MemoryType, NumberOfPages, Memory, FALSE);
}
/**
Allocates pages from the memory map.
@ -268,8 +856,9 @@ InternalMergeNodes (
/**
Frees previous allocated pages.
@param Memory Base address of memory being freed.
@param NumberOfPages The number of pages to free.
@param[in] Memory Base address of memory being freed.
@param[in] NumberOfPages The number of pages to free.
@param[in] AddRegion If this memory is new added region.
@retval EFI_NOT_FOUND Could not find the entry that covers the range.
@retval EFI_INVALID_PARAMETER Address not aligned.
@ -277,10 +866,10 @@ InternalMergeNodes (
**/
EFI_STATUS
EFIAPI
SmmInternalFreePages (
SmmInternalFreePagesEx (
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NumberOfPages
IN UINTN NumberOfPages,
IN BOOLEAN AddRegion
)
{
LIST_ENTRY *Node;
@ -326,9 +915,38 @@ SmmInternalFreePages (
InternalMergeNodes (Pages);
}
//
// Update SmmMemoryMap here.
//
ConvertSmmMemoryMapEntry (EfiConventionalMemory, Memory, NumberOfPages, AddRegion);
if (!AddRegion) {
CoreFreeMemoryMapStack();
}
return EFI_SUCCESS;
}
/**
Frees previous allocated pages.
@param[in] Memory Base address of memory being freed.
@param[in] NumberOfPages The number of pages to free.
@retval EFI_NOT_FOUND Could not find the entry that covers the range.
@retval EFI_INVALID_PARAMETER Address not aligned.
@return EFI_SUCCESS Pages successfully freed.
**/
EFI_STATUS
EFIAPI
SmmInternalFreePages (
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NumberOfPages
)
{
return SmmInternalFreePagesEx (Memory, NumberOfPages, FALSE);
}
/**
Frees previous allocated pages.
@ -383,16 +1001,121 @@ SmmAddMemoryRegion (
UINTN AlignedMemBase;
//
// Do not add memory regions that is already allocated, needs testing, or needs ECC initialization
// Add EfiRuntimeServicesData for memory regions that is already allocated, needs testing, or needs ECC initialization
//
if ((Attributes & (EFI_ALLOCATED | EFI_NEEDS_TESTING | EFI_NEEDS_ECC_INITIALIZATION)) != 0) {
return;
Type = EfiRuntimeServicesData;
} else {
Type = EfiConventionalMemory;
}
DEBUG ((DEBUG_INFO, "SmmAddMemoryRegion\n"));
DEBUG ((DEBUG_INFO, " MemBase - 0x%lx\n", MemBase));
DEBUG ((DEBUG_INFO, " MemLength - 0x%lx\n", MemLength));
DEBUG ((DEBUG_INFO, " Type - 0x%x\n", Type));
DEBUG ((DEBUG_INFO, " Attributes - 0x%lx\n", Attributes));
//
// Align range on an EFI_PAGE_SIZE boundary
//
//
AlignedMemBase = (UINTN)(MemBase + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
MemLength -= AlignedMemBase - MemBase;
SmmFreePages (AlignedMemBase, TRUNCATE_TO_PAGES ((UINTN)MemLength));
if (Type == EfiConventionalMemory) {
SmmInternalFreePagesEx (AlignedMemBase, TRUNCATE_TO_PAGES ((UINTN)MemLength), TRUE);
} else {
ConvertSmmMemoryMapEntry (EfiRuntimeServicesData, AlignedMemBase, TRUNCATE_TO_PAGES ((UINTN)MemLength), TRUE);
}
CoreFreeMemoryMapStack ();
}
/**
This function returns a copy of the current memory map. The map is an array of
memory descriptors, each of which describes a contiguous block of memory.
@param[in, out] MemoryMapSize A pointer to the size, in bytes, of the
MemoryMap buffer. On input, this is the size of
the buffer allocated by the caller. On output,
it is the size of the buffer returned by the
firmware if the buffer was large enough, or the
size of the buffer needed to contain the map if
the buffer was too small.
@param[in, out] MemoryMap A pointer to the buffer in which firmware places
the current memory map.
@param[out] MapKey A pointer to the location in which firmware
returns the key for the current memory map.
@param[out] DescriptorSize A pointer to the location in which firmware
returns the size, in bytes, of an individual
EFI_MEMORY_DESCRIPTOR.
@param[out] DescriptorVersion A pointer to the location in which firmware
returns the version number associated with the
EFI_MEMORY_DESCRIPTOR.
@retval EFI_SUCCESS The memory map was returned in the MemoryMap
buffer.
@retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current
buffer size needed to hold the memory map is
returned in MemoryMapSize.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
**/
EFI_STATUS
EFIAPI
SmmCoreGetMemoryMap (
IN OUT UINTN *MemoryMapSize,
IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,
OUT UINTN *MapKey,
OUT UINTN *DescriptorSize,
OUT UINT32 *DescriptorVersion
)
{
UINTN Count;
LIST_ENTRY *Link;
MEMORY_MAP *Entry;
UINTN Size;
UINTN BufferSize;
Size = sizeof (EFI_MEMORY_DESCRIPTOR);
//
// Make sure Size != sizeof(EFI_MEMORY_DESCRIPTOR). This will
// prevent people from having pointer math bugs in their code.
// now you have to use *DescriptorSize to make things work.
//
Size += sizeof(UINT64) - (Size % sizeof (UINT64));
if (DescriptorSize != NULL) {
*DescriptorSize = Size;
}
if (DescriptorVersion != NULL) {
*DescriptorVersion = EFI_MEMORY_DESCRIPTOR_VERSION;
}
Count = GetSmmMemoryMapEntryCount ();
BufferSize = Size * Count;
if (*MemoryMapSize < BufferSize) {
*MemoryMapSize = BufferSize;
return EFI_BUFFER_TOO_SMALL;
}
*MemoryMapSize = BufferSize;
if (MemoryMap == NULL) {
return EFI_INVALID_PARAMETER;
}
ZeroMem (MemoryMap, BufferSize);
Link = gMemoryMap.ForwardLink;
while (Link != &gMemoryMap) {
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);
Link = Link->ForwardLink;
MemoryMap->Type = Entry->Type;
MemoryMap->PhysicalStart = Entry->Start;
MemoryMap->NumberOfPages = RShiftU64 (Entry->End - Entry->Start + 1, EFI_PAGE_SHIFT);
MemoryMap = NEXT_MEMORY_DESCRIPTOR (MemoryMap, Size);
}
return EFI_SUCCESS;
}

40
MdeModulePkg/Core/PiSmmCore/PiSmmCore.c
View File

@ -87,6 +87,8 @@ SMM_CORE_SMI_HANDLERS mSmmCoreSmiHandlers[] = {
UINTN mFullSmramRangeCount;
EFI_SMRAM_DESCRIPTOR *mFullSmramRanges;
EFI_SMM_DRIVER_ENTRY *mSmmCoreDriverEntry;
EFI_LOADED_IMAGE_PROTOCOL *mSmmCoreLoadedImage;
/**
@ -564,6 +566,42 @@ SmmCoreInstallLoadedImage (
);
ASSERT_EFI_ERROR (Status);
//
// Allocate a Loaded Image Protocol in SMM
//
Status = SmmAllocatePool (EfiRuntimeServicesData, sizeof(EFI_SMM_DRIVER_ENTRY), (VOID **)&mSmmCoreDriverEntry);
ASSERT_EFI_ERROR(Status);
ZeroMem (mSmmCoreDriverEntry, sizeof(EFI_SMM_DRIVER_ENTRY));
//
// Fill in the remaining fields of the Loaded Image Protocol instance.
//
mSmmCoreDriverEntry->Signature = EFI_SMM_DRIVER_ENTRY_SIGNATURE;
mSmmCoreDriverEntry->SmmLoadedImage.Revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
mSmmCoreDriverEntry->SmmLoadedImage.ParentHandle = gSmmCorePrivate->SmmIplImageHandle;
mSmmCoreDriverEntry->SmmLoadedImage.SystemTable = gST;
mSmmCoreDriverEntry->SmmLoadedImage.ImageBase = (VOID *)(UINTN)gSmmCorePrivate->PiSmmCoreImageBase;
mSmmCoreDriverEntry->SmmLoadedImage.ImageSize = gSmmCorePrivate->PiSmmCoreImageSize;
mSmmCoreDriverEntry->SmmLoadedImage.ImageCodeType = EfiRuntimeServicesCode;
mSmmCoreDriverEntry->SmmLoadedImage.ImageDataType = EfiRuntimeServicesData;
mSmmCoreDriverEntry->ImageEntryPoint = gSmmCorePrivate->PiSmmCoreEntryPoint;
mSmmCoreDriverEntry->ImageBuffer = gSmmCorePrivate->PiSmmCoreImageBase;
mSmmCoreDriverEntry->NumberOfPage = EFI_SIZE_TO_PAGES((UINTN)gSmmCorePrivate->PiSmmCoreImageSize);
//
// Create a new image handle in the SMM handle database for the SMM Driver
//
mSmmCoreDriverEntry->SmmImageHandle = NULL;
Status = SmmInstallProtocolInterface (
&mSmmCoreDriverEntry->SmmImageHandle,
&gEfiLoadedImageProtocolGuid,
EFI_NATIVE_INTERFACE,
&mSmmCoreDriverEntry->SmmLoadedImage
);
ASSERT_EFI_ERROR(Status);
return ;
}
@ -636,5 +674,7 @@ SmmMain (
SmmCoreInstallLoadedImage ();
SmmCoreInitializeMemoryAttributesTable ();
return EFI_SUCCESS;
}

91
MdeModulePkg/Core/PiSmmCore/PiSmmCore.h
View File

@ -110,6 +110,8 @@ typedef struct {
// Image Page Number
//
UINTN NumberOfPage;
EFI_HANDLE SmmImageHandle;
EFI_LOADED_IMAGE_PROTOCOL SmmLoadedImage;
} EFI_SMM_DRIVER_ENTRY;
#define EFI_HANDLE_SIGNATURE SIGNATURE_32('h','n','d','l')
@ -550,6 +552,38 @@ SmmLocateProtocol (
OUT VOID **Interface
);
/**
Function returns an array of handles that support the requested protocol
in a buffer allocated from pool. This is a version of SmmLocateHandle()
that allocates a buffer for the caller.
@param SearchType Specifies which handle(s) are to be returned.
@param Protocol Provides the protocol to search by. This
parameter is only valid for SearchType
ByProtocol.
@param SearchKey Supplies the search key depending on the
SearchType.
@param NumberHandles The number of handles returned in Buffer.
@param Buffer A pointer to the buffer to return the requested
array of handles that support Protocol.
@retval EFI_SUCCESS The result array of handles was returned.
@retval EFI_NOT_FOUND No handles match the search.
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the
matching results.
@retval EFI_INVALID_PARAMETER One or more paramters are not valid.
**/
EFI_STATUS
EFIAPI
SmmLocateHandleBuffer (
IN EFI_LOCATE_SEARCH_TYPE SearchType,
IN EFI_GUID *Protocol OPTIONAL,
IN VOID *SearchKey OPTIONAL,
IN OUT UINTN *NumberHandles,
OUT EFI_HANDLE **Buffer
);
/**
Manage SMI of a particular type.
@ -980,9 +1014,66 @@ SmramProfileReadyToLock (
VOID
);
/**
Initialize MemoryAttributes support.
**/
VOID
EFIAPI
SmmCoreInitializeMemoryAttributesTable (
VOID
);
/**
This function returns a copy of the current memory map. The map is an array of
memory descriptors, each of which describes a contiguous block of memory.
@param[in, out] MemoryMapSize A pointer to the size, in bytes, of the
MemoryMap buffer. On input, this is the size of
the buffer allocated by the caller. On output,
it is the size of the buffer returned by the
firmware if the buffer was large enough, or the
size of the buffer needed to contain the map if
the buffer was too small.
@param[in, out] MemoryMap A pointer to the buffer in which firmware places
the current memory map.
@param[out] MapKey A pointer to the location in which firmware
returns the key for the current memory map.
@param[out] DescriptorSize A pointer to the location in which firmware
returns the size, in bytes, of an individual
EFI_MEMORY_DESCRIPTOR.
@param[out] DescriptorVersion A pointer to the location in which firmware
returns the version number associated with the
EFI_MEMORY_DESCRIPTOR.
@retval EFI_SUCCESS The memory map was returned in the MemoryMap
buffer.
@retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current
buffer size needed to hold the memory map is
returned in MemoryMapSize.
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
**/
EFI_STATUS
EFIAPI
SmmCoreGetMemoryMap (
IN OUT UINTN *MemoryMapSize,
IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,
OUT UINTN *MapKey,
OUT UINTN *DescriptorSize,
OUT UINT32 *DescriptorVersion
);
///
/// For generic EFI machines make the default allocations 4K aligned
///
#define EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE)
#define DEFAULT_PAGE_ALLOCATION (EFI_PAGE_SIZE)
extern UINTN mFullSmramRangeCount;
extern EFI_SMRAM_DESCRIPTOR *mFullSmramRanges;
extern EFI_SMM_DRIVER_ENTRY *mSmmCoreDriverEntry;
extern EFI_LOADED_IMAGE_PROTOCOL *mSmmCoreLoadedImage;
//

2
MdeModulePkg/Core/PiSmmCore/PiSmmCore.inf
View File

@ -38,6 +38,7 @@
Smi.c
InstallConfigurationTable.c
SmramProfileRecord.c
MemoryAttributesTable.c
[Packages]
MdePkg/MdePkg.dec
@ -96,6 +97,7 @@
gEdkiiMemoryProfileGuid
## SOMETIMES_PRODUCES ## GUID # Install protocol
gEdkiiSmmMemoryProfileGuid
gEdkiiPiSmmMemoryAttributesTableGuid ## SOMETIMES_PRODUCES ## SystemTable
[UserExtensions.TianoCore."ExtraFiles"]
PiSmmCoreExtra.uni

16
MdeModulePkg/Core/PiSmmCore/Pool.c
View File

@ -86,8 +86,24 @@ SmmInitializeMemoryServices (
}
//
// Initialize free SMRAM regions
// Need add Free memory at first, to let gSmmMemoryMap record data
//
for (Index = 0; Index < SmramRangeCount; Index++) {
if ((SmramRanges[Index].RegionState & (EFI_ALLOCATED | EFI_NEEDS_TESTING | EFI_NEEDS_ECC_INITIALIZATION)) != 0) {
continue;
}
SmmAddMemoryRegion (
SmramRanges[Index].CpuStart,
SmramRanges[Index].PhysicalSize,
EfiConventionalMemory,
SmramRanges[Index].RegionState
);
}
for (Index = 0; Index < SmramRangeCount; Index++) {
if ((SmramRanges[Index].RegionState & (EFI_ALLOCATED | EFI_NEEDS_TESTING | EFI_NEEDS_ECC_INITIALIZATION)) == 0) {
continue;
}
SmmAddMemoryRegion (
SmramRanges[Index].CpuStart,
SmramRanges[Index].PhysicalSize,