From: Achin Gupta <achin.gupta@arm.com>
To: Supreeth Venkatesh <supreeth.venkatesh@arm.com>
Cc: edk2-devel@lists.01.org, michael.d.kinney@intel.com,
liming.gao@intel.com, jiewen.yao@intel.com,
leif.lindholm@linaro.org, ard.biesheuvel@linaro.org, nd@arm.com
Subject: Re: [PATCH v1 13/18] StandaloneMmPkg/Core: Implementation of Standalone MM Core Module.
Date: Mon, 30 Apr 2018 20:19:43 +0100 [thread overview]
Message-ID: <20180430191942.GX663@e104320-lin> (raw)
In-Reply-To: <20180406144223.10931-14-supreeth.venkatesh@arm.com>
Hi Supreeth,
I think it is worth adding a signed off by Jiewen since he originally
contributed the code and it has not changed much since. Please update the
correct year in the copyright headers too.
Acked-by: Achin Gupta <achin.gupta@arm.com>
cheers,
Achin
On Fri, Apr 06, 2018 at 03:42:18PM +0100, Supreeth Venkatesh wrote:
> Management Mode (MM) is a generic term used to describe a secure
> execution environment provided by the CPU and related silicon that is
> entered when the CPU detects a MMI. For x86 systems, this can be
> implemented with System Management Mode (SMM). For ARM systems, this can
> be implemented with TrustZone (TZ).
> A MMI can be a CPU instruction or interrupt. Upon detection of a MMI, a
> CPU will jump to the MM Entry Point and save some portion of its state
> (the "save state") such that execution can be resumed.
> The MMI can be generated synchronously by software or asynchronously by
> a hardware event. Each MMI source can be detected, cleared and disabled.
> Some systems provide for special memory (Management Mode RAM or MMRAM)
> which is set aside for software running in MM. Usually the MMRAM is
> hidden during normal CPU execution, but this is not required. Usually,
> after MMRAM is hidden it cannot be exposed until the next system reset.
>
> The MM Core Interface Specification describes three pieces of the PI
> Management Mode architecture:
> 1. MM Dispatch
> During DXE, the DXE Foundation works with the MM Foundation to
> schedule MM drivers for execution in the discovered firmware volumes.
> 2. MM Initialization
> MM related code opens MMRAM, creates the MMRAM memory map, and
> launches the MM Foundation, which provides the necessary services to
> launch MM-related drivers. Then, sometime before boot, MMRAM is
> closed and locked. This piece may be completed during the
> SEC, PEI or DXE phases.
> 3. MMI Management
> When an MMI generated, the MM environment is created and then the MMI
>
> sources are detected and MMI handlers called.
>
> This patch implements the MM Core.
>
> Contributed-under: TianoCore Contribution Agreement 1.1
> Signed-off-by: Achin Gupta <achin.gupta@arm.com>
> Signed-off-by: Supreeth Venkatesh <supreeth.venkatesh@arm.com>
> ---
> StandaloneMmPkg/Core/Dependency.c | 389 +++++++
> StandaloneMmPkg/Core/Dispatcher.c | 1071 ++++++++++++++++++++
> StandaloneMmPkg/Core/FwVol.c | 104 ++
> StandaloneMmPkg/Core/Handle.c | 533 ++++++++++
> StandaloneMmPkg/Core/InstallConfigurationTable.c | 178 ++++
> StandaloneMmPkg/Core/Locate.c | 496 +++++++++
> StandaloneMmPkg/Core/Mmi.c | 337 ++++++
> StandaloneMmPkg/Core/Notify.c | 203 ++++
> StandaloneMmPkg/Core/Page.c | 384 +++++++
> StandaloneMmPkg/Core/Pool.c | 287 ++++++
> StandaloneMmPkg/Core/StandaloneMmCore.c | 708 +++++++++++++
> StandaloneMmPkg/Core/StandaloneMmCore.h | 903 +++++++++++++++++
> StandaloneMmPkg/Core/StandaloneMmCore.inf | 80 ++
> StandaloneMmPkg/Core/StandaloneMmCorePrivateData.h | 66 ++
> StandaloneMmPkg/Include/Guid/MmFvDispatch.h | 38 +
> StandaloneMmPkg/Include/StandaloneMm.h | 36 +
> 16 files changed, 5813 insertions(+)
> create mode 100644 StandaloneMmPkg/Core/Dependency.c
> create mode 100644 StandaloneMmPkg/Core/Dispatcher.c
> create mode 100644 StandaloneMmPkg/Core/FwVol.c
> create mode 100644 StandaloneMmPkg/Core/Handle.c
> create mode 100644 StandaloneMmPkg/Core/InstallConfigurationTable.c
> create mode 100644 StandaloneMmPkg/Core/Locate.c
> create mode 100644 StandaloneMmPkg/Core/Mmi.c
> create mode 100644 StandaloneMmPkg/Core/Notify.c
> create mode 100644 StandaloneMmPkg/Core/Page.c
> create mode 100644 StandaloneMmPkg/Core/Pool.c
> create mode 100644 StandaloneMmPkg/Core/StandaloneMmCore.c
> create mode 100644 StandaloneMmPkg/Core/StandaloneMmCore.h
> create mode 100644 StandaloneMmPkg/Core/StandaloneMmCore.inf
> create mode 100644 StandaloneMmPkg/Core/StandaloneMmCorePrivateData.h
> create mode 100644 StandaloneMmPkg/Include/Guid/MmFvDispatch.h
> create mode 100644 StandaloneMmPkg/Include/StandaloneMm.h
>
> diff --git a/StandaloneMmPkg/Core/Dependency.c b/StandaloneMmPkg/Core/Dependency.c
> new file mode 100644
> index 0000000000..e501369130
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Dependency.c
> @@ -0,0 +1,389 @@
> +/** @file
> + MM Driver Dispatcher Dependency Evaluator
> +
> + This routine evaluates a dependency expression (DEPENDENCY_EXPRESSION) to determine
> + if a driver can be scheduled for execution. The criteria for
> + schedulability is that the dependency expression is satisfied.
> +
> + Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +///
> +/// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependency expression
> +/// to save time. A EFI_DEP_PUSH is evaluated one an
> +/// replaced with EFI_DEP_REPLACE_TRUE. If PI spec's Vol 2
> +/// Driver Execution Environment Core Interface use 0xff
> +/// as new DEPEX opcode. EFI_DEP_REPLACE_TRUE should be
> +/// defined to a new value that is not conflicting with PI spec.
> +///
> +#define EFI_DEP_REPLACE_TRUE 0xff
> +
> +///
> +/// Define the initial size of the dependency expression evaluation stack
> +///
> +#define DEPEX_STACK_SIZE_INCREMENT 0x1000
> +
> +//
> +// Global stack used to evaluate dependency expressions
> +//
> +BOOLEAN *mDepexEvaluationStack = NULL;
> +BOOLEAN *mDepexEvaluationStackEnd = NULL;
> +BOOLEAN *mDepexEvaluationStackPointer = NULL;
> +
> +/**
> + Grow size of the Depex stack
> +
> + @retval EFI_SUCCESS Stack successfully growed.
> + @retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the stack.
> +
> +**/
> +EFI_STATUS
> +GrowDepexStack (
> + VOID
> + )
> +{
> + BOOLEAN *NewStack;
> + UINTN Size;
> +
> + Size = DEPEX_STACK_SIZE_INCREMENT;
> + if (mDepexEvaluationStack != NULL) {
> + Size = Size + (mDepexEvaluationStackEnd - mDepexEvaluationStack);
> + }
> +
> + NewStack = AllocatePool (Size * sizeof (BOOLEAN));
> + if (NewStack == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + if (mDepexEvaluationStack != NULL) {
> + //
> + // Copy to Old Stack to the New Stack
> + //
> + CopyMem (
> + NewStack,
> + mDepexEvaluationStack,
> + (mDepexEvaluationStackEnd - mDepexEvaluationStack) * sizeof (BOOLEAN)
> + );
> +
> + //
> + // Free The Old Stack
> + //
> + FreePool (mDepexEvaluationStack);
> + }
> +
> + //
> + // Make the Stack pointer point to the old data in the new stack
> + //
> + mDepexEvaluationStackPointer = NewStack + (mDepexEvaluationStackPointer - mDepexEvaluationStack);
> + mDepexEvaluationStack = NewStack;
> + mDepexEvaluationStackEnd = NewStack + Size;
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Push an element onto the Boolean Stack.
> +
> + @param Value BOOLEAN to push.
> +
> + @retval EFI_SUCCESS The value was pushed onto the stack.
> + @retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the stack.
> +
> +**/
> +EFI_STATUS
> +PushBool (
> + IN BOOLEAN Value
> + )
> +{
> + EFI_STATUS Status;
> +
> + //
> + // Check for a stack overflow condition
> + //
> + if (mDepexEvaluationStackPointer == mDepexEvaluationStackEnd) {
> + //
> + // Grow the stack
> + //
> + Status = GrowDepexStack ();
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> + }
> +
> + //
> + // Push the item onto the stack
> + //
> + *mDepexEvaluationStackPointer = Value;
> + mDepexEvaluationStackPointer++;
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Pop an element from the Boolean stack.
> +
> + @param Value BOOLEAN to pop.
> +
> + @retval EFI_SUCCESS The value was popped onto the stack.
> + @retval EFI_ACCESS_DENIED The pop operation underflowed the stack.
> +
> +**/
> +EFI_STATUS
> +PopBool (
> + OUT BOOLEAN *Value
> + )
> +{
> + //
> + // Check for a stack underflow condition
> + //
> + if (mDepexEvaluationStackPointer == mDepexEvaluationStack) {
> + return EFI_ACCESS_DENIED;
> + }
> +
> + //
> + // Pop the item off the stack
> + //
> + mDepexEvaluationStackPointer--;
> + *Value = *mDepexEvaluationStackPointer;
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + This is the POSTFIX version of the dependency evaluator. This code does
> + not need to handle Before or After, as it is not valid to call this
> + routine in this case. POSTFIX means all the math is done on top of the stack.
> +
> + @param DriverEntry DriverEntry element to update.
> +
> + @retval TRUE If driver is ready to run.
> + @retval FALSE If driver is not ready to run or some fatal error
> + was found.
> +
> +**/
> +BOOLEAN
> +MmIsSchedulable (
> + IN EFI_MM_DRIVER_ENTRY *DriverEntry
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 *Iterator;
> + BOOLEAN Operator;
> + BOOLEAN Operator2;
> + EFI_GUID DriverGuid;
> + VOID *Interface;
> +
> + Operator = FALSE;
> + Operator2 = FALSE;
> +
> + if (DriverEntry->After || DriverEntry->Before) {
> + //
> + // If Before or After Depex skip as MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter ()
> + // processes them.
> + //
> + return FALSE;
> + }
> +
> + DEBUG ((DEBUG_DISPATCH, "Evaluate MM DEPEX for FFS(%g)\n", &DriverEntry->FileName));
> +
> + if (DriverEntry->Depex == NULL) {
> + //
> + // A NULL Depex means that the MM driver is not built correctly.
> + // All MM drivers must have a valid depex expressiion.
> + //
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Depex is empty)\n"));
> + ASSERT (FALSE);
> + return FALSE;
> + }
> +
> + //
> + // Clean out memory leaks in Depex Boolean stack. Leaks are only caused by
> + // incorrectly formed DEPEX expressions
> + //
> + mDepexEvaluationStackPointer = mDepexEvaluationStack;
> +
> +
> + Iterator = DriverEntry->Depex;
> +
> + while (TRUE) {
> + //
> + // Check to see if we are attempting to fetch dependency expression instructions
> + // past the end of the dependency expression.
> + //
> + if (((UINTN)Iterator - (UINTN)DriverEntry->Depex) >= DriverEntry->DepexSize) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Attempt to fetch past end of depex)\n"));
> + return FALSE;
> + }
> +
> + //
> + // Look at the opcode of the dependency expression instruction.
> + //
> + switch (*Iterator) {
> + case EFI_DEP_BEFORE:
> + case EFI_DEP_AFTER:
> + //
> + // For a well-formed Dependency Expression, the code should never get here.
> + // The BEFORE and AFTER are processed prior to this routine's invocation.
> + // If the code flow arrives at this point, there was a BEFORE or AFTER
> + // that were not the first opcodes.
> + //
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected BEFORE or AFTER opcode)\n"));
> + ASSERT (FALSE);
> +
> + case EFI_DEP_PUSH:
> + //
> + // Push operator is followed by a GUID. Test to see if the GUID protocol
> + // is installed and push the boolean result on the stack.
> + //
> + CopyMem (&DriverGuid, Iterator + 1, sizeof (EFI_GUID));
> +
> + Status = MmLocateProtocol (&DriverGuid, NULL, &Interface);
> + if (EFI_ERROR (Status) && (mEfiSystemTable != NULL)) {
> + //
> + // For MM Driver, it may depend on uefi protocols
> + //
> + Status = mEfiSystemTable->BootServices->LocateProtocol (&DriverGuid, NULL, &Interface);
> + }
> +
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " PUSH GUID(%g) = FALSE\n", &DriverGuid));
> + Status = PushBool (FALSE);
> + } else {
> + DEBUG ((DEBUG_DISPATCH, " PUSH GUID(%g) = TRUE\n", &DriverGuid));
> + *Iterator = EFI_DEP_REPLACE_TRUE;
> + Status = PushBool (TRUE);
> + }
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Iterator += sizeof (EFI_GUID);
> + break;
> +
> + case EFI_DEP_AND:
> + DEBUG ((DEBUG_DISPATCH, " AND\n"));
> + Status = PopBool (&Operator);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Status = PopBool (&Operator2);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Status = PushBool ((BOOLEAN)(Operator && Operator2));
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + break;
> +
> + case EFI_DEP_OR:
> + DEBUG ((DEBUG_DISPATCH, " OR\n"));
> + Status = PopBool (&Operator);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Status = PopBool (&Operator2);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Status = PushBool ((BOOLEAN)(Operator || Operator2));
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + break;
> +
> + case EFI_DEP_NOT:
> + DEBUG ((DEBUG_DISPATCH, " NOT\n"));
> + Status = PopBool (&Operator);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Status = PushBool ((BOOLEAN)(!Operator));
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + break;
> +
> + case EFI_DEP_TRUE:
> + DEBUG ((DEBUG_DISPATCH, " TRUE\n"));
> + Status = PushBool (TRUE);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + break;
> +
> + case EFI_DEP_FALSE:
> + DEBUG ((DEBUG_DISPATCH, " FALSE\n"));
> + Status = PushBool (FALSE);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + break;
> +
> + case EFI_DEP_END:
> + DEBUG ((DEBUG_DISPATCH, " END\n"));
> + Status = PopBool (&Operator);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> + DEBUG ((DEBUG_DISPATCH, " RESULT = %a\n", Operator ? "TRUE" : "FALSE"));
> + return Operator;
> +
> + case EFI_DEP_REPLACE_TRUE:
> + CopyMem (&DriverGuid, Iterator + 1, sizeof (EFI_GUID));
> + DEBUG ((DEBUG_DISPATCH, " PUSH GUID(%g) = TRUE\n", &DriverGuid));
> + Status = PushBool (TRUE);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unexpected error)\n"));
> + return FALSE;
> + }
> +
> + Iterator += sizeof (EFI_GUID);
> + break;
> +
> + default:
> + DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE (Unknown opcode)\n"));
> + goto Done;
> + }
> +
> + //
> + // Skip over the Dependency Op Code we just processed in the switch.
> + // The math is done out of order, but it should not matter. That is
> + // we may add in the sizeof (EFI_GUID) before we account for the OP Code.
> + // This is not an issue, since we just need the correct end result. You
> + // need to be careful using Iterator in the loop as it's intermediate value
> + // may be strange.
> + //
> + Iterator++;
> + }
> +
> +Done:
> + return FALSE;
> +}
> diff --git a/StandaloneMmPkg/Core/Dispatcher.c b/StandaloneMmPkg/Core/Dispatcher.c
> new file mode 100644
> index 0000000000..af18fa7eaa
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Dispatcher.c
> @@ -0,0 +1,1071 @@
> +/** @file
> + MM Driver Dispatcher.
> +
> + Step #1 - When a FV protocol is added to the system every driver in the FV
> + is added to the mDiscoveredList. The Before, and After Depex are
> + pre-processed as drivers are added to the mDiscoveredList. If an Apriori
> + file exists in the FV those drivers are addeded to the
> + mScheduledQueue. The mFvHandleList is used to make sure a
> + FV is only processed once.
> +
> + Step #2 - Dispatch. Remove driver from the mScheduledQueue and load and
> + start it. After mScheduledQueue is drained check the
> + mDiscoveredList to see if any item has a Depex that is ready to
> + be placed on the mScheduledQueue.
> +
> + Step #3 - Adding to the mScheduledQueue requires that you process Before
> + and After dependencies. This is done recursively as the call to add
> + to the mScheduledQueue checks for Before and recursively adds
> + all Befores. It then addes the item that was passed in and then
> + processess the After dependecies by recursively calling the routine.
> +
> + Dispatcher Rules:
> + The rules for the dispatcher are similar to the DXE dispatcher.
> +
> + The rules for DXE dispatcher are in chapter 10 of the DXE CIS. Figure 10-3
> + is the state diagram for the DXE dispatcher
> +
> + Depex - Dependency Expresion.
> +
> + Copyright (c) 2014, Hewlett-Packard Development Company, L.P.
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +//
> +// MM Dispatcher Data structures
> +//
> +#define KNOWN_HANDLE_SIGNATURE SIGNATURE_32('k','n','o','w')
> +typedef struct {
> + UINTN Signature;
> + LIST_ENTRY Link; // mFvHandleList
> + EFI_HANDLE Handle;
> +} KNOWN_HANDLE;
> +
> +//
> +// Function Prototypes
> +//
> +
> +EFI_STATUS
> +MmCoreFfsFindMmDriver (
> + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader
> + );
> +
> +/**
> + Insert InsertedDriverEntry onto the mScheduledQueue. To do this you
> + must add any driver with a before dependency on InsertedDriverEntry first.
> + You do this by recursively calling this routine. After all the Befores are
> + processed you can add InsertedDriverEntry to the mScheduledQueue.
> + Then you can add any driver with an After dependency on InsertedDriverEntry
> + by recursively calling this routine.
> +
> + @param InsertedDriverEntry The driver to insert on the ScheduledLink Queue
> +
> +**/
> +VOID
> +MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter (
> + IN EFI_MM_DRIVER_ENTRY *InsertedDriverEntry
> + );
> +
> +//
> +// The Driver List contains one copy of every driver that has been discovered.
> +// Items are never removed from the driver list. List of EFI_MM_DRIVER_ENTRY
> +//
> +LIST_ENTRY mDiscoveredList = INITIALIZE_LIST_HEAD_VARIABLE (mDiscoveredList);
> +
> +//
> +// Queue of drivers that are ready to dispatch. This queue is a subset of the
> +// mDiscoveredList.list of EFI_MM_DRIVER_ENTRY.
> +//
> +LIST_ENTRY mScheduledQueue = INITIALIZE_LIST_HEAD_VARIABLE (mScheduledQueue);
> +
> +//
> +// List of handles who's Fv's have been parsed and added to the mFwDriverList.
> +//
> +LIST_ENTRY mFvHandleList = INITIALIZE_LIST_HEAD_VARIABLE (mFvHandleList);
> +
> +//
> +// Flag for the MM Dispacher. TRUE if dispatcher is execuing.
> +//
> +BOOLEAN gDispatcherRunning = FALSE;
> +
> +//
> +// Flag for the MM Dispacher. TRUE if there is one or more MM drivers ready to be dispatched
> +//
> +BOOLEAN gRequestDispatch = FALSE;
> +
> +//
> +// The global variable is defined for Loading modules at fixed address feature to track the MM code
> +// memory range usage. It is a bit mapped array in which every bit indicates the correspoding
> +// memory page available or not.
> +//
> +GLOBAL_REMOVE_IF_UNREFERENCED UINT64 *mMmCodeMemoryRangeUsageBitMap=NULL;
> +
> +/**
> + To check memory usage bit map array to figure out if the memory range in which the image will be loaded is available or not. If
> + memory range is avaliable, the function will mark the correponding bits to 1 which indicates the memory range is used.
> + The function is only invoked when load modules at fixed address feature is enabled.
> +
> + @param ImageBase The base addres the image will be loaded at.
> + @param ImageSize The size of the image
> +
> + @retval EFI_SUCCESS The memory range the image will be loaded in is available
> + @retval EFI_NOT_FOUND The memory range the image will be loaded in is not available
> +**/
> +EFI_STATUS
> +CheckAndMarkFixLoadingMemoryUsageBitMap (
> + IN EFI_PHYSICAL_ADDRESS ImageBase,
> + IN UINTN ImageSize
> + )
> +{
> + UINT32 MmCodePageNumber;
> + UINT64 MmCodeSize;
> + EFI_PHYSICAL_ADDRESS MmCodeBase;
> + UINTN BaseOffsetPageNumber;
> + UINTN TopOffsetPageNumber;
> + UINTN Index;
> + //
> + // Build tool will calculate the smm code size and then patch the PcdLoadFixAddressMmCodePageNumber
> + //
> + MmCodePageNumber = 0;
> + MmCodeSize = EFI_PAGES_TO_SIZE (MmCodePageNumber);
> + MmCodeBase = gLoadModuleAtFixAddressMmramBase;
> +
> + //
> + // If the memory usage bit map is not initialized, do it. Every bit in the array
> + // indicate the status of the corresponding memory page, available or not
> + //
> + if (mMmCodeMemoryRangeUsageBitMap == NULL) {
> + mMmCodeMemoryRangeUsageBitMap = AllocateZeroPool(((MmCodePageNumber / 64) + 1)*sizeof(UINT64));
> + }
> + //
> + // If the Dxe code memory range is not allocated or the bit map array allocation failed, return EFI_NOT_FOUND
> + //
> + if (mMmCodeMemoryRangeUsageBitMap == NULL) {
> + return EFI_NOT_FOUND;
> + }
> + //
> + // see if the memory range for loading the image is in the MM code range.
> + //
> + if (MmCodeBase + MmCodeSize < ImageBase + ImageSize || MmCodeBase > ImageBase) {
> + return EFI_NOT_FOUND;
> + }
> + //
> + // Test if the memory is avalaible or not.
> + //
> + BaseOffsetPageNumber = (UINTN)EFI_SIZE_TO_PAGES((UINT32)(ImageBase - MmCodeBase));
> + TopOffsetPageNumber = (UINTN)EFI_SIZE_TO_PAGES((UINT32)(ImageBase + ImageSize - MmCodeBase));
> + for (Index = BaseOffsetPageNumber; Index < TopOffsetPageNumber; Index ++) {
> + if ((mMmCodeMemoryRangeUsageBitMap[Index / 64] & LShiftU64(1, (Index % 64))) != 0) {
> + //
> + // This page is already used.
> + //
> + return EFI_NOT_FOUND;
> + }
> + }
> +
> + //
> + // Being here means the memory range is available. So mark the bits for the memory range
> + //
> + for (Index = BaseOffsetPageNumber; Index < TopOffsetPageNumber; Index ++) {
> + mMmCodeMemoryRangeUsageBitMap[Index / 64] |= LShiftU64(1, (Index % 64));
> + }
> + return EFI_SUCCESS;
> +}
> +/**
> + Get the fixed loading address from image header assigned by build tool. This function only be called
> + when Loading module at Fixed address feature enabled.
> +
> + @param ImageContext Pointer to the image context structure that describes the PE/COFF
> + image that needs to be examined by this function.
> + @retval EFI_SUCCESS An fixed loading address is assigned to this image by build tools .
> + @retval EFI_NOT_FOUND The image has no assigned fixed loadding address.
> +
> +**/
> +EFI_STATUS
> +GetPeCoffImageFixLoadingAssignedAddress(
> + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
> + )
> +{
> + UINTN SectionHeaderOffset;
> + EFI_STATUS Status;
> + EFI_IMAGE_SECTION_HEADER SectionHeader;
> + EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
> + EFI_PHYSICAL_ADDRESS FixLoadingAddress;
> + UINT16 Index;
> + UINTN Size;
> + UINT16 NumberOfSections;
> + UINT64 ValueInSectionHeader;
> +
> + FixLoadingAddress = 0;
> + Status = EFI_NOT_FOUND;
> +
> + //
> + // Get PeHeader pointer
> + //
> + ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((CHAR8* )ImageContext->Handle + ImageContext->PeCoffHeaderOffset);
> + SectionHeaderOffset = ImageContext->PeCoffHeaderOffset +
> + sizeof (UINT32) +
> + sizeof (EFI_IMAGE_FILE_HEADER) +
> + ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader;
> + NumberOfSections = ImgHdr->Pe32.FileHeader.NumberOfSections;
> +
> + //
> + // Get base address from the first section header that doesn't point to code section.
> + //
> + for (Index = 0; Index < NumberOfSections; Index++) {
> + //
> + // Read section header from file
> + //
> + Size = sizeof (EFI_IMAGE_SECTION_HEADER);
> + Status = ImageContext->ImageRead (
> + ImageContext->Handle,
> + SectionHeaderOffset,
> + &Size,
> + &SectionHeader
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + Status = EFI_NOT_FOUND;
> +
> + if ((SectionHeader.Characteristics & EFI_IMAGE_SCN_CNT_CODE) == 0) {
> + //
> + // Build tool will save the address in PointerToRelocations & PointerToLineNumbers fields in the first section header
> + // that doesn't point to code section in image header.So there is an assumption that when the feature is enabled,
> + // if a module with a loading address assigned by tools, the PointerToRelocations & PointerToLineNumbers fields
> + // should not be Zero, or else, these 2 fields should be set to Zero
> + //
> + ValueInSectionHeader = ReadUnaligned64((UINT64*)&SectionHeader.PointerToRelocations);
> + if (ValueInSectionHeader != 0) {
> + //
> + // Found first section header that doesn't point to code section in which build tool saves the
> + // offset to SMRAM base as image base in PointerToRelocations & PointerToLineNumbers fields
> + //
> + FixLoadingAddress = (EFI_PHYSICAL_ADDRESS)(gLoadModuleAtFixAddressMmramBase + (INT64)ValueInSectionHeader);
> + //
> + // Check if the memory range is available.
> + //
> + Status = CheckAndMarkFixLoadingMemoryUsageBitMap (FixLoadingAddress, (UINTN)(ImageContext->ImageSize + ImageContext->SectionAlignment));
> + if (!EFI_ERROR(Status)) {
> + //
> + // The assigned address is valid. Return the specified loading address
> + //
> + ImageContext->ImageAddress = FixLoadingAddress;
> + }
> + }
> + break;
> + }
> + SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
> + }
> + DEBUG ((DEBUG_INFO|DEBUG_LOAD, "LOADING MODULE FIXED INFO: Loading module at fixed address %x, Status = %r\n", FixLoadingAddress, Status));
> + return Status;
> +}
> +/**
> + Loads an EFI image into SMRAM.
> +
> + @param DriverEntry EFI_MM_DRIVER_ENTRY instance
> +
> + @return EFI_STATUS
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLoadImage (
> + IN OUT EFI_MM_DRIVER_ENTRY *DriverEntry
> + )
> +{
> + VOID *Buffer;
> + UINTN PageCount;
> + EFI_STATUS Status;
> + EFI_PHYSICAL_ADDRESS DstBuffer;
> + PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
> +
> + DEBUG ((DEBUG_INFO, "MmLoadImage - %g\n", &DriverEntry->FileName));
> +
> + Buffer = AllocateCopyPool (DriverEntry->Pe32DataSize, DriverEntry->Pe32Data);
> + if (Buffer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + Status = EFI_SUCCESS;
> +
> + //
> + // Initialize ImageContext
> + //
> + ImageContext.Handle = Buffer;
> + ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
> +
> + //
> + // Get information about the image being loaded
> + //
> + Status = PeCoffLoaderGetImageInfo (&ImageContext);
> + if (EFI_ERROR (Status)) {
> + if (Buffer != NULL) {
> + MmFreePool (Buffer);
> + }
> + return Status;
> + }
> +
> + PageCount = (UINTN)EFI_SIZE_TO_PAGES((UINTN)ImageContext.ImageSize + ImageContext.SectionAlignment);
> + DstBuffer = (UINTN)(-1);
> +
> + Status = MmAllocatePages (
> + AllocateMaxAddress,
> + EfiRuntimeServicesCode,
> + PageCount,
> + &DstBuffer
> + );
> + if (EFI_ERROR (Status)) {
> + if (Buffer != NULL) {
> + MmFreePool (Buffer);
> + }
> + return Status;
> + }
> +
> + ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)DstBuffer;
> +
> + //
> + // Align buffer on section boundry
> + //
> + ImageContext.ImageAddress += ImageContext.SectionAlignment - 1;
> + ImageContext.ImageAddress &= ~((EFI_PHYSICAL_ADDRESS)(ImageContext.SectionAlignment - 1));
> +
> + //
> + // Load the image to our new buffer
> + //
> + Status = PeCoffLoaderLoadImage (&ImageContext);
> + if (EFI_ERROR (Status)) {
> + if (Buffer != NULL) {
> + MmFreePool (Buffer);
> + }
> + MmFreePages (DstBuffer, PageCount);
> + return Status;
> + }
> +
> + //
> + // Relocate the image in our new buffer
> + //
> + Status = PeCoffLoaderRelocateImage (&ImageContext);
> + if (EFI_ERROR (Status)) {
> + if (Buffer != NULL) {
> + MmFreePool (Buffer);
> + }
> + MmFreePages (DstBuffer, PageCount);
> + return Status;
> + }
> +
> + //
> + // Flush the instruction cache so the image data are written before we execute it
> + //
> + InvalidateInstructionCacheRange ((VOID *)(UINTN) ImageContext.ImageAddress, (UINTN) ImageContext.ImageSize);
> +
> + //
> + // Save Image EntryPoint in DriverEntry
> + //
> + DriverEntry->ImageEntryPoint = ImageContext.EntryPoint;
> + DriverEntry->ImageBuffer = DstBuffer;
> + DriverEntry->NumberOfPage = PageCount;
> +
> + if (mEfiSystemTable != NULL) {
> + Status = mEfiSystemTable->BootServices->AllocatePool (EfiBootServicesData, sizeof (EFI_LOADED_IMAGE_PROTOCOL), (VOID **)&DriverEntry->LoadedImage);
> + if (EFI_ERROR (Status)) {
> + if (Buffer != NULL) {
> + MmFreePool (Buffer);
> + }
> + MmFreePages (DstBuffer, PageCount);
> + return Status;
> + }
> +
> + ZeroMem (DriverEntry->LoadedImage, sizeof (EFI_LOADED_IMAGE_PROTOCOL));
> + //
> + // Fill in the remaining fields of the Loaded Image Protocol instance.
> + // Note: ImageBase is an SMRAM address that can not be accessed outside of SMRAM if SMRAM window is closed.
> + //
> + DriverEntry->LoadedImage->Revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
> + DriverEntry->LoadedImage->ParentHandle = NULL;
> + DriverEntry->LoadedImage->SystemTable = mEfiSystemTable;
> + DriverEntry->LoadedImage->DeviceHandle = NULL;
> + DriverEntry->LoadedImage->FilePath = NULL;
> +
> + DriverEntry->LoadedImage->ImageBase = (VOID *)(UINTN)DriverEntry->ImageBuffer;
> + DriverEntry->LoadedImage->ImageSize = ImageContext.ImageSize;
> + DriverEntry->LoadedImage->ImageCodeType = EfiRuntimeServicesCode;
> + DriverEntry->LoadedImage->ImageDataType = EfiRuntimeServicesData;
> +
> + //
> + // Create a new image handle in the UEFI handle database for the MM Driver
> + //
> + DriverEntry->ImageHandle = NULL;
> + Status = mEfiSystemTable->BootServices->InstallMultipleProtocolInterfaces (
> + &DriverEntry->ImageHandle,
> + &gEfiLoadedImageProtocolGuid, DriverEntry->LoadedImage,
> + NULL
> + );
> + }
> +
> + //
> + // Print the load address and the PDB file name if it is available
> + //
> +
> + DEBUG_CODE_BEGIN ();
> +
> + UINTN Index;
> + UINTN StartIndex;
> + CHAR8 EfiFileName[256];
> +
> +
> + DEBUG ((DEBUG_INFO | DEBUG_LOAD,
> + "Loading MM driver at 0x%11p EntryPoint=0x%11p ",
> + (VOID *)(UINTN) ImageContext.ImageAddress,
> + FUNCTION_ENTRY_POINT (ImageContext.EntryPoint)));
> +
> +
> + //
> + // Print Module Name by Pdb file path.
> + // Windows and Unix style file path are all trimmed correctly.
> + //
> + if (ImageContext.PdbPointer != NULL) {
> + StartIndex = 0;
> + for (Index = 0; ImageContext.PdbPointer[Index] != 0; Index++) {
> + if ((ImageContext.PdbPointer[Index] == '\\') || (ImageContext.PdbPointer[Index] == '/')) {
> + StartIndex = Index + 1;
> + }
> + }
> + //
> + // Copy the PDB file name to our temporary string, and replace .pdb with .efi
> + // The PDB file name is limited in the range of 0~255.
> + // If the length is bigger than 255, trim the redudant characters to avoid overflow in array boundary.
> + //
> + for (Index = 0; Index < sizeof (EfiFileName) - 4; Index++) {
> + EfiFileName[Index] = ImageContext.PdbPointer[Index + StartIndex];
> + if (EfiFileName[Index] == 0) {
> + EfiFileName[Index] = '.';
> + }
> + if (EfiFileName[Index] == '.') {
> + EfiFileName[Index + 1] = 'e';
> + EfiFileName[Index + 2] = 'f';
> + EfiFileName[Index + 3] = 'i';
> + EfiFileName[Index + 4] = 0;
> + break;
> + }
> + }
> +
> + if (Index == sizeof (EfiFileName) - 4) {
> + EfiFileName[Index] = 0;
> + }
> + DEBUG ((DEBUG_INFO | DEBUG_LOAD, "%a", EfiFileName)); // &Image->ImageContext.PdbPointer[StartIndex]));
> + }
> + DEBUG ((DEBUG_INFO | DEBUG_LOAD, "\n"));
> +
> + DEBUG_CODE_END ();
> +
> + //
> + // Free buffer allocated by Fv->ReadSection.
> + //
> + // The UEFI Boot Services FreePool() function must be used because Fv->ReadSection
> + // used the UEFI Boot Services AllocatePool() function
> + //
> + MmFreePool(Buffer);
> + return Status;
> +}
> +
> +/**
> + Preprocess dependency expression and update DriverEntry to reflect the
> + state of Before and After dependencies. If DriverEntry->Before
> + or DriverEntry->After is set it will never be cleared.
> +
> + @param DriverEntry DriverEntry element to update .
> +
> + @retval EFI_SUCCESS It always works.
> +
> +**/
> +EFI_STATUS
> +MmPreProcessDepex (
> + IN EFI_MM_DRIVER_ENTRY *DriverEntry
> + )
> +{
> + UINT8 *Iterator;
> +
> + Iterator = DriverEntry->Depex;
> + DriverEntry->Dependent = TRUE;
> +
> + if (*Iterator == EFI_DEP_BEFORE) {
> + DriverEntry->Before = TRUE;
> + } else if (*Iterator == EFI_DEP_AFTER) {
> + DriverEntry->After = TRUE;
> + }
> +
> + if (DriverEntry->Before || DriverEntry->After) {
> + CopyMem (&DriverEntry->BeforeAfterGuid, Iterator + 1, sizeof (EFI_GUID));
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Read Depex and pre-process the Depex for Before and After. If Section Extraction
> + protocol returns an error via ReadSection defer the reading of the Depex.
> +
> + @param DriverEntry Driver to work on.
> +
> + @retval EFI_SUCCESS Depex read and preprossesed
> + @retval EFI_PROTOCOL_ERROR The section extraction protocol returned an error
> + and Depex reading needs to be retried.
> + @retval Error DEPEX not found.
> +
> +**/
> +EFI_STATUS
> +MmGetDepexSectionAndPreProccess (
> + IN EFI_MM_DRIVER_ENTRY *DriverEntry
> + )
> +{
> + EFI_STATUS Status;
> +
> + //
> + // Data already read
> + //
> + if (DriverEntry->Depex == NULL) {
> + Status = EFI_NOT_FOUND;
> + } else {
> + Status = EFI_SUCCESS;
> + }
> + if (EFI_ERROR (Status)) {
> + if (Status == EFI_PROTOCOL_ERROR) {
> + //
> + // The section extraction protocol failed so set protocol error flag
> + //
> + DriverEntry->DepexProtocolError = TRUE;
> + } else {
> + //
> + // If no Depex assume depend on all architectural protocols
> + //
> + DriverEntry->Depex = NULL;
> + DriverEntry->Dependent = TRUE;
> + DriverEntry->DepexProtocolError = FALSE;
> + }
> + } else {
> + //
> + // Set Before and After state information based on Depex
> + // Driver will be put in Dependent state
> + //
> + MmPreProcessDepex (DriverEntry);
> + DriverEntry->DepexProtocolError = FALSE;
> + }
> +
> + return Status;
> +}
> +
> +/**
> + This is the main Dispatcher for MM and it exits when there are no more
> + drivers to run. Drain the mScheduledQueue and load and start a PE
> + image for each driver. Search the mDiscoveredList to see if any driver can
> + be placed on the mScheduledQueue. If no drivers are placed on the
> + mScheduledQueue exit the function.
> +
> + @retval EFI_SUCCESS All of the MM Drivers that could be dispatched
> + have been run and the MM Entry Point has been
> + registered.
> + @retval EFI_NOT_READY The MM Driver that registered the MM Entry Point
> + was just dispatched.
> + @retval EFI_NOT_FOUND There are no MM Drivers available to be dispatched.
> + @retval EFI_ALREADY_STARTED The MM Dispatcher is already running
> +
> +**/
> +EFI_STATUS
> +MmDispatcher (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + LIST_ENTRY *Link;
> + EFI_MM_DRIVER_ENTRY *DriverEntry;
> + BOOLEAN ReadyToRun;
> + BOOLEAN PreviousMmEntryPointRegistered;
> +
> + DEBUG ((DEBUG_INFO, "MmDispatcher\n"));
> +
> + if (!gRequestDispatch) {
> + DEBUG ((DEBUG_INFO, " !gRequestDispatch\n"));
> + return EFI_NOT_FOUND;
> + }
> +
> + if (gDispatcherRunning) {
> + DEBUG ((DEBUG_INFO, " gDispatcherRunning\n"));
> + //
> + // If the dispatcher is running don't let it be restarted.
> + //
> + return EFI_ALREADY_STARTED;
> + }
> +
> + gDispatcherRunning = TRUE;
> +
> + do {
> + //
> + // Drain the Scheduled Queue
> + //
> + DEBUG ((DEBUG_INFO, " Drain the Scheduled Queue\n"));
> + while (!IsListEmpty (&mScheduledQueue)) {
> + DriverEntry = CR (
> + mScheduledQueue.ForwardLink,
> + EFI_MM_DRIVER_ENTRY,
> + ScheduledLink,
> + EFI_MM_DRIVER_ENTRY_SIGNATURE
> + );
> + DEBUG ((DEBUG_INFO, " DriverEntry (Scheduled) - %g\n", &DriverEntry->FileName));
> +
> + //
> + // Load the MM Driver image into memory. If the Driver was transitioned from
> + // Untrused to Scheduled it would have already been loaded so we may need to
> + // skip the LoadImage
> + //
> + if (DriverEntry->ImageHandle == NULL) {
> + Status = MmLoadImage (DriverEntry);
> +
> + //
> + // Update the driver state to reflect that it's been loaded
> + //
> + if (EFI_ERROR (Status)) {
> + //
> + // The MM Driver could not be loaded, and do not attempt to load or start it again.
> + // Take driver from Scheduled to Initialized.
> + //
> + DriverEntry->Initialized = TRUE;
> + DriverEntry->Scheduled = FALSE;
> + RemoveEntryList (&DriverEntry->ScheduledLink);
> +
> + //
> + // If it's an error don't try the StartImage
> + //
> + continue;
> + }
> + }
> +
> + DriverEntry->Scheduled = FALSE;
> + DriverEntry->Initialized = TRUE;
> + RemoveEntryList (&DriverEntry->ScheduledLink);
> +
> + /*REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
> + EFI_PROGRESS_CODE,
> + EFI_SOFTWARE_MM_DRIVER | EFI_SW_PC_INIT_BEGIN,
> + &DriverEntry->ImageHandle,
> + sizeof (DriverEntry->ImageHandle)
> + );*/
> +
> + //
> + // Cache state of MmEntryPointRegistered before calling entry point
> + //
> + PreviousMmEntryPointRegistered = gMmCorePrivate->MmEntryPointRegistered;
> +
> + //
> + // For each MM driver, pass NULL as ImageHandle
> + //
> + if (mEfiSystemTable == NULL) {
> + DEBUG ((DEBUG_INFO, "StartImage - 0x%x (Standalone Mode)\n", DriverEntry->ImageEntryPoint));
> + Status = ((MM_IMAGE_ENTRY_POINT)(UINTN)DriverEntry->ImageEntryPoint)(DriverEntry->ImageHandle, &gMmCoreMmst);
> + } else {
> + DEBUG ((DEBUG_INFO, "StartImage - 0x%x (Tradition Mode)\n", DriverEntry->ImageEntryPoint));
> + Status = ((EFI_IMAGE_ENTRY_POINT)(UINTN)DriverEntry->ImageEntryPoint)(DriverEntry->ImageHandle, mEfiSystemTable);
> + }
> + if (EFI_ERROR(Status)){
> + DEBUG ((DEBUG_INFO, "StartImage Status - %r\n", Status));
> + MmFreePages(DriverEntry->ImageBuffer, DriverEntry->NumberOfPage);
> + }
> +
> + /*REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
> + EFI_PROGRESS_CODE,
> + EFI_SOFTWARE_MM_DRIVER | EFI_SW_PC_INIT_END,
> + &DriverEntry->ImageHandle,
> + sizeof (DriverEntry->ImageHandle)
> + );*/
> +
> + if (!PreviousMmEntryPointRegistered && gMmCorePrivate->MmEntryPointRegistered) {
> + //
> + // Return immediately if the MM Entry Point was registered by the MM
> + // Driver that was just dispatched. The MM IPL will reinvoke the MM
> + // Core Dispatcher. This is required so MM Mode may be enabled as soon
> + // as all the dependent MM Drivers for MM Mode have been dispatched.
> + // Once the MM Entry Point has been registered, then MM Mode will be
> + // used.
> + //
> + gRequestDispatch = TRUE;
> + gDispatcherRunning = FALSE;
> + return EFI_NOT_READY;
> + }
> + }
> +
> + //
> + // Search DriverList for items to place on Scheduled Queue
> + //
> + DEBUG ((DEBUG_INFO, " Search DriverList for items to place on Scheduled Queue\n"));
> + ReadyToRun = FALSE;
> + for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {
> + DriverEntry = CR (Link, EFI_MM_DRIVER_ENTRY, Link, EFI_MM_DRIVER_ENTRY_SIGNATURE);
> + DEBUG ((DEBUG_INFO, " DriverEntry (Discovered) - %g\n", &DriverEntry->FileName));
> +
> + if (DriverEntry->DepexProtocolError){
> + //
> + // If Section Extraction Protocol did not let the Depex be read before retry the read
> + //
> + Status = MmGetDepexSectionAndPreProccess (DriverEntry);
> + }
> +
> + if (DriverEntry->Dependent) {
> + if (MmIsSchedulable (DriverEntry)) {
> + MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);
> + ReadyToRun = TRUE;
> + }
> + }
> + }
> + } while (ReadyToRun);
> +
> + //
> + // If there is no more MM driver to dispatch, stop the dispatch request
> + //
> + DEBUG ((DEBUG_INFO, " no more MM driver to dispatch, stop the dispatch request\n"));
> + gRequestDispatch = FALSE;
> + for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {
> + DriverEntry = CR (Link, EFI_MM_DRIVER_ENTRY, Link, EFI_MM_DRIVER_ENTRY_SIGNATURE);
> + DEBUG ((DEBUG_INFO, " DriverEntry (Discovered) - %g\n", &DriverEntry->FileName));
> +
> + if (!DriverEntry->Initialized){
> + //
> + // We have MM driver pending to dispatch
> + //
> + gRequestDispatch = TRUE;
> + break;
> + }
> + }
> +
> + gDispatcherRunning = FALSE;
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Insert InsertedDriverEntry onto the mScheduledQueue. To do this you
> + must add any driver with a before dependency on InsertedDriverEntry first.
> + You do this by recursively calling this routine. After all the Befores are
> + processed you can add InsertedDriverEntry to the mScheduledQueue.
> + Then you can add any driver with an After dependency on InsertedDriverEntry
> + by recursively calling this routine.
> +
> + @param InsertedDriverEntry The driver to insert on the ScheduledLink Queue
> +
> +**/
> +VOID
> +MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter (
> + IN EFI_MM_DRIVER_ENTRY *InsertedDriverEntry
> + )
> +{
> + LIST_ENTRY *Link;
> + EFI_MM_DRIVER_ENTRY *DriverEntry;
> +
> + //
> + // Process Before Dependency
> + //
> + for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {
> + DriverEntry = CR(Link, EFI_MM_DRIVER_ENTRY, Link, EFI_MM_DRIVER_ENTRY_SIGNATURE);
> + if (DriverEntry->Before && DriverEntry->Dependent && DriverEntry != InsertedDriverEntry) {
> + DEBUG ((DEBUG_DISPATCH, "Evaluate MM DEPEX for FFS(%g)\n", &DriverEntry->FileName));
> + DEBUG ((DEBUG_DISPATCH, " BEFORE FFS(%g) = ", &DriverEntry->BeforeAfterGuid));
> + if (CompareGuid (&InsertedDriverEntry->FileName, &DriverEntry->BeforeAfterGuid)) {
> + //
> + // Recursively process BEFORE
> + //
> + DEBUG ((DEBUG_DISPATCH, "TRUE\n END\n RESULT = TRUE\n"));
> + MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);
> + } else {
> + DEBUG ((DEBUG_DISPATCH, "FALSE\n END\n RESULT = FALSE\n"));
> + }
> + }
> + }
> +
> + //
> + // Convert driver from Dependent to Scheduled state
> + //
> +
> + InsertedDriverEntry->Dependent = FALSE;
> + InsertedDriverEntry->Scheduled = TRUE;
> + InsertTailList (&mScheduledQueue, &InsertedDriverEntry->ScheduledLink);
> +
> +
> + //
> + // Process After Dependency
> + //
> + for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {
> + DriverEntry = CR(Link, EFI_MM_DRIVER_ENTRY, Link, EFI_MM_DRIVER_ENTRY_SIGNATURE);
> + if (DriverEntry->After && DriverEntry->Dependent && DriverEntry != InsertedDriverEntry) {
> + DEBUG ((DEBUG_DISPATCH, "Evaluate MM DEPEX for FFS(%g)\n", &DriverEntry->FileName));
> + DEBUG ((DEBUG_DISPATCH, " AFTER FFS(%g) = ", &DriverEntry->BeforeAfterGuid));
> + if (CompareGuid (&InsertedDriverEntry->FileName, &DriverEntry->BeforeAfterGuid)) {
> + //
> + // Recursively process AFTER
> + //
> + DEBUG ((DEBUG_DISPATCH, "TRUE\n END\n RESULT = TRUE\n"));
> + MmInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);
> + } else {
> + DEBUG ((DEBUG_DISPATCH, "FALSE\n END\n RESULT = FALSE\n"));
> + }
> + }
> + }
> +}
> +
> +/**
> + Return TRUE if the Fv has been processed, FALSE if not.
> +
> + @param FvHandle The handle of a FV that's being tested
> +
> + @retval TRUE Fv protocol on FvHandle has been processed
> + @retval FALSE Fv protocol on FvHandle has not yet been
> + processed
> +
> +**/
> +BOOLEAN
> +FvHasBeenProcessed (
> + IN EFI_HANDLE FvHandle
> + )
> +{
> + LIST_ENTRY *Link;
> + KNOWN_HANDLE *KnownHandle;
> +
> + for (Link = mFvHandleList.ForwardLink; Link != &mFvHandleList; Link = Link->ForwardLink) {
> + KnownHandle = CR(Link, KNOWN_HANDLE, Link, KNOWN_HANDLE_SIGNATURE);
> + if (KnownHandle->Handle == FvHandle) {
> + return TRUE;
> + }
> + }
> + return FALSE;
> +}
> +
> +/**
> + Remember that Fv protocol on FvHandle has had it's drivers placed on the
> + mDiscoveredList. This fucntion adds entries on the mFvHandleList. Items are
> + never removed/freed from the mFvHandleList.
> +
> + @param FvHandle The handle of a FV that has been processed
> +
> +**/
> +VOID
> +FvIsBeingProcesssed (
> + IN EFI_HANDLE FvHandle
> + )
> +{
> + KNOWN_HANDLE *KnownHandle;
> +
> + DEBUG ((DEBUG_INFO, "FvIsBeingProcesssed - 0x%08x\n", FvHandle));
> +
> + KnownHandle = AllocatePool (sizeof (KNOWN_HANDLE));
> + ASSERT (KnownHandle != NULL);
> +
> + KnownHandle->Signature = KNOWN_HANDLE_SIGNATURE;
> + KnownHandle->Handle = FvHandle;
> + InsertTailList (&mFvHandleList, &KnownHandle->Link);
> +}
> +
> +/**
> + Add an entry to the mDiscoveredList. Allocate memory to store the DriverEntry,
> + and initilize any state variables. Read the Depex from the FV and store it
> + in DriverEntry. Pre-process the Depex to set the Before and After state.
> + The Discovered list is never free'ed and contains booleans that represent the
> + other possible MM driver states.
> +
> + @param Fv Fv protocol, needed to read Depex info out of
> + FLASH.
> + @param FvHandle Handle for Fv, needed in the
> + EFI_MM_DRIVER_ENTRY so that the PE image can be
> + read out of the FV at a later time.
> + @param DriverName Name of driver to add to mDiscoveredList.
> +
> + @retval EFI_SUCCESS If driver was added to the mDiscoveredList.
> + @retval EFI_ALREADY_STARTED The driver has already been started. Only one
> + DriverName may be active in the system at any one
> + time.
> +
> +**/
> +EFI_STATUS
> +MmAddToDriverList (
> + IN EFI_HANDLE FvHandle,
> + IN VOID *Pe32Data,
> + IN UINTN Pe32DataSize,
> + IN VOID *Depex,
> + IN UINTN DepexSize,
> + IN EFI_GUID *DriverName
> + )
> +{
> + EFI_MM_DRIVER_ENTRY *DriverEntry;
> +
> + DEBUG ((DEBUG_INFO, "MmAddToDriverList - %g (0x%08x)\n", DriverName, Pe32Data));
> +
> + //
> + // Create the Driver Entry for the list. ZeroPool initializes lots of variables to
> + // NULL or FALSE.
> + //
> + DriverEntry = AllocateZeroPool (sizeof (EFI_MM_DRIVER_ENTRY));
> + ASSERT (DriverEntry != NULL);
> +
> + DriverEntry->Signature = EFI_MM_DRIVER_ENTRY_SIGNATURE;
> + CopyGuid (&DriverEntry->FileName, DriverName);
> + DriverEntry->FvHandle = FvHandle;
> + DriverEntry->Pe32Data = Pe32Data;
> + DriverEntry->Pe32DataSize = Pe32DataSize;
> + DriverEntry->Depex = Depex;
> + DriverEntry->DepexSize = DepexSize;
> +
> + MmGetDepexSectionAndPreProccess (DriverEntry);
> +
> + InsertTailList (&mDiscoveredList, &DriverEntry->Link);
> + gRequestDispatch = TRUE;
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + Event notification that is fired every time a FV dispatch protocol is added.
> + More than one protocol may have been added when this event is fired, so you
> + must loop on MmLocateHandle () to see how many protocols were added and
> + do the following to each FV:
> + If the Fv has already been processed, skip it. If the Fv has not been
> + processed then mark it as being processed, as we are about to process it.
> + Read the Fv and add any driver in the Fv to the mDiscoveredList.The
> + mDiscoveredList is never free'ed and contains variables that define
> + the other states the MM driver transitions to..
> + While you are at it read the A Priori file into memory.
> + Place drivers in the A Priori list onto the mScheduledQueue.
> +
> + @param DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmDriverDispatchHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_STATUS Status;
> +
> + DEBUG ((DEBUG_INFO, "MmDriverDispatchHandler\n"));
> +
> + //
> + // Execute the MM Dispatcher on any newly discovered FVs and previously
> + // discovered MM drivers that have been discovered but not dispatched.
> + //
> + Status = MmDispatcher ();
> +
> + //
> + // Check to see if CommBuffer and CommBufferSize are valid
> + //
> + if (CommBuffer != NULL && CommBufferSize != NULL) {
> + if (*CommBufferSize > 0) {
> + if (Status == EFI_NOT_READY) {
> + //
> + // If a the MM Core Entry Point was just registered, then set flag to
> + // request the MM Dispatcher to be restarted.
> + //
> + *(UINT8 *)CommBuffer = COMM_BUFFER_MM_DISPATCH_RESTART;
> + } else if (!EFI_ERROR (Status)) {
> + //
> + // Set the flag to show that the MM Dispatcher executed without errors
> + //
> + *(UINT8 *)CommBuffer = COMM_BUFFER_MM_DISPATCH_SUCCESS;
> + } else {
> + //
> + // Set the flag to show that the MM Dispatcher encountered an error
> + //
> + *(UINT8 *)CommBuffer = COMM_BUFFER_MM_DISPATCH_ERROR;
> + }
> + }
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmFvDispatchHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_STATUS Status;
> + EFI_MM_COMMUNICATE_FV_DISPATCH_DATA *CommunicationFvDispatchData;
> + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
> +
> + DEBUG ((DEBUG_INFO, "MmFvDispatchHandler\n"));
> +
> + CommunicationFvDispatchData = CommBuffer;
> +
> + DEBUG ((DEBUG_INFO, " Dispatch - 0x%016lx - 0x%016lx\n", CommunicationFvDispatchData->Address, CommunicationFvDispatchData->Size));
> +
> + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)CommunicationFvDispatchData->Address;
> +
> + MmCoreFfsFindMmDriver (FwVolHeader);
> +
> + //
> + // Execute the MM Dispatcher on any newly discovered FVs and previously
> + // discovered MM drivers that have been discovered but not dispatched.
> + //
> + Status = MmDispatcher ();
> +
> + return Status;
> +}
> +
> +/**
> + Traverse the discovered list for any drivers that were discovered but not loaded
> + because the dependency experessions evaluated to false.
> +
> +**/
> +VOID
> +MmDisplayDiscoveredNotDispatched (
> + VOID
> + )
> +{
> + LIST_ENTRY *Link;
> + EFI_MM_DRIVER_ENTRY *DriverEntry;
> +
> + for (Link = mDiscoveredList.ForwardLink;Link !=&mDiscoveredList; Link = Link->ForwardLink) {
> + DriverEntry = CR(Link, EFI_MM_DRIVER_ENTRY, Link, EFI_MM_DRIVER_ENTRY_SIGNATURE);
> + if (DriverEntry->Dependent) {
> + DEBUG ((DEBUG_LOAD, "MM Driver %g was discovered but not loaded!!\n", &DriverEntry->FileName));
> + }
> + }
> +}
> diff --git a/StandaloneMmPkg/Core/FwVol.c b/StandaloneMmPkg/Core/FwVol.c
> new file mode 100644
> index 0000000000..901c58bc53
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/FwVol.c
> @@ -0,0 +1,104 @@
> +/**@file
> +
> +Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
> +Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> +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 "StandaloneMmCore.h"
> +#include <Library/FvLib.h>
> +
> +//
> +// List of file types supported by dispatcher
> +//
> +EFI_FV_FILETYPE mMmFileTypes[] = {
> + EFI_FV_FILETYPE_MM,
> + 0xE, //EFI_FV_FILETYPE_MM_STANDALONE,
> + //
> + // Note: DXE core will process the FV image file, so skip it in MM core
> + // EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
> + //
> +};
> +
> +EFI_STATUS
> +MmAddToDriverList (
> + IN EFI_HANDLE FvHandle,
> + IN VOID *Pe32Data,
> + IN UINTN Pe32DataSize,
> + IN VOID *Depex,
> + IN UINTN DepexSize,
> + IN EFI_GUID *DriverName
> + );
> +
> +BOOLEAN
> +FvHasBeenProcessed (
> + IN EFI_HANDLE FvHandle
> + );
> +
> +VOID
> +FvIsBeingProcesssed (
> + IN EFI_HANDLE FvHandle
> + );
> +
> +EFI_STATUS
> +MmCoreFfsFindMmDriver (
> + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader
> + )
> +/*++
> +
> +Routine Description:
> + Given the pointer to the Firmware Volume Header find the
> + MM driver and return it's PE32 image.
> +
> +Arguments:
> + FwVolHeader - Pointer to memory mapped FV
> +
> +Returns:
> + other - Failure
> +
> +--*/
> +{
> + EFI_STATUS Status;
> + EFI_STATUS DepexStatus;
> + EFI_FFS_FILE_HEADER *FileHeader;
> + EFI_FV_FILETYPE FileType;
> + VOID *Pe32Data;
> + UINTN Pe32DataSize;
> + VOID *Depex;
> + UINTN DepexSize;
> + UINTN Index;
> +
> + DEBUG((DEBUG_INFO, "MmCoreFfsFindMmDriver - 0x%x\n", FwVolHeader));
> +
> + if (FvHasBeenProcessed (FwVolHeader)) {
> + return EFI_SUCCESS;
> + }
> +
> + FvIsBeingProcesssed (FwVolHeader);
> +
> + for (Index = 0; Index < sizeof(mMmFileTypes) / sizeof(mMmFileTypes[0]); Index++) {
> + DEBUG((DEBUG_INFO, "Check MmFileTypes - 0x%x\n", mMmFileTypes[Index]));
> + FileType = mMmFileTypes[Index];
> + FileHeader = NULL;
> + do {
> + Status = FfsFindNextFile(FileType, FwVolHeader, &FileHeader);
> + if (!EFI_ERROR(Status)) {
> + Status = FfsFindSectionData(EFI_SECTION_PE32, FileHeader, &Pe32Data, &Pe32DataSize);
> + DEBUG((DEBUG_INFO, "Find PE data - 0x%x\n", Pe32Data));
> + DepexStatus = FfsFindSectionData(EFI_SECTION_MM_DEPEX, FileHeader, &Depex, &DepexSize);
> + if (!EFI_ERROR(DepexStatus)) {
> + MmAddToDriverList(FwVolHeader, Pe32Data, Pe32DataSize, Depex, DepexSize, &FileHeader->Name);
> + }
> + }
> + } while (!EFI_ERROR(Status));
> + }
> +
> + return Status;
> +}
> diff --git a/StandaloneMmPkg/Core/Handle.c b/StandaloneMmPkg/Core/Handle.c
> new file mode 100644
> index 0000000000..01832f4bbe
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Handle.c
> @@ -0,0 +1,533 @@
> +/** @file
> + SMM handle & protocol handling.
> +
> + Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +//
> +// mProtocolDatabase - A list of all protocols in the system. (simple list for now)
> +// gHandleList - A list of all the handles in the system
> +//
> +LIST_ENTRY mProtocolDatabase = INITIALIZE_LIST_HEAD_VARIABLE (mProtocolDatabase);
> +LIST_ENTRY gHandleList = INITIALIZE_LIST_HEAD_VARIABLE (gHandleList);
> +
> +/**
> + Check whether a handle is a valid EFI_HANDLE
> +
> + @param UserHandle The handle to check
> +
> + @retval EFI_INVALID_PARAMETER The handle is NULL or not a valid EFI_HANDLE.
> + @retval EFI_SUCCESS The handle is valid EFI_HANDLE.
> +
> +**/
> +EFI_STATUS
> +MmValidateHandle (
> + IN EFI_HANDLE UserHandle
> + )
> +{
> + IHANDLE *Handle;
> +
> + Handle = (IHANDLE *)UserHandle;
> + if (Handle == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> + if (Handle->Signature != EFI_HANDLE_SIGNATURE) {
> + return EFI_INVALID_PARAMETER;
> + }
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Finds the protocol entry for the requested protocol.
> +
> + @param Protocol The ID of the protocol
> + @param Create Create a new entry if not found
> +
> + @return Protocol entry
> +
> +**/
> +PROTOCOL_ENTRY *
> +MmFindProtocolEntry (
> + IN EFI_GUID *Protocol,
> + IN BOOLEAN Create
> + )
> +{
> + LIST_ENTRY *Link;
> + PROTOCOL_ENTRY *Item;
> + PROTOCOL_ENTRY *ProtEntry;
> +
> + //
> + // Search the database for the matching GUID
> + //
> +
> + ProtEntry = NULL;
> + for (Link = mProtocolDatabase.ForwardLink;
> + Link != &mProtocolDatabase;
> + Link = Link->ForwardLink) {
> +
> + Item = CR(Link, PROTOCOL_ENTRY, AllEntries, PROTOCOL_ENTRY_SIGNATURE);
> + if (CompareGuid (&Item->ProtocolID, Protocol)) {
> + //
> + // This is the protocol entry
> + //
> + ProtEntry = Item;
> + break;
> + }
> + }
> +
> + //
> + // If the protocol entry was not found and Create is TRUE, then
> + // allocate a new entry
> + //
> + if ((ProtEntry == NULL) && Create) {
> + ProtEntry = AllocatePool (sizeof(PROTOCOL_ENTRY));
> + if (ProtEntry != NULL) {
> + //
> + // Initialize new protocol entry structure
> + //
> + ProtEntry->Signature = PROTOCOL_ENTRY_SIGNATURE;
> + CopyGuid ((VOID *)&ProtEntry->ProtocolID, Protocol);
> + InitializeListHead (&ProtEntry->Protocols);
> + InitializeListHead (&ProtEntry->Notify);
> +
> + //
> + // Add it to protocol database
> + //
> + InsertTailList (&mProtocolDatabase, &ProtEntry->AllEntries);
> + }
> + }
> + return ProtEntry;
> +}
> +
> +/**
> + Finds the protocol instance for the requested handle and protocol.
> + Note: This function doesn't do parameters checking, it's caller's responsibility
> + to pass in valid parameters.
> +
> + @param Handle The handle to search the protocol on
> + @param Protocol GUID of the protocol
> + @param Interface The interface for the protocol being searched
> +
> + @return Protocol instance (NULL: Not found)
> +
> +**/
> +PROTOCOL_INTERFACE *
> +MmFindProtocolInterface (
> + IN IHANDLE *Handle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + )
> +{
> + PROTOCOL_INTERFACE *Prot;
> + PROTOCOL_ENTRY *ProtEntry;
> + LIST_ENTRY *Link;
> +
> + Prot = NULL;
> +
> + //
> + // Lookup the protocol entry for this protocol ID
> + //
> + ProtEntry = MmFindProtocolEntry (Protocol, FALSE);
> + if (ProtEntry != NULL) {
> + //
> + // Look at each protocol interface for any matches
> + //
> + for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link=Link->ForwardLink) {
> + //
> + // If this protocol interface matches, remove it
> + //
> + Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
> + if (Prot->Interface == Interface && Prot->Protocol == ProtEntry) {
> + break;
> + }
> + Prot = NULL;
> + }
> + }
> + return Prot;
> +}
> +
> +/**
> + Wrapper function to MmInstallProtocolInterfaceNotify. This is the public API which
> + Calls the private one which contains a BOOLEAN parameter for notifications
> +
> + @param UserHandle The handle to install the protocol handler on,
> + or NULL if a new handle is to be allocated
> + @param Protocol The protocol to add to the handle
> + @param InterfaceType Indicates whether Interface is supplied in
> + native form.
> + @param Interface The interface for the protocol being added
> +
> + @return Status code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInstallProtocolInterface (
> + IN OUT EFI_HANDLE *UserHandle,
> + IN EFI_GUID *Protocol,
> + IN EFI_INTERFACE_TYPE InterfaceType,
> + IN VOID *Interface
> + )
> +{
> + return MmInstallProtocolInterfaceNotify (
> + UserHandle,
> + Protocol,
> + InterfaceType,
> + Interface,
> + TRUE
> + );
> +}
> +
> +/**
> + Installs a protocol interface into the boot services environment.
> +
> + @param UserHandle The handle to install the protocol handler on,
> + or NULL if a new handle is to be allocated
> + @param Protocol The protocol to add to the handle
> + @param InterfaceType Indicates whether Interface is supplied in
> + native form.
> + @param Interface The interface for the protocol being added
> + @param Notify indicates whether notify the notification list
> + for this protocol
> +
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
> + @retval EFI_SUCCESS Protocol interface successfully installed
> +
> +**/
> +EFI_STATUS
> +MmInstallProtocolInterfaceNotify (
> + IN OUT EFI_HANDLE *UserHandle,
> + IN EFI_GUID *Protocol,
> + IN EFI_INTERFACE_TYPE InterfaceType,
> + IN VOID *Interface,
> + IN BOOLEAN Notify
> + )
> +{
> + PROTOCOL_INTERFACE *Prot;
> + PROTOCOL_ENTRY *ProtEntry;
> + IHANDLE *Handle;
> + EFI_STATUS Status;
> + VOID *ExistingInterface;
> +
> + //
> + // returns EFI_INVALID_PARAMETER if InterfaceType is invalid.
> + // Also added check for invalid UserHandle and Protocol pointers.
> + //
> + if (UserHandle == NULL || Protocol == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (InterfaceType != EFI_NATIVE_INTERFACE) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + //
> + // Print debug message
> + //
> + DEBUG((DEBUG_LOAD | DEBUG_INFO, "MmInstallProtocolInterface: %g %p\n", Protocol, Interface));
> +
> + Status = EFI_OUT_OF_RESOURCES;
> + Prot = NULL;
> + Handle = NULL;
> +
> + if (*UserHandle != NULL) {
> + Status = MmHandleProtocol (*UserHandle, Protocol, (VOID **)&ExistingInterface);
> + if (!EFI_ERROR (Status)) {
> + return EFI_INVALID_PARAMETER;
> + }
> + }
> +
> + //
> + // Lookup the Protocol Entry for the requested protocol
> + //
> + ProtEntry = MmFindProtocolEntry (Protocol, TRUE);
> + if (ProtEntry == NULL) {
> + goto Done;
> + }
> +
> + //
> + // Allocate a new protocol interface structure
> + //
> + Prot = AllocateZeroPool (sizeof(PROTOCOL_INTERFACE));
> + if (Prot == NULL) {
> + Status = EFI_OUT_OF_RESOURCES;
> + goto Done;
> + }
> +
> + //
> + // If caller didn't supply a handle, allocate a new one
> + //
> + Handle = (IHANDLE *)*UserHandle;
> + if (Handle == NULL) {
> + Handle = AllocateZeroPool (sizeof(IHANDLE));
> + if (Handle == NULL) {
> + Status = EFI_OUT_OF_RESOURCES;
> + goto Done;
> + }
> +
> + //
> + // Initialize new handler structure
> + //
> + Handle->Signature = EFI_HANDLE_SIGNATURE;
> + InitializeListHead (&Handle->Protocols);
> +
> + //
> + // Add this handle to the list global list of all handles
> + // in the system
> + //
> + InsertTailList (&gHandleList, &Handle->AllHandles);
> + }
> +
> + Status = MmValidateHandle (Handle);
> + if (EFI_ERROR (Status)) {
> + goto Done;
> + }
> +
> + //
> + // Each interface that is added must be unique
> + //
> + ASSERT (MmFindProtocolInterface (Handle, Protocol, Interface) == NULL);
> +
> + //
> + // Initialize the protocol interface structure
> + //
> + Prot->Signature = PROTOCOL_INTERFACE_SIGNATURE;
> + Prot->Handle = Handle;
> + Prot->Protocol = ProtEntry;
> + Prot->Interface = Interface;
> +
> + //
> + // Add this protocol interface to the head of the supported
> + // protocol list for this handle
> + //
> + InsertHeadList (&Handle->Protocols, &Prot->Link);
> +
> + //
> + // Add this protocol interface to the tail of the
> + // protocol entry
> + //
> + InsertTailList (&ProtEntry->Protocols, &Prot->ByProtocol);
> +
> + //
> + // Notify the notification list for this protocol
> + //
> + if (Notify) {
> + MmNotifyProtocol (Prot);
> + }
> + Status = EFI_SUCCESS;
> +
> +Done:
> + if (!EFI_ERROR (Status)) {
> + //
> + // Return the new handle back to the caller
> + //
> + *UserHandle = Handle;
> + } else {
> + //
> + // There was an error, clean up
> + //
> + if (Prot != NULL) {
> + FreePool (Prot);
> + }
> + }
> + return Status;
> +}
> +
> +/**
> + Uninstalls all instances of a protocol:interfacer from a handle.
> + If the last protocol interface is remove from the handle, the
> + handle is freed.
> +
> + @param UserHandle The handle to remove the protocol handler from
> + @param Protocol The protocol, of protocol:interface, to remove
> + @param Interface The interface, of protocol:interface, to remove
> +
> + @retval EFI_INVALID_PARAMETER Protocol is NULL.
> + @retval EFI_SUCCESS Protocol interface successfully uninstalled.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmUninstallProtocolInterface (
> + IN EFI_HANDLE UserHandle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + )
> +{
> + EFI_STATUS Status;
> + IHANDLE *Handle;
> + PROTOCOL_INTERFACE *Prot;
> +
> + //
> + // Check that Protocol is valid
> + //
> + if (Protocol == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + //
> + // Check that UserHandle is a valid handle
> + //
> + Status = MmValidateHandle (UserHandle);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + //
> + // Check that Protocol exists on UserHandle, and Interface matches the interface in the database
> + //
> + Prot = MmFindProtocolInterface (UserHandle, Protocol, Interface);
> + if (Prot == NULL) {
> + return EFI_NOT_FOUND;
> + }
> +
> + //
> + // Remove the protocol interface from the protocol
> + //
> + Status = EFI_NOT_FOUND;
> + Handle = (IHANDLE *)UserHandle;
> + Prot = MmRemoveInterfaceFromProtocol (Handle, Protocol, Interface);
> +
> + if (Prot != NULL) {
> + //
> + // Remove the protocol interface from the handle
> + //
> + RemoveEntryList (&Prot->Link);
> +
> + //
> + // Free the memory
> + //
> + Prot->Signature = 0;
> + FreePool (Prot);
> + Status = EFI_SUCCESS;
> + }
> +
> + //
> + // If there are no more handlers for the handle, free the handle
> + //
> + if (IsListEmpty (&Handle->Protocols)) {
> + Handle->Signature = 0;
> + RemoveEntryList (&Handle->AllHandles);
> + FreePool (Handle);
> + }
> + return Status;
> +}
> +
> +/**
> + Locate a certain GUID protocol interface in a Handle's protocols.
> +
> + @param UserHandle The handle to obtain the protocol interface on
> + @param Protocol The GUID of the protocol
> +
> + @return The requested protocol interface for the handle
> +
> +**/
> +PROTOCOL_INTERFACE *
> +MmGetProtocolInterface (
> + IN EFI_HANDLE UserHandle,
> + IN EFI_GUID *Protocol
> + )
> +{
> + EFI_STATUS Status;
> + PROTOCOL_ENTRY *ProtEntry;
> + PROTOCOL_INTERFACE *Prot;
> + IHANDLE *Handle;
> + LIST_ENTRY *Link;
> +
> + Status = MmValidateHandle (UserHandle);
> + if (EFI_ERROR (Status)) {
> + return NULL;
> + }
> +
> + Handle = (IHANDLE *)UserHandle;
> +
> + //
> + // Look at each protocol interface for a match
> + //
> + for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
> + Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
> + ProtEntry = Prot->Protocol;
> + if (CompareGuid (&ProtEntry->ProtocolID, Protocol)) {
> + return Prot;
> + }
> + }
> + return NULL;
> +}
> +
> +/**
> + Queries a handle to determine if it supports a specified protocol.
> +
> + @param UserHandle The handle being queried.
> + @param Protocol The published unique identifier of the protocol.
> + @param Interface Supplies the address where a pointer to the
> + corresponding Protocol Interface is returned.
> +
> + @retval EFI_SUCCESS The interface information for the specified protocol was returned.
> + @retval EFI_UNSUPPORTED The device does not support the specified protocol.
> + @retval EFI_INVALID_PARAMETER Handle is not a valid EFI_HANDLE..
> + @retval EFI_INVALID_PARAMETER Protocol is NULL.
> + @retval EFI_INVALID_PARAMETER Interface is NULL.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmHandleProtocol (
> + IN EFI_HANDLE UserHandle,
> + IN EFI_GUID *Protocol,
> + OUT VOID **Interface
> + )
> +{
> + EFI_STATUS Status;
> + PROTOCOL_INTERFACE *Prot;
> +
> + //
> + // Check for invalid Protocol
> + //
> + if (Protocol == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + //
> + // Check for invalid Interface
> + //
> + if (Interface == NULL) {
> + return EFI_INVALID_PARAMETER;
> + } else {
> + *Interface = NULL;
> + }
> +
> + //
> + // Check for invalid UserHandle
> + //
> + Status = MmValidateHandle (UserHandle);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + //
> + // Look at each protocol interface for a match
> + //
> + Prot = MmGetProtocolInterface (UserHandle, Protocol);
> + if (Prot == NULL) {
> + return EFI_UNSUPPORTED;
> + }
> +
> + //
> + // This is the protocol interface entry for this protocol
> + //
> + *Interface = Prot->Interface;
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/StandaloneMmPkg/Core/InstallConfigurationTable.c b/StandaloneMmPkg/Core/InstallConfigurationTable.c
> new file mode 100644
> index 0000000000..3a31c63f94
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/InstallConfigurationTable.c
> @@ -0,0 +1,178 @@
> +/** @file
> + System Management System Table Services MmInstallConfigurationTable service
> +
> + Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +#define CONFIG_TABLE_SIZE_INCREASED 0x10
> +
> +UINTN mMmSystemTableAllocateSize = 0;
> +
> +/**
> + The MmInstallConfigurationTable() function is used to maintain the list
> + of configuration tables that are stored in the System Management System
> + Table. The list is stored as an array of (GUID, Pointer) pairs. The list
> + must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
> +
> + @param SystemTable A pointer to the SMM System Table (SMST).
> + @param Guid A pointer to the GUID for the entry to add, update, or remove.
> + @param Table A pointer to the buffer of the table to add.
> + @param TableSize The size of the table to install.
> +
> + @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or removed.
> + @retval EFI_INVALID_PARAMETER Guid is not valid.
> + @retval EFI_NOT_FOUND An attempt was made to delete a non-existent entry.
> + @retval EFI_OUT_OF_RESOURCES There is not enough memory available to complete the operation.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInstallConfigurationTable (
> + IN CONST EFI_MM_SYSTEM_TABLE *SystemTable,
> + IN CONST EFI_GUID *Guid,
> + IN VOID *Table,
> + IN UINTN TableSize
> + )
> +{
> + UINTN Index;
> + EFI_CONFIGURATION_TABLE *ConfigurationTable;
> + EFI_CONFIGURATION_TABLE *OldTable;
> +
> + //
> + // If Guid is NULL, then this operation cannot be performed
> + //
> + if (Guid == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + ConfigurationTable = gMmCoreMmst.MmConfigurationTable;
> +
> + //
> + // Search all the table for an entry that matches Guid
> + //
> + for (Index = 0; Index < gMmCoreMmst.NumberOfTableEntries; Index++) {
> + if (CompareGuid (Guid, &(ConfigurationTable[Index].VendorGuid))) {
> + break;
> + }
> + }
> +
> + if (Index < gMmCoreMmst.NumberOfTableEntries) {
> + //
> + // A match was found, so this is either a modify or a delete operation
> + //
> + if (Table != NULL) {
> + //
> + // If Table is not NULL, then this is a modify operation.
> + // Modify the table entry and return.
> + //
> + ConfigurationTable[Index].VendorTable = Table;
> + return EFI_SUCCESS;
> + }
> +
> + //
> + // A match was found and Table is NULL, so this is a delete operation.
> + //
> + gMmCoreMmst.NumberOfTableEntries--;
> +
> + //
> + // Copy over deleted entry
> + //
> + CopyMem (
> + &(ConfigurationTable[Index]),
> + &(ConfigurationTable[Index + 1]),
> + (gMmCoreMmst.NumberOfTableEntries - Index) * sizeof (EFI_CONFIGURATION_TABLE)
> + );
> +
> + } else {
> + //
> + // No matching GUIDs were found, so this is an add operation.
> + //
> + if (Table == NULL) {
> + //
> + // If Table is NULL on an add operation, then return an error.
> + //
> + return EFI_NOT_FOUND;
> + }
> +
> + //
> + // Assume that Index == gMmCoreMmst.NumberOfTableEntries
> + //
> + if ((Index * sizeof (EFI_CONFIGURATION_TABLE)) >= mMmSystemTableAllocateSize) {
> + //
> + // Allocate a table with one additional entry.
> + //
> + mMmSystemTableAllocateSize += (CONFIG_TABLE_SIZE_INCREASED * sizeof (EFI_CONFIGURATION_TABLE));
> + ConfigurationTable = AllocatePool (mMmSystemTableAllocateSize);
> + if (ConfigurationTable == NULL) {
> + //
> + // If a new table could not be allocated, then return an error.
> + //
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + if (gMmCoreMmst.MmConfigurationTable != NULL) {
> + //
> + // Copy the old table to the new table.
> + //
> + CopyMem (
> + ConfigurationTable,
> + gMmCoreMmst.MmConfigurationTable,
> + Index * sizeof (EFI_CONFIGURATION_TABLE)
> + );
> +
> + //
> + // Record the old table pointer.
> + //
> + OldTable = gMmCoreMmst.MmConfigurationTable;
> +
> + //
> + // As the MmInstallConfigurationTable() may be re-entered by FreePool() in
> + // its calling stack, updating System table to the new table pointer must
> + // be done before calling FreePool() to free the old table.
> + // It can make sure the gMmCoreMmst.MmConfigurationTable point to the new
> + // table and avoid the errors of use-after-free to the old table by the
> + // reenter of MmInstallConfigurationTable() in FreePool()'s calling stack.
> + //
> + gMmCoreMmst.MmConfigurationTable = ConfigurationTable;
> +
> + //
> + // Free the old table after updating System Table to the new table pointer.
> + //
> + FreePool (OldTable);
> + } else {
> + //
> + // Update System Table
> + //
> + gMmCoreMmst.MmConfigurationTable = ConfigurationTable;
> + }
> + }
> +
> + //
> + // Fill in the new entry
> + //
> + CopyGuid ((VOID *)&ConfigurationTable[Index].VendorGuid, Guid);
> + ConfigurationTable[Index].VendorTable = Table;
> +
> + //
> + // This is an add operation, so increment the number of table entries
> + //
> + gMmCoreMmst.NumberOfTableEntries++;
> + }
> +
> + //
> + // CRC-32 field is ignorable for SMM System Table and should be set to zero
> + //
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/StandaloneMmPkg/Core/Locate.c b/StandaloneMmPkg/Core/Locate.c
> new file mode 100644
> index 0000000000..6a90575f99
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Locate.c
> @@ -0,0 +1,496 @@
> +/** @file
> + Locate handle functions
> +
> + Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +//
> +// ProtocolRequest - Last LocateHandle request ID
> +//
> +UINTN mEfiLocateHandleRequest = 0;
> +
> +//
> +// Internal prototypes
> +//
> +
> +typedef struct {
> + EFI_GUID *Protocol;
> + VOID *SearchKey;
> + LIST_ENTRY *Position;
> + PROTOCOL_ENTRY *ProtEntry;
> +} LOCATE_POSITION;
> +
> +typedef
> +IHANDLE *
> +(* CORE_GET_NEXT) (
> + IN OUT LOCATE_POSITION *Position,
> + OUT VOID **Interface
> + );
> +
> +/**
> + Routine to get the next Handle, when you are searching for all handles.
> +
> + @param Position Information about which Handle to seach for.
> + @param Interface Return the interface structure for the matching
> + protocol.
> +
> + @return An pointer to IHANDLE if the next Position is not the end of the list.
> + Otherwise,NULL is returned.
> +
> +**/
> +IHANDLE *
> +MmGetNextLocateAllHandles (
> + IN OUT LOCATE_POSITION *Position,
> + OUT VOID **Interface
> + )
> +{
> + IHANDLE *Handle;
> +
> + //
> + // Next handle
> + //
> + Position->Position = Position->Position->ForwardLink;
> +
> + //
> + // If not at the end of the list, get the handle
> + //
> + Handle = NULL;
> + *Interface = NULL;
> + if (Position->Position != &gHandleList) {
> + Handle = CR (Position->Position, IHANDLE, AllHandles, EFI_HANDLE_SIGNATURE);
> + }
> + return Handle;
> +}
> +
> +/**
> + Routine to get the next Handle, when you are searching for register protocol
> + notifies.
> +
> + @param Position Information about which Handle to seach for.
> + @param Interface Return the interface structure for the matching
> + protocol.
> +
> + @return An pointer to IHANDLE if the next Position is not the end of the list.
> + Otherwise,NULL is returned.
> +
> +**/
> +IHANDLE *
> +MmGetNextLocateByRegisterNotify (
> + IN OUT LOCATE_POSITION *Position,
> + OUT VOID **Interface
> + )
> +{
> + IHANDLE *Handle;
> + PROTOCOL_NOTIFY *ProtNotify;
> + PROTOCOL_INTERFACE *Prot;
> + LIST_ENTRY *Link;
> +
> + Handle = NULL;
> + *Interface = NULL;
> + ProtNotify = Position->SearchKey;
> +
> + //
> + // If this is the first request, get the next handle
> + //
> + if (ProtNotify != NULL) {
> + ASSERT(ProtNotify->Signature == PROTOCOL_NOTIFY_SIGNATURE);
> + Position->SearchKey = NULL;
> +
> + //
> + // If not at the end of the list, get the next handle
> + //
> + Link = ProtNotify->Position->ForwardLink;
> + if (Link != &ProtNotify->Protocol->Protocols) {
> + Prot = CR (Link, PROTOCOL_INTERFACE, ByProtocol, PROTOCOL_INTERFACE_SIGNATURE);
> + Handle = Prot->Handle;
> + *Interface = Prot->Interface;
> + }
> + }
> + return Handle;
> +}
> +
> +/**
> + Routine to get the next Handle, when you are searching for a given protocol.
> +
> + @param Position Information about which Handle to seach for.
> + @param Interface Return the interface structure for the matching
> + protocol.
> +
> + @return An pointer to IHANDLE if the next Position is not the end of the list.
> + Otherwise,NULL is returned.
> +
> +**/
> +IHANDLE *
> +MmGetNextLocateByProtocol (
> + IN OUT LOCATE_POSITION *Position,
> + OUT VOID **Interface
> + )
> +{
> + IHANDLE *Handle;
> + LIST_ENTRY *Link;
> + PROTOCOL_INTERFACE *Prot;
> +
> + Handle = NULL;
> + *Interface = NULL;
> + for (; ;) {
> + //
> + // Next entry
> + //
> + Link = Position->Position->ForwardLink;
> + Position->Position = Link;
> +
> + //
> + // If not at the end, return the handle
> + //
> + if (Link == &Position->ProtEntry->Protocols) {
> + Handle = NULL;
> + break;
> + }
> +
> + //
> + // Get the handle
> + //
> + Prot = CR(Link, PROTOCOL_INTERFACE, ByProtocol, PROTOCOL_INTERFACE_SIGNATURE);
> + Handle = Prot->Handle;
> + *Interface = Prot->Interface;
> +
> + //
> + // If this handle has not been returned this request, then
> + // return it now
> + //
> + if (Handle->LocateRequest != mEfiLocateHandleRequest) {
> + Handle->LocateRequest = mEfiLocateHandleRequest;
> + break;
> + }
> + }
> + return Handle;
> +}
> +
> +/**
> + Return the first Protocol Interface that matches the Protocol GUID. If
> + Registration is pasased in return a Protocol Instance that was just add
> + to the system. If Retistration is NULL return the first Protocol Interface
> + you find.
> +
> + @param Protocol The protocol to search for
> + @param Registration Optional Registration Key returned from
> + RegisterProtocolNotify()
> + @param Interface Return the Protocol interface (instance).
> +
> + @retval EFI_SUCCESS If a valid Interface is returned
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_NOT_FOUND Protocol interface not found
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLocateProtocol (
> + IN EFI_GUID *Protocol,
> + IN VOID *Registration OPTIONAL,
> + OUT VOID **Interface
> + )
> +{
> + EFI_STATUS Status;
> + LOCATE_POSITION Position;
> + PROTOCOL_NOTIFY *ProtNotify;
> + IHANDLE *Handle;
> +
> + if ((Interface == NULL) || (Protocol == NULL)) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + *Interface = NULL;
> + Status = EFI_SUCCESS;
> +
> + //
> + // Set initial position
> + //
> + Position.Protocol = Protocol;
> + Position.SearchKey = Registration;
> + Position.Position = &gHandleList;
> +
> + mEfiLocateHandleRequest += 1;
> +
> + if (Registration == NULL) {
> + //
> + // Look up the protocol entry and set the head pointer
> + //
> + Position.ProtEntry = MmFindProtocolEntry (Protocol, FALSE);
> + if (Position.ProtEntry == NULL) {
> + return EFI_NOT_FOUND;
> + }
> + Position.Position = &Position.ProtEntry->Protocols;
> +
> + Handle = MmGetNextLocateByProtocol (&Position, Interface);
> + } else {
> + Handle = MmGetNextLocateByRegisterNotify (&Position, Interface);
> + }
> +
> + if (Handle == NULL) {
> + Status = EFI_NOT_FOUND;
> + } else if (Registration != NULL) {
> + //
> + // If this is a search by register notify and a handle was
> + // returned, update the register notification position
> + //
> + ProtNotify = Registration;
> + ProtNotify->Position = ProtNotify->Position->ForwardLink;
> + }
> +
> + return Status;
> +}
> +
> +/**
> + Locates the requested handle(s) and returns them in Buffer.
> +
> + @param SearchType The type of search to perform to locate the
> + handles
> + @param Protocol The protocol to search for
> + @param SearchKey Dependant on SearchType
> + @param BufferSize On input the size of Buffer. On output the
> + size of data returned.
> + @param Buffer The buffer to return the results in
> +
> + @retval EFI_BUFFER_TOO_SMALL Buffer too small, required buffer size is
> + returned in BufferSize.
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_SUCCESS Successfully found the requested handle(s) and
> + returns them in Buffer.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLocateHandle (
> + IN EFI_LOCATE_SEARCH_TYPE SearchType,
> + IN EFI_GUID *Protocol OPTIONAL,
> + IN VOID *SearchKey OPTIONAL,
> + IN OUT UINTN *BufferSize,
> + OUT EFI_HANDLE *Buffer
> + )
> +{
> + EFI_STATUS Status;
> + LOCATE_POSITION Position;
> + PROTOCOL_NOTIFY *ProtNotify;
> + CORE_GET_NEXT GetNext;
> + UINTN ResultSize;
> + IHANDLE *Handle;
> + IHANDLE **ResultBuffer;
> + VOID *Interface;
> +
> + if (BufferSize == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if ((*BufferSize > 0) && (Buffer == NULL)) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + GetNext = NULL;
> +
> + //
> + // Set initial position
> + //
> + Position.Protocol = Protocol;
> + Position.SearchKey = SearchKey;
> + Position.Position = &gHandleList;
> +
> + ResultSize = 0;
> + ResultBuffer = (IHANDLE **) Buffer;
> + Status = EFI_SUCCESS;
> +
> + //
> + // Get the search function based on type
> + //
> + switch (SearchType) {
> + case AllHandles:
> + GetNext = MmGetNextLocateAllHandles;
> + break;
> +
> + case ByRegisterNotify:
> + GetNext = MmGetNextLocateByRegisterNotify;
> + //
> + // Must have SearchKey for locate ByRegisterNotify
> + //
> + if (SearchKey == NULL) {
> + Status = EFI_INVALID_PARAMETER;
> + }
> + break;
> +
> + case ByProtocol:
> + GetNext = MmGetNextLocateByProtocol;
> + if (Protocol == NULL) {
> + Status = EFI_INVALID_PARAMETER;
> + break;
> + }
> + //
> + // Look up the protocol entry and set the head pointer
> + //
> + Position.ProtEntry = MmFindProtocolEntry (Protocol, FALSE);
> + if (Position.ProtEntry == NULL) {
> + Status = EFI_NOT_FOUND;
> + break;
> + }
> + Position.Position = &Position.ProtEntry->Protocols;
> + break;
> +
> + default:
> + Status = EFI_INVALID_PARAMETER;
> + break;
> + }
> +
> + if (EFI_ERROR(Status)) {
> + return Status;
> + }
> +
> + //
> + // Enumerate out the matching handles
> + //
> + mEfiLocateHandleRequest += 1;
> + for (; ;) {
> + //
> + // Get the next handle. If no more handles, stop
> + //
> + Handle = GetNext (&Position, &Interface);
> + if (NULL == Handle) {
> + break;
> + }
> +
> + //
> + // Increase the resulting buffer size, and if this handle
> + // fits return it
> + //
> + ResultSize += sizeof(Handle);
> + if (ResultSize <= *BufferSize) {
> + *ResultBuffer = Handle;
> + ResultBuffer += 1;
> + }
> + }
> +
> + //
> + // If the result is a zero length buffer, then there were no
> + // matching handles
> + //
> + if (ResultSize == 0) {
> + Status = EFI_NOT_FOUND;
> + } else {
> + //
> + // Return the resulting buffer size. If it's larger than what
> + // was passed, then set the error code
> + //
> + if (ResultSize > *BufferSize) {
> + Status = EFI_BUFFER_TOO_SMALL;
> + }
> +
> + *BufferSize = ResultSize;
> +
> + if (SearchType == ByRegisterNotify && !EFI_ERROR(Status)) {
> + ASSERT (SearchKey != NULL);
> + //
> + // If this is a search by register notify and a handle was
> + // returned, update the register notification position
> + //
> + ProtNotify = SearchKey;
> + ProtNotify->Position = ProtNotify->Position->ForwardLink;
> + }
> + }
> +
> + return Status;
> +}
> +
> +/**
> + Function returns an array of handles that support the requested protocol
> + in a buffer allocated from pool. This is a version of MmLocateHandle()
> + 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 parameters are not valid.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLocateHandleBuffer (
> + IN EFI_LOCATE_SEARCH_TYPE SearchType,
> + IN EFI_GUID *Protocol OPTIONAL,
> + IN VOID *SearchKey OPTIONAL,
> + IN OUT UINTN *NumberHandles,
> + OUT EFI_HANDLE **Buffer
> + )
> +{
> + EFI_STATUS Status;
> + UINTN BufferSize;
> +
> + if (NumberHandles == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (Buffer == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + BufferSize = 0;
> + *NumberHandles = 0;
> + *Buffer = NULL;
> + Status = MmLocateHandle (
> + SearchType,
> + Protocol,
> + SearchKey,
> + &BufferSize,
> + *Buffer
> + );
> + //
> + // LocateHandleBuffer() returns incorrect status code if SearchType is
> + // invalid.
> + //
> + // Add code to correctly handle expected errors from MmLocateHandle().
> + //
> + if (EFI_ERROR(Status) && Status != EFI_BUFFER_TOO_SMALL) {
> + if (Status != EFI_INVALID_PARAMETER) {
> + Status = EFI_NOT_FOUND;
> + }
> + return Status;
> + }
> +
> + *Buffer = AllocatePool (BufferSize);
> + if (*Buffer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + Status = MmLocateHandle (
> + SearchType,
> + Protocol,
> + SearchKey,
> + &BufferSize,
> + *Buffer
> + );
> +
> + *NumberHandles = BufferSize / sizeof(EFI_HANDLE);
> + if (EFI_ERROR(Status)) {
> + *NumberHandles = 0;
> + }
> +
> + return Status;
> +}
> diff --git a/StandaloneMmPkg/Core/Mmi.c b/StandaloneMmPkg/Core/Mmi.c
> new file mode 100644
> index 0000000000..29aba7b53d
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Mmi.c
> @@ -0,0 +1,337 @@
> +/** @file
> + MMI management.
> +
> + Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +//
> +// MM_HANDLER_STATE_NOTIFIER
> +//
> +
> +//
> +// MM_HANDLER - used for each MM handler
> +//
> +
> +#define MMI_ENTRY_SIGNATURE SIGNATURE_32('m','m','i','e')
> +
> + typedef struct {
> + UINTN Signature;
> + LIST_ENTRY AllEntries; // All entries
> +
> + EFI_GUID HandlerType; // Type of interrupt
> + LIST_ENTRY MmiHandlers; // All handlers
> +} MMI_ENTRY;
> +
> +#define MMI_HANDLER_SIGNATURE SIGNATURE_32('m','m','i','h')
> +
> + typedef struct {
> + UINTN Signature;
> + LIST_ENTRY Link; // Link on MMI_ENTRY.MmiHandlers
> + EFI_MM_HANDLER_ENTRY_POINT Handler; // The mm handler's entry point
> + MMI_ENTRY *MmiEntry;
> +} MMI_HANDLER;
> +
> +LIST_ENTRY mRootMmiHandlerList = INITIALIZE_LIST_HEAD_VARIABLE (mRootMmiHandlerList);
> +LIST_ENTRY mMmiEntryList = INITIALIZE_LIST_HEAD_VARIABLE (mMmiEntryList);
> +
> +/**
> + Finds the MMI entry for the requested handler type.
> +
> + @param HandlerType The type of the interrupt
> + @param Create Create a new entry if not found
> +
> + @return MMI entry
> +
> +**/
> +MMI_ENTRY *
> +EFIAPI
> +MmCoreFindMmiEntry (
> + IN EFI_GUID *HandlerType,
> + IN BOOLEAN Create
> + )
> +{
> + LIST_ENTRY *Link;
> + MMI_ENTRY *Item;
> + MMI_ENTRY *MmiEntry;
> +
> + //
> + // Search the MMI entry list for the matching GUID
> + //
> + MmiEntry = NULL;
> + for (Link = mMmiEntryList.ForwardLink;
> + Link != &mMmiEntryList;
> + Link = Link->ForwardLink) {
> +
> + Item = CR (Link, MMI_ENTRY, AllEntries, MMI_ENTRY_SIGNATURE);
> + if (CompareGuid (&Item->HandlerType, HandlerType)) {
> + //
> + // This is the MMI entry
> + //
> + MmiEntry = Item;
> + break;
> + }
> + }
> +
> + //
> + // If the protocol entry was not found and Create is TRUE, then
> + // allocate a new entry
> + //
> + if ((MmiEntry == NULL) && Create) {
> + MmiEntry = AllocatePool (sizeof(MMI_ENTRY));
> + if (MmiEntry != NULL) {
> + //
> + // Initialize new MMI entry structure
> + //
> + MmiEntry->Signature = MMI_ENTRY_SIGNATURE;
> + CopyGuid ((VOID *)&MmiEntry->HandlerType, HandlerType);
> + InitializeListHead (&MmiEntry->MmiHandlers);
> +
> + //
> + // Add it to MMI entry list
> + //
> + InsertTailList (&mMmiEntryList, &MmiEntry->AllEntries);
> + }
> + }
> + return MmiEntry;
> +}
> +
> +/**
> + Manage MMI of a particular type.
> +
> + @param HandlerType Points to the handler type or NULL for root MMI handlers.
> + @param Context Points to an optional context buffer.
> + @param CommBuffer Points to the optional communication buffer.
> + @param CommBufferSize Points to the size of the optional communication buffer.
> +
> + @retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was processed successfully but not quiesced.
> + @retval EFI_INTERRUPT_PENDING One or more MMI sources could not be quiesced.
> + @retval EFI_NOT_FOUND Interrupt source was not handled or quiesced.
> + @retval EFI_SUCCESS Interrupt source was handled and quiesced.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiManage (
> + IN CONST EFI_GUID *HandlerType,
> + IN CONST VOID *Context OPTIONAL,
> + IN OUT VOID *CommBuffer OPTIONAL,
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + LIST_ENTRY *Link;
> + LIST_ENTRY *Head;
> + MMI_ENTRY *MmiEntry;
> + MMI_HANDLER *MmiHandler;
> + BOOLEAN SuccessReturn;
> + EFI_STATUS Status;
> +
> + Status = EFI_NOT_FOUND;
> + SuccessReturn = FALSE;
> + if (HandlerType == NULL) {
> + //
> + // Root MMI handler
> + //
> +
> + Head = &mRootMmiHandlerList;
> + } else {
> + //
> + // Non-root MMI handler
> + //
> + MmiEntry = MmCoreFindMmiEntry ((EFI_GUID *) HandlerType, FALSE);
> + if (MmiEntry == NULL) {
> + //
> + // There is no handler registered for this interrupt source
> + //
> + return Status;
> + }
> +
> + Head = &MmiEntry->MmiHandlers;
> + }
> +
> + for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
> + MmiHandler = CR (Link, MMI_HANDLER, Link, MMI_HANDLER_SIGNATURE);
> +
> + Status = MmiHandler->Handler (
> + (EFI_HANDLE) MmiHandler,
> + Context,
> + CommBuffer,
> + CommBufferSize
> + );
> +
> + switch (Status) {
> + case EFI_INTERRUPT_PENDING:
> + //
> + // If a handler returns EFI_INTERRUPT_PENDING and HandlerType is not NULL then
> + // no additional handlers will be processed and EFI_INTERRUPT_PENDING will be returned.
> + //
> + if (HandlerType != NULL) {
> + return EFI_INTERRUPT_PENDING;
> + }
> + break;
> +
> + case EFI_SUCCESS:
> + //
> + // If at least one of the handlers returns EFI_SUCCESS then the function will return
> + // EFI_SUCCESS. If a handler returns EFI_SUCCESS and HandlerType is not NULL then no
> + // additional handlers will be processed.
> + //
> + if (HandlerType != NULL) {
> + return EFI_SUCCESS;
> + }
> + SuccessReturn = TRUE;
> + break;
> +
> + case EFI_WARN_INTERRUPT_SOURCE_QUIESCED:
> + //
> + // If at least one of the handlers returns EFI_WARN_INTERRUPT_SOURCE_QUIESCED
> + // then the function will return EFI_SUCCESS.
> + //
> + SuccessReturn = TRUE;
> + break;
> +
> + case EFI_WARN_INTERRUPT_SOURCE_PENDING:
> + //
> + // If all the handlers returned EFI_WARN_INTERRUPT_SOURCE_PENDING
> + // then EFI_WARN_INTERRUPT_SOURCE_PENDING will be returned.
> + //
> + break;
> +
> + default:
> + //
> + // Unexpected status code returned.
> + //
> + ASSERT (FALSE);
> + break;
> + }
> + }
> +
> + if (SuccessReturn) {
> + Status = EFI_SUCCESS;
> + }
> +
> + return Status;
> +}
> +
> +/**
> + Registers a handler to execute within MM.
> +
> + @param Handler Handler service funtion pointer.
> + @param HandlerType Points to the handler type or NULL for root MMI handlers.
> + @param DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.
> +
> + @retval EFI_SUCCESS Handler register success.
> + @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiHandlerRegister (
> + IN EFI_MM_HANDLER_ENTRY_POINT Handler,
> + IN CONST EFI_GUID *HandlerType OPTIONAL,
> + OUT EFI_HANDLE *DispatchHandle
> + )
> +{
> + MMI_HANDLER *MmiHandler;
> + MMI_ENTRY *MmiEntry;
> + LIST_ENTRY *List;
> +
> + if (Handler == NULL || DispatchHandle == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + MmiHandler = AllocateZeroPool (sizeof (MMI_HANDLER));
> + if (MmiHandler == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + MmiHandler->Signature = MMI_HANDLER_SIGNATURE;
> + MmiHandler->Handler = Handler;
> +
> + if (HandlerType == NULL) {
> + //
> + // This is root MMI handler
> + //
> + MmiEntry = NULL;
> + List = &mRootMmiHandlerList;
> + } else {
> + //
> + // None root MMI handler
> + //
> + MmiEntry = MmCoreFindMmiEntry ((EFI_GUID *) HandlerType, TRUE);
> + if (MmiEntry == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + List = &MmiEntry->MmiHandlers;
> + }
> +
> + MmiHandler->MmiEntry = MmiEntry;
> + InsertTailList (List, &MmiHandler->Link);
> +
> + *DispatchHandle = (EFI_HANDLE) MmiHandler;
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Unregister a handler in MM.
> +
> + @param DispatchHandle The handle that was specified when the handler was registered.
> +
> + @retval EFI_SUCCESS Handler function was successfully unregistered.
> + @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiHandlerUnRegister (
> + IN EFI_HANDLE DispatchHandle
> + )
> +{
> + MMI_HANDLER *MmiHandler;
> + MMI_ENTRY *MmiEntry;
> +
> + MmiHandler = (MMI_HANDLER *) DispatchHandle;
> +
> + if (MmiHandler == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (MmiHandler->Signature != MMI_HANDLER_SIGNATURE) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + MmiEntry = MmiHandler->MmiEntry;
> +
> + RemoveEntryList (&MmiHandler->Link);
> + FreePool (MmiHandler);
> +
> + if (MmiEntry == NULL) {
> + //
> + // This is root MMI handler
> + //
> + return EFI_SUCCESS;
> + }
> +
> + if (IsListEmpty (&MmiEntry->MmiHandlers)) {
> + //
> + // No handler registered for this interrupt now, remove the MMI_ENTRY
> + //
> + RemoveEntryList (&MmiEntry->AllEntries);
> +
> + FreePool (MmiEntry);
> + }
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/StandaloneMmPkg/Core/Notify.c b/StandaloneMmPkg/Core/Notify.c
> new file mode 100644
> index 0000000000..d5fc8f50d1
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Notify.c
> @@ -0,0 +1,203 @@
> +/** @file
> + Support functions for UEFI protocol notification infrastructure.
> +
> + Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +/**
> + Signal event for every protocol in protocol entry.
> +
> + @param Prot Protocol interface
> +
> +**/
> +VOID
> +MmNotifyProtocol (
> + IN PROTOCOL_INTERFACE *Prot
> + )
> +{
> + PROTOCOL_ENTRY *ProtEntry;
> + PROTOCOL_NOTIFY *ProtNotify;
> + LIST_ENTRY *Link;
> +
> + ProtEntry = Prot->Protocol;
> + for (Link=ProtEntry->Notify.ForwardLink; Link != &ProtEntry->Notify; Link=Link->ForwardLink) {
> + ProtNotify = CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
> + ProtNotify->Function (&ProtEntry->ProtocolID, Prot->Interface, Prot->Handle);
> + }
> +}
> +
> +/**
> + Removes Protocol from the protocol list (but not the handle list).
> +
> + @param Handle The handle to remove protocol on.
> + @param Protocol GUID of the protocol to be moved
> + @param Interface The interface of the protocol
> +
> + @return Protocol Entry
> +
> +**/
> +PROTOCOL_INTERFACE *
> +MmRemoveInterfaceFromProtocol (
> + IN IHANDLE *Handle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + )
> +{
> + PROTOCOL_INTERFACE *Prot;
> + PROTOCOL_NOTIFY *ProtNotify;
> + PROTOCOL_ENTRY *ProtEntry;
> + LIST_ENTRY *Link;
> +
> + Prot = MmFindProtocolInterface (Handle, Protocol, Interface);
> + if (Prot != NULL) {
> +
> + ProtEntry = Prot->Protocol;
> +
> + //
> + // If there's a protocol notify location pointing to this entry, back it up one
> + //
> + for(Link = ProtEntry->Notify.ForwardLink; Link != &ProtEntry->Notify; Link=Link->ForwardLink) {
> + ProtNotify = CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
> +
> + if (ProtNotify->Position == &Prot->ByProtocol) {
> + ProtNotify->Position = Prot->ByProtocol.BackLink;
> + }
> + }
> +
> + //
> + // Remove the protocol interface entry
> + //
> + RemoveEntryList (&Prot->ByProtocol);
> + }
> +
> + return Prot;
> +}
> +
> +/**
> + Add a new protocol notification record for the request protocol.
> +
> + @param Protocol The requested protocol to add the notify
> + registration
> + @param Function Points to the notification function
> + @param Registration Returns the registration record
> +
> + @retval EFI_SUCCESS Successfully returned the registration record
> + that has been added or unhooked
> + @retval EFI_INVALID_PARAMETER Protocol is NULL or Registration is NULL
> + @retval EFI_OUT_OF_RESOURCES Not enough memory resource to finish the request
> + @retval EFI_NOT_FOUND If the registration is not found when Function == NULL
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmRegisterProtocolNotify (
> + IN CONST EFI_GUID *Protocol,
> + IN EFI_MM_NOTIFY_FN Function,
> + OUT VOID **Registration
> + )
> +{
> + PROTOCOL_ENTRY *ProtEntry;
> + PROTOCOL_NOTIFY *ProtNotify;
> + LIST_ENTRY *Link;
> + EFI_STATUS Status;
> +
> + if (Protocol == NULL || Registration == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (Function == NULL) {
> + //
> + // Get the protocol entry per Protocol
> + //
> + ProtEntry = MmFindProtocolEntry ((EFI_GUID *) Protocol, FALSE);
> + if (ProtEntry != NULL) {
> + ProtNotify = (PROTOCOL_NOTIFY * )*Registration;
> + for (Link = ProtEntry->Notify.ForwardLink;
> + Link != &ProtEntry->Notify;
> + Link = Link->ForwardLink) {
> + //
> + // Compare the notification record
> + //
> + if (ProtNotify == (CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE))){
> + //
> + // If Registration is an existing registration, then unhook it
> + //
> + ProtNotify->Signature = 0;
> + RemoveEntryList (&ProtNotify->Link);
> + FreePool (ProtNotify);
> + return EFI_SUCCESS;
> + }
> + }
> + }
> + //
> + // If the registration is not found
> + //
> + return EFI_NOT_FOUND;
> + }
> +
> + ProtNotify = NULL;
> +
> + //
> + // Get the protocol entry to add the notification too
> + //
> + ProtEntry = MmFindProtocolEntry ((EFI_GUID *) Protocol, TRUE);
> + if (ProtEntry != NULL) {
> + //
> + // Find whether notification already exist
> + //
> + for (Link = ProtEntry->Notify.ForwardLink;
> + Link != &ProtEntry->Notify;
> + Link = Link->ForwardLink) {
> +
> + ProtNotify = CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
> + if (CompareGuid (&ProtNotify->Protocol->ProtocolID, Protocol) &&
> + (ProtNotify->Function == Function)) {
> +
> + //
> + // Notification already exist
> + //
> + *Registration = ProtNotify;
> +
> + return EFI_SUCCESS;
> + }
> + }
> +
> + //
> + // Allocate a new notification record
> + //
> + ProtNotify = AllocatePool (sizeof(PROTOCOL_NOTIFY));
> + if (ProtNotify != NULL) {
> + ProtNotify->Signature = PROTOCOL_NOTIFY_SIGNATURE;
> + ProtNotify->Protocol = ProtEntry;
> + ProtNotify->Function = Function;
> + //
> + // Start at the ending
> + //
> + ProtNotify->Position = ProtEntry->Protocols.BackLink;
> +
> + InsertTailList (&ProtEntry->Notify, &ProtNotify->Link);
> + }
> + }
> +
> + //
> + // Done. If we have a protocol notify entry, then return it.
> + // Otherwise, we must have run out of resources trying to add one
> + //
> + Status = EFI_OUT_OF_RESOURCES;
> + if (ProtNotify != NULL) {
> + *Registration = ProtNotify;
> + Status = EFI_SUCCESS;
> + }
> + return Status;
> +}
> diff --git a/StandaloneMmPkg/Core/Page.c b/StandaloneMmPkg/Core/Page.c
> new file mode 100644
> index 0000000000..ba3e7cea74
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Page.c
> @@ -0,0 +1,384 @@
> +/** @file
> + MM Memory page management functions.
> +
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +#define NEXT_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \
> + ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) + (Size)))
> +
> +#define TRUNCATE_TO_PAGES(a) ((a) >> EFI_PAGE_SHIFT)
> +
> +LIST_ENTRY mMmMemoryMap = INITIALIZE_LIST_HEAD_VARIABLE (mMmMemoryMap);
> +
> +UINTN mMapKey;
> +
> +/**
> + Internal Function. Allocate n pages from given free page node.
> +
> + @param Pages The free page node.
> + @param NumberOfPages Number of pages to be allocated.
> + @param MaxAddress Request to allocate memory below this address.
> +
> + @return Memory address of allocated pages.
> +
> +**/
> +UINTN
> +InternalAllocPagesOnOneNode (
> + IN OUT FREE_PAGE_LIST *Pages,
> + IN UINTN NumberOfPages,
> + IN UINTN MaxAddress
> + )
> +{
> + UINTN Top;
> + UINTN Bottom;
> + FREE_PAGE_LIST *Node;
> +
> + Top = TRUNCATE_TO_PAGES (MaxAddress + 1 - (UINTN)Pages);
> + if (Top > Pages->NumberOfPages) {
> + Top = Pages->NumberOfPages;
> + }
> + Bottom = Top - NumberOfPages;
> +
> + if (Top < Pages->NumberOfPages) {
> + Node = (FREE_PAGE_LIST*)((UINTN)Pages + EFI_PAGES_TO_SIZE (Top));
> + Node->NumberOfPages = Pages->NumberOfPages - Top;
> + InsertHeadList (&Pages->Link, &Node->Link);
> + }
> +
> + if (Bottom > 0) {
> + Pages->NumberOfPages = Bottom;
> + } else {
> + RemoveEntryList (&Pages->Link);
> + }
> +
> + return (UINTN)Pages + EFI_PAGES_TO_SIZE (Bottom);
> +}
> +
> +/**
> + Internal Function. Allocate n pages from free page list below MaxAddress.
> +
> + @param FreePageList The free page node.
> + @param NumberOfPages Number of pages to be allocated.
> + @param MaxAddress Request to allocate memory below this address.
> +
> + @return Memory address of allocated pages.
> +
> +**/
> +UINTN
> +InternalAllocMaxAddress (
> + IN OUT LIST_ENTRY *FreePageList,
> + IN UINTN NumberOfPages,
> + IN UINTN MaxAddress
> + )
> +{
> + LIST_ENTRY *Node;
> + FREE_PAGE_LIST *Pages;
> +
> + for (Node = FreePageList->BackLink; Node != FreePageList; Node = Node->BackLink) {
> + Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);
> + if (Pages->NumberOfPages >= NumberOfPages &&
> + (UINTN)Pages + EFI_PAGES_TO_SIZE (NumberOfPages) - 1 <= MaxAddress) {
> + return InternalAllocPagesOnOneNode (Pages, NumberOfPages, MaxAddress);
> + }
> + }
> + return (UINTN)(-1);
> +}
> +
> +/**
> + Internal Function. Allocate n pages from free page list at given address.
> +
> + @param FreePageList The free page node.
> + @param NumberOfPages Number of pages to be allocated.
> + @param MaxAddress Request to allocate memory below this address.
> +
> + @return Memory address of allocated pages.
> +
> +**/
> +UINTN
> +InternalAllocAddress (
> + IN OUT LIST_ENTRY *FreePageList,
> + IN UINTN NumberOfPages,
> + IN UINTN Address
> + )
> +{
> + UINTN EndAddress;
> + LIST_ENTRY *Node;
> + FREE_PAGE_LIST *Pages;
> +
> + if ((Address & EFI_PAGE_MASK) != 0) {
> + return ~Address;
> + }
> +
> + EndAddress = Address + EFI_PAGES_TO_SIZE (NumberOfPages);
> + for (Node = FreePageList->BackLink; Node!= FreePageList; Node = Node->BackLink) {
> + Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);
> + if ((UINTN)Pages <= Address) {
> + if ((UINTN)Pages + EFI_PAGES_TO_SIZE (Pages->NumberOfPages) < EndAddress) {
> + break;
> + }
> + return InternalAllocPagesOnOneNode (Pages, NumberOfPages, EndAddress);
> + }
> + }
> + return ~Address;
> +}
> +
> +/**
> + 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.
> +
> + @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
> +MmInternalAllocatePages (
> + IN EFI_ALLOCATE_TYPE Type,
> + IN EFI_MEMORY_TYPE MemoryType,
> + IN UINTN NumberOfPages,
> + OUT EFI_PHYSICAL_ADDRESS *Memory
> + )
> +{
> + UINTN RequestedAddress;
> +
> + if (MemoryType != EfiRuntimeServicesCode &&
> + MemoryType != EfiRuntimeServicesData) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (NumberOfPages > TRUNCATE_TO_PAGES ((UINTN)-1) + 1) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + //
> + // We don't track memory type in MM
> + //
> + RequestedAddress = (UINTN)*Memory;
> + switch (Type) {
> + case AllocateAnyPages:
> + RequestedAddress = (UINTN)(-1);
> + case AllocateMaxAddress:
> + *Memory = InternalAllocMaxAddress (
> + &mMmMemoryMap,
> + NumberOfPages,
> + RequestedAddress
> + );
> + if (*Memory == (UINTN)-1) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> + break;
> + case AllocateAddress:
> + *Memory = InternalAllocAddress (
> + &mMmMemoryMap,
> + NumberOfPages,
> + RequestedAddress
> + );
> + if (*Memory != RequestedAddress) {
> + return EFI_NOT_FOUND;
> + }
> + break;
> + default:
> + return EFI_INVALID_PARAMETER;
> + }
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + 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.
> +
> + @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
> +MmAllocatePages (
> + IN EFI_ALLOCATE_TYPE Type,
> + IN EFI_MEMORY_TYPE MemoryType,
> + IN UINTN NumberOfPages,
> + OUT EFI_PHYSICAL_ADDRESS *Memory
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = MmInternalAllocatePages (Type, MemoryType, NumberOfPages, Memory);
> + return Status;
> +}
> +
> +/**
> + Internal Function. Merge two adjacent nodes.
> +
> + @param First The first of two nodes to merge.
> +
> + @return Pointer to node after merge (if success) or pointer to next node (if fail).
> +
> +**/
> +FREE_PAGE_LIST *
> +InternalMergeNodes (
> + IN FREE_PAGE_LIST *First
> + )
> +{
> + FREE_PAGE_LIST *Next;
> +
> + Next = BASE_CR (First->Link.ForwardLink, FREE_PAGE_LIST, Link);
> + ASSERT (
> + TRUNCATE_TO_PAGES ((UINTN)Next - (UINTN)First) >= First->NumberOfPages);
> +
> + if (TRUNCATE_TO_PAGES ((UINTN)Next - (UINTN)First) == First->NumberOfPages) {
> + First->NumberOfPages += Next->NumberOfPages;
> + RemoveEntryList (&Next->Link);
> + Next = First;
> + }
> + return Next;
> +}
> +
> +/**
> + Frees previous allocated pages.
> +
> + @param Memory Base address of memory being freed.
> + @param 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
> +MmInternalFreePages (
> + IN EFI_PHYSICAL_ADDRESS Memory,
> + IN UINTN NumberOfPages
> + )
> +{
> + LIST_ENTRY *Node;
> + FREE_PAGE_LIST *Pages;
> +
> + if ((Memory & EFI_PAGE_MASK) != 0) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + Pages = NULL;
> + Node = mMmMemoryMap.ForwardLink;
> + while (Node != &mMmMemoryMap) {
> + Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);
> + if (Memory < (UINTN)Pages) {
> + break;
> + }
> + Node = Node->ForwardLink;
> + }
> +
> + if (Node != &mMmMemoryMap &&
> + Memory + EFI_PAGES_TO_SIZE (NumberOfPages) > (UINTN)Pages) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + if (Node->BackLink != &mMmMemoryMap) {
> + Pages = BASE_CR (Node->BackLink, FREE_PAGE_LIST, Link);
> + if ((UINTN)Pages + EFI_PAGES_TO_SIZE (Pages->NumberOfPages) > Memory) {
> + return EFI_INVALID_PARAMETER;
> + }
> + }
> +
> + Pages = (FREE_PAGE_LIST*)(UINTN)Memory;
> + Pages->NumberOfPages = NumberOfPages;
> + InsertTailList (Node, &Pages->Link);
> +
> + if (Pages->Link.BackLink != &mMmMemoryMap) {
> + Pages = InternalMergeNodes (
> + BASE_CR (Pages->Link.BackLink, FREE_PAGE_LIST, Link)
> + );
> + }
> +
> + if (Node != &mMmMemoryMap) {
> + InternalMergeNodes (Pages);
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Frees previous allocated pages.
> +
> + @param Memory Base address of memory being freed.
> + @param 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
> +MmFreePages (
> + IN EFI_PHYSICAL_ADDRESS Memory,
> + IN UINTN NumberOfPages
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = MmInternalFreePages (Memory, NumberOfPages);
> + return Status;
> +}
> +
> +/**
> + Add free MMRAM region for use by memory service.
> +
> + @param MemBase Base address of memory region.
> + @param MemLength Length of the memory region.
> + @param Type Memory type.
> + @param Attributes Memory region state.
> +
> +**/
> +VOID
> +MmAddMemoryRegion (
> + IN EFI_PHYSICAL_ADDRESS MemBase,
> + IN UINT64 MemLength,
> + IN EFI_MEMORY_TYPE Type,
> + IN UINT64 Attributes
> + )
> +{
> + UINTN AlignedMemBase;
> +
> + //
> + // Do not add 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;
> + }
> +
> + //
> + // Align range on an EFI_PAGE_SIZE boundary
> + //
> + AlignedMemBase = (UINTN)(MemBase + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
> + MemLength -= AlignedMemBase - MemBase;
> + MmFreePages (AlignedMemBase, TRUNCATE_TO_PAGES ((UINTN)MemLength));
> +}
> diff --git a/StandaloneMmPkg/Core/Pool.c b/StandaloneMmPkg/Core/Pool.c
> new file mode 100644
> index 0000000000..bdf1258381
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/Pool.c
> @@ -0,0 +1,287 @@
> +/** @file
> + SMM Memory pool management functions.
> +
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +LIST_ENTRY mMmPoolLists[MAX_POOL_INDEX];
> +//
> +// To cache the MMRAM base since when Loading modules At fixed address feature is enabled,
> +// all module is assigned an offset relative the MMRAM base in build time.
> +//
> +GLOBAL_REMOVE_IF_UNREFERENCED EFI_PHYSICAL_ADDRESS gLoadModuleAtFixAddressMmramBase = 0;
> +
> +/**
> + Called to initialize the memory service.
> +
> + @param MmramRangeCount Number of MMRAM Regions
> + @param MmramRanges Pointer to MMRAM Descriptors
> +
> +**/
> +VOID
> +MmInitializeMemoryServices (
> + IN UINTN MmramRangeCount,
> + IN EFI_MMRAM_DESCRIPTOR *MmramRanges
> + )
> +{
> + UINTN Index;
> +
> + //
> + // Initialize Pool list
> + //
> + for (Index = sizeof (mMmPoolLists) / sizeof (*mMmPoolLists); Index > 0;) {
> + InitializeListHead (&mMmPoolLists[--Index]);
> + }
> +
> +
> + //
> + // Initialize free MMRAM regions
> + //
> + for (Index = 0; Index < MmramRangeCount; Index++) {
> + //
> + // BUGBUG: Add legacy MMRAM region is buggy.
> + //
> + if (MmramRanges[Index].CpuStart < BASE_1MB) {
> + continue;
> + }
> + DEBUG ((DEBUG_INFO, "MmAddMemoryRegion %d : 0x%016lx - 0x%016lx\n", Index, MmramRanges[Index].CpuStart, MmramRanges[Index].PhysicalSize));
> + MmAddMemoryRegion (
> + MmramRanges[Index].CpuStart,
> + MmramRanges[Index].PhysicalSize,
> + EfiConventionalMemory,
> + MmramRanges[Index].RegionState
> + );
> + }
> +
> +}
> +
> +/**
> + Internal Function. Allocate a pool by specified PoolIndex.
> +
> + @param PoolIndex Index which indicate the Pool size.
> + @param FreePoolHdr The returned Free pool.
> +
> + @retval EFI_OUT_OF_RESOURCES Allocation failed.
> + @retval EFI_SUCCESS Pool successfully allocated.
> +
> +**/
> +EFI_STATUS
> +InternalAllocPoolByIndex (
> + IN UINTN PoolIndex,
> + OUT FREE_POOL_HEADER **FreePoolHdr
> + )
> +{
> + EFI_STATUS Status;
> + FREE_POOL_HEADER *Hdr;
> + EFI_PHYSICAL_ADDRESS Address;
> +
> + ASSERT (PoolIndex <= MAX_POOL_INDEX);
> + Status = EFI_SUCCESS;
> + Hdr = NULL;
> + if (PoolIndex == MAX_POOL_INDEX) {
> + Status = MmInternalAllocatePages (AllocateAnyPages, EfiRuntimeServicesData, EFI_SIZE_TO_PAGES (MAX_POOL_SIZE << 1), &Address);
> + if (EFI_ERROR (Status)) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> + Hdr = (FREE_POOL_HEADER *) (UINTN) Address;
> + } else if (!IsListEmpty (&mMmPoolLists[PoolIndex])) {
> + Hdr = BASE_CR (GetFirstNode (&mMmPoolLists[PoolIndex]), FREE_POOL_HEADER, Link);
> + RemoveEntryList (&Hdr->Link);
> + } else {
> + Status = InternalAllocPoolByIndex (PoolIndex + 1, &Hdr);
> + if (!EFI_ERROR (Status)) {
> + Hdr->Header.Size >>= 1;
> + Hdr->Header.Available = TRUE;
> + InsertHeadList (&mMmPoolLists[PoolIndex], &Hdr->Link);
> + Hdr = (FREE_POOL_HEADER*)((UINT8*)Hdr + Hdr->Header.Size);
> + }
> + }
> +
> + if (!EFI_ERROR (Status)) {
> + Hdr->Header.Size = MIN_POOL_SIZE << PoolIndex;
> + Hdr->Header.Available = FALSE;
> + }
> +
> + *FreePoolHdr = Hdr;
> + return Status;
> +}
> +
> +/**
> + Internal Function. Free a pool by specified PoolIndex.
> +
> + @param FreePoolHdr The pool to free.
> +
> + @retval EFI_SUCCESS Pool successfully freed.
> +
> +**/
> +EFI_STATUS
> +InternalFreePoolByIndex (
> + IN FREE_POOL_HEADER *FreePoolHdr
> + )
> +{
> + UINTN PoolIndex;
> +
> + ASSERT ((FreePoolHdr->Header.Size & (FreePoolHdr->Header.Size - 1)) == 0);
> + ASSERT (((UINTN)FreePoolHdr & (FreePoolHdr->Header.Size - 1)) == 0);
> + ASSERT (FreePoolHdr->Header.Size >= MIN_POOL_SIZE);
> +
> + PoolIndex = (UINTN) (HighBitSet32 ((UINT32)FreePoolHdr->Header.Size) - MIN_POOL_SHIFT);
> + FreePoolHdr->Header.Available = TRUE;
> + ASSERT (PoolIndex < MAX_POOL_INDEX);
> + InsertHeadList (&mMmPoolLists[PoolIndex], &FreePoolHdr->Link);
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Allocate pool of a particular type.
> +
> + @param PoolType Type of pool to allocate.
> + @param Size The amount of pool to allocate.
> + @param Buffer The address to return a pointer to the allocated
> + pool.
> +
> + @retval EFI_INVALID_PARAMETER PoolType not valid.
> + @retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed.
> + @retval EFI_SUCCESS Pool successfully allocated.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInternalAllocatePool (
> + IN EFI_MEMORY_TYPE PoolType,
> + IN UINTN Size,
> + OUT VOID **Buffer
> + )
> +{
> + POOL_HEADER *PoolHdr;
> + FREE_POOL_HEADER *FreePoolHdr;
> + EFI_STATUS Status;
> + EFI_PHYSICAL_ADDRESS Address;
> + UINTN PoolIndex;
> +
> + if (PoolType != EfiRuntimeServicesCode &&
> + PoolType != EfiRuntimeServicesData) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + Size += sizeof (*PoolHdr);
> + if (Size > MAX_POOL_SIZE) {
> + Size = EFI_SIZE_TO_PAGES (Size);
> + Status = MmInternalAllocatePages (AllocateAnyPages, PoolType, Size, &Address);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + PoolHdr = (POOL_HEADER*)(UINTN)Address;
> + PoolHdr->Size = EFI_PAGES_TO_SIZE (Size);
> + PoolHdr->Available = FALSE;
> + *Buffer = PoolHdr + 1;
> + return Status;
> + }
> +
> + Size = (Size + MIN_POOL_SIZE - 1) >> MIN_POOL_SHIFT;
> + PoolIndex = (UINTN) HighBitSet32 ((UINT32)Size);
> + if ((Size & (Size - 1)) != 0) {
> + PoolIndex++;
> + }
> +
> + Status = InternalAllocPoolByIndex (PoolIndex, &FreePoolHdr);
> + if (!EFI_ERROR(Status)) {
> + *Buffer = &FreePoolHdr->Header + 1;
> + }
> + return Status;
> +}
> +
> +/**
> + Allocate pool of a particular type.
> +
> + @param PoolType Type of pool to allocate.
> + @param Size The amount of pool to allocate.
> + @param Buffer The address to return a pointer to the allocated
> + pool.
> +
> + @retval EFI_INVALID_PARAMETER PoolType not valid.
> + @retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed.
> + @retval EFI_SUCCESS Pool successfully allocated.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmAllocatePool (
> + IN EFI_MEMORY_TYPE PoolType,
> + IN UINTN Size,
> + OUT VOID **Buffer
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = MmInternalAllocatePool (PoolType, Size, Buffer);
> + return Status;
> +}
> +
> +/**
> + Frees pool.
> +
> + @param Buffer The allocated pool entry to free.
> +
> + @retval EFI_INVALID_PARAMETER Buffer is not a valid value.
> + @retval EFI_SUCCESS Pool successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInternalFreePool (
> + IN VOID *Buffer
> + )
> +{
> + FREE_POOL_HEADER *FreePoolHdr;
> +
> + if (Buffer == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + FreePoolHdr = (FREE_POOL_HEADER*)((POOL_HEADER*)Buffer - 1);
> + ASSERT (!FreePoolHdr->Header.Available);
> +
> + if (FreePoolHdr->Header.Size > MAX_POOL_SIZE) {
> + ASSERT (((UINTN)FreePoolHdr & EFI_PAGE_MASK) == 0);
> + ASSERT ((FreePoolHdr->Header.Size & EFI_PAGE_MASK) == 0);
> + return MmInternalFreePages (
> + (EFI_PHYSICAL_ADDRESS)(UINTN)FreePoolHdr,
> + EFI_SIZE_TO_PAGES (FreePoolHdr->Header.Size)
> + );
> + }
> + return InternalFreePoolByIndex (FreePoolHdr);
> +}
> +
> +/**
> + Frees pool.
> +
> + @param Buffer The allocated pool entry to free.
> +
> + @retval EFI_INVALID_PARAMETER Buffer is not a valid value.
> + @retval EFI_SUCCESS Pool successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmFreePool (
> + IN VOID *Buffer
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = MmInternalFreePool (Buffer);
> + return Status;
> +}
> diff --git a/StandaloneMmPkg/Core/StandaloneMmCore.c b/StandaloneMmPkg/Core/StandaloneMmCore.c
> new file mode 100644
> index 0000000000..0bb99b9710
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/StandaloneMmCore.c
> @@ -0,0 +1,708 @@
> +/** @file
> + MM Core Main Entry Point
> +
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + 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 "StandaloneMmCore.h"
> +
> +EFI_STATUS
> +MmCoreFfsFindMmDriver (
> + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader
> + );
> +
> +EFI_STATUS
> +MmDispatcher (
> + VOID
> + );
> +
> +//
> +// Globals used to initialize the protocol
> +//
> +EFI_HANDLE mMmCpuHandle = NULL;
> +
> +//
> +// Physical pointer to private structure shared between MM IPL and the MM Core
> +//
> +MM_CORE_PRIVATE_DATA *gMmCorePrivate;
> +
> +//
> +// MM Core global variable for MM System Table. Only accessed as a physical structure in MMRAM.
> +//
> +EFI_MM_SYSTEM_TABLE gMmCoreMmst = {
> +
> + // The table header for the MMST.
> + {
> + MM_MMST_SIGNATURE,
> + EFI_MM_SYSTEM_TABLE_REVISION,
> + sizeof (gMmCoreMmst.Hdr)
> + },
> + // MmFirmwareVendor
> + NULL,
> + // MmFirmwareRevision
> + 0,
> + // MmInstallConfigurationTable
> + MmInstallConfigurationTable,
> + // I/O Service
> + {
> + {
> + (EFI_MM_CPU_IO) MmEfiNotAvailableYetArg5, // MmMemRead
> + (EFI_MM_CPU_IO) MmEfiNotAvailableYetArg5 // MmMemWrite
> + },
> + {
> + (EFI_MM_CPU_IO) MmEfiNotAvailableYetArg5, // MmIoRead
> + (EFI_MM_CPU_IO) MmEfiNotAvailableYetArg5 // MmIoWrite
> + }
> + },
> + // Runtime memory services
> + MmAllocatePool,
> + MmFreePool,
> + MmAllocatePages,
> + MmFreePages,
> + // MP service
> + NULL, // MmStartupThisAp
> + 0, // CurrentlyExecutingCpu
> + 0, // NumberOfCpus
> + NULL, // CpuSaveStateSize
> + NULL, // CpuSaveState
> + 0, // NumberOfTableEntries
> + NULL, // MmConfigurationTable
> + MmInstallProtocolInterface,
> + MmUninstallProtocolInterface,
> + MmHandleProtocol,
> + MmRegisterProtocolNotify,
> + MmLocateHandle,
> + MmLocateProtocol,
> + MmiManage,
> + MmiHandlerRegister,
> + MmiHandlerUnRegister
> +};
> +
> +//
> +// Flag to determine if the platform has performed a legacy boot.
> +// If this flag is TRUE, then the runtime code and runtime data associated with the
> +// MM IPL are converted to free memory, so the MM Core must guarantee that is
> +// does not touch of the code/data associated with the MM IPL if this flag is TRUE.
> +//
> +BOOLEAN mInLegacyBoot = FALSE;
> +
> +//
> +// Table of MMI Handlers that are registered by the MM Core when it is initialized
> +//
> +MM_CORE_MMI_HANDLERS mMmCoreMmiHandlers[] = {
> + { MmFvDispatchHandler, &gMmFvDispatchGuid, NULL, TRUE },
> + { MmDriverDispatchHandler, &gEfiEventDxeDispatchGuid, NULL, TRUE },
> + { MmReadyToLockHandler, &gEfiDxeMmReadyToLockProtocolGuid, NULL, TRUE },
> + { MmEndOfDxeHandler, &gEfiEndOfDxeEventGroupGuid, NULL, FALSE },
> + { MmLegacyBootHandler, &gEfiEventLegacyBootGuid, NULL, FALSE },
> + { MmExitBootServiceHandler,&gEfiEventExitBootServicesGuid, NULL, FALSE },
> + { MmReadyToBootHandler, &gEfiEventReadyToBootGuid, NULL, FALSE },
> + { NULL, NULL, NULL, FALSE },
> +};
> +
> +EFI_SYSTEM_TABLE *mEfiSystemTable;
> +UINTN mMmramRangeCount;
> +EFI_MMRAM_DESCRIPTOR *mMmramRanges;
> +
> +/**
> + Place holder function until all the MM System Table Service are available.
> +
> + Note: This function is only used by MMRAM invocation. It is never used by DXE invocation.
> +
> + @param Arg1 Undefined
> + @param Arg2 Undefined
> + @param Arg3 Undefined
> + @param Arg4 Undefined
> + @param Arg5 Undefined
> +
> + @return EFI_NOT_AVAILABLE_YET
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmEfiNotAvailableYetArg5 (
> + UINTN Arg1,
> + UINTN Arg2,
> + UINTN Arg3,
> + UINTN Arg4,
> + UINTN Arg5
> + )
> +{
> + //
> + // This function should never be executed. If it does, then the architectural protocols
> + // have not been designed correctly.
> + //
> + return EFI_NOT_AVAILABLE_YET;
> +}
> +
> +/**
> + Software MMI handler that is called when a Legacy Boot event is signaled. The MM
> + Core uses this signal to know that a Legacy Boot has been performed and that
> + gMmCorePrivate that is shared between the UEFI and MM execution environments can
> + not be accessed from MM anymore since that structure is considered free memory by
> + a legacy OS.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLegacyBootHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_HANDLE MmHandle;
> + EFI_STATUS Status = EFI_SUCCESS;
> +
> + if (!mInLegacyBoot) {
> + MmHandle = NULL;
> + Status = MmInstallProtocolInterface (
> + &MmHandle,
> + &gEfiEventLegacyBootGuid,
> + EFI_NATIVE_INTERFACE,
> + NULL
> + );
> + }
> + mInLegacyBoot = TRUE;
> + return Status;
> +}
> +
> +/**
> + Software MMI handler that is called when a ExitBoot Service event is signaled.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmExitBootServiceHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_HANDLE MmHandle;
> + EFI_STATUS Status = EFI_SUCCESS;
> + STATIC BOOLEAN mInExitBootServices = FALSE;
> +
> + if (!mInExitBootServices) {
> + MmHandle = NULL;
> + Status = MmInstallProtocolInterface (
> + &MmHandle,
> + &gEfiEventExitBootServicesGuid,
> + EFI_NATIVE_INTERFACE,
> + NULL
> + );
> + }
> + mInExitBootServices = TRUE;
> + return Status;
> +}
> +
> +/**
> + Software MMI handler that is called when a ExitBoot Service event is signaled.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmReadyToBootHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_HANDLE MmHandle;
> + EFI_STATUS Status = EFI_SUCCESS;
> + STATIC BOOLEAN mInReadyToBoot = FALSE;
> +
> + if (!mInReadyToBoot) {
> + MmHandle = NULL;
> + Status = MmInstallProtocolInterface (
> + &MmHandle,
> + &gEfiEventReadyToBootGuid,
> + EFI_NATIVE_INTERFACE,
> + NULL
> + );
> + }
> + mInReadyToBoot = TRUE;
> + return Status;
> +}
> +
> +/**
> + Software MMI handler that is called when the DxeMmReadyToLock protocol is added
> + or if gEfiEventReadyToBootGuid is signaled. This function unregisters the
> + Software SMIs that are nor required after MMRAM is locked and installs the
> + MM Ready To Lock Protocol so MM Drivers are informed that MMRAM is about
> + to be locked.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmReadyToLockHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Index;
> + EFI_HANDLE MmHandle;
> +
> + DEBUG ((DEBUG_INFO, "MmReadyToLockHandler\n"));
> +
> + //
> + // Unregister MMI Handlers that are no longer required after the MM driver dispatch is stopped
> + //
> + for (Index = 0; mMmCoreMmiHandlers[Index].HandlerType != NULL; Index++) {
> + if (mMmCoreMmiHandlers[Index].UnRegister) {
> + MmiHandlerUnRegister (mMmCoreMmiHandlers[Index].DispatchHandle);
> + }
> + }
> +
> + //
> + // Install MM Ready to lock protocol
> + //
> + MmHandle = NULL;
> + Status = MmInstallProtocolInterface (
> + &MmHandle,
> + &gEfiMmReadyToLockProtocolGuid,
> + EFI_NATIVE_INTERFACE,
> + NULL
> + );
> +
> + //
> + // Make sure MM CPU I/O 2 Protocol has been installed into the handle database
> + //
> + //Status = MmLocateProtocol (&EFI_MM_CPU_IO_PROTOCOL_GUID, NULL, &Interface);
> +
> + //
> + // Print a message on a debug build if the MM CPU I/O 2 Protocol is not installed
> + //
> + //if (EFI_ERROR (Status)) {
> + //DEBUG ((DEBUG_ERROR, "\nSMM: SmmCpuIo Arch Protocol not present!!\n"));
> + //}
> +
> +
> + //
> + // Assert if the CPU I/O 2 Protocol is not installed
> + //
> + //ASSERT_EFI_ERROR (Status);
> +
> + //
> + // Display any drivers that were not dispatched because dependency expression
> + // evaluated to false if this is a debug build
> + //
> + //MmDisplayDiscoveredNotDispatched ();
> +
> + return Status;
> +}
> +
> +/**
> + Software MMI handler that is called when the EndOfDxe event is signaled.
> + This function installs the MM EndOfDxe Protocol so MM Drivers are informed that
> + platform code will invoke 3rd part code.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmEndOfDxeHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + )
> +{
> + EFI_STATUS Status;
> + EFI_HANDLE MmHandle;
> +
> + DEBUG ((DEBUG_INFO, "MmEndOfDxeHandler\n"));
> + //
> + // Install MM EndOfDxe protocol
> + //
> + MmHandle = NULL;
> + Status = MmInstallProtocolInterface (
> + &MmHandle,
> + &gEfiMmEndOfDxeProtocolGuid,
> + EFI_NATIVE_INTERFACE,
> + NULL
> + );
> + return Status;
> +}
> +
> +
> +
> +/**
> + The main entry point to MM Foundation.
> +
> + Note: This function is only used by MMRAM invocation. It is never used by DXE invocation.
> +
> + @param MmEntryContext Processor information and functionality
> + needed by MM Foundation.
> +
> +**/
> +VOID
> +EFIAPI
> +MmEntryPoint (
> + IN CONST EFI_MM_ENTRY_CONTEXT *MmEntryContext
> +)
> +{
> + EFI_STATUS Status;
> + EFI_MM_COMMUNICATE_HEADER *CommunicateHeader;
> + BOOLEAN InLegacyBoot;
> +
> + DEBUG ((DEBUG_INFO, "MmEntryPoint ...\n"));
> +
> + //
> + // Update MMST using the context
> + //
> + CopyMem (&gMmCoreMmst.MmStartupThisAp, MmEntryContext, sizeof (EFI_MM_ENTRY_CONTEXT));
> +
> + //
> + // Call platform hook before Mm Dispatch
> + //
> + //PlatformHookBeforeMmDispatch ();
> +
> + //
> + // If a legacy boot has occured, then make sure gMmCorePrivate is not accessed
> + //
> + InLegacyBoot = mInLegacyBoot;
> + if (!InLegacyBoot) {
> + //
> + // TBD: Mark the InMm flag as TRUE
> + //
> + gMmCorePrivate->InMm = TRUE;
> +
> + //
> + // Check to see if this is a Synchronous MMI sent through the MM Communication
> + // Protocol or an Asynchronous MMI
> + //
> + if (gMmCorePrivate->CommunicationBuffer != 0) {
> + //
> + // Synchronous MMI for MM Core or request from Communicate protocol
> + //
> + if (!MmIsBufferOutsideMmValid ((UINTN)gMmCorePrivate->CommunicationBuffer, gMmCorePrivate->BufferSize)) {
> + //
> + // If CommunicationBuffer is not in valid address scope, return EFI_INVALID_PARAMETER
> + //
> + gMmCorePrivate->CommunicationBuffer = 0;
> + gMmCorePrivate->ReturnStatus = EFI_INVALID_PARAMETER;
> + } else {
> + CommunicateHeader = (EFI_MM_COMMUNICATE_HEADER *)(UINTN)gMmCorePrivate->CommunicationBuffer;
> + gMmCorePrivate->BufferSize -= OFFSET_OF (EFI_MM_COMMUNICATE_HEADER, Data);
> + //DEBUG ((DEBUG_INFO, "CommunicateHeader->HeaderGuid - %g\n", &CommunicateHeader->HeaderGuid));
> + Status = MmiManage (
> + &CommunicateHeader->HeaderGuid,
> + NULL,
> + CommunicateHeader->Data,
> + (UINTN *)&gMmCorePrivate->BufferSize
> + );
> + //
> + // Update CommunicationBuffer, BufferSize and ReturnStatus
> + // Communicate service finished, reset the pointer to CommBuffer to NULL
> + //
> + gMmCorePrivate->BufferSize += OFFSET_OF (EFI_MM_COMMUNICATE_HEADER, Data);
> + gMmCorePrivate->CommunicationBuffer = 0;
> + gMmCorePrivate->ReturnStatus = (Status == EFI_SUCCESS) ? EFI_SUCCESS : EFI_NOT_FOUND;
> + }
> + }
> + }
> +
> + //
> + // Process Asynchronous MMI sources
> + //
> + MmiManage (NULL, NULL, NULL, NULL);
> +
> + //
> + // TBD: Do not use private data structure ?
> + //
> +
> + //
> + // If a legacy boot has occured, then make sure gMmCorePrivate is not accessed
> + //
> + if (!InLegacyBoot) {
> + //
> + // Clear the InMm flag as we are going to leave MM
> + //
> + gMmCorePrivate->InMm = FALSE;
> + }
> +
> + DEBUG ((DEBUG_INFO, "MmEntryPoint Done\n"));
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +MmConfigurationMmNotify (
> + IN CONST EFI_GUID *Protocol,
> + IN VOID *Interface,
> + IN EFI_HANDLE Handle
> + )
> +{
> + EFI_STATUS Status;
> + EFI_MM_CONFIGURATION_PROTOCOL *MmConfiguration;
> +
> + DEBUG ((DEBUG_INFO, "MmConfigurationMmNotify(%g) - %x\n", Protocol, Interface));
> +
> + MmConfiguration = Interface;
> +
> + //
> + // Register the MM Entry Point provided by the MM Core with the MM COnfiguration protocol
> + //
> + Status = MmConfiguration->RegisterMmEntry (MmConfiguration, (EFI_MM_ENTRY_POINT)(UINTN)gMmCorePrivate->MmEntryPoint);
> + ASSERT_EFI_ERROR (Status);
> +
> + //
> + // Set flag to indicate that the MM Entry Point has been registered which
> + // means that MMIs are now fully operational.
> + //
> + gMmCorePrivate->MmEntryPointRegistered = TRUE;
> +
> + //
> + // Print debug message showing MM Core entry point address.
> + //
> + DEBUG ((DEBUG_INFO, "MM Core registered MM Entry Point address %p\n", (VOID *)(UINTN)gMmCorePrivate->MmEntryPoint));
> + return EFI_SUCCESS;
> +}
> +
> +UINTN
> +GetHobListSize (
> + IN VOID *HobStart
> + )
> +{
> + EFI_PEI_HOB_POINTERS Hob;
> +
> + ASSERT (HobStart != NULL);
> +
> + Hob.Raw = (UINT8 *) HobStart;
> + while (!END_OF_HOB_LIST (Hob)) {
> + Hob.Raw = GET_NEXT_HOB (Hob);
> + }
> + //
> + // Need plus END_OF_HOB_LIST
> + //
> + return (UINTN)Hob.Raw - (UINTN)HobStart + sizeof(EFI_HOB_GENERIC_HEADER);
> +}
> +
> +/**
> + The Entry Point for MM Core
> +
> + Install DXE Protocols and reload MM Core into MMRAM and register MM Core
> + EntryPoint on the MMI vector.
> +
> + Note: This function is called for both DXE invocation and MMRAM invocation.
> +
> + @param ImageHandle The firmware allocated handle for the EFI image.
> + @param SystemTable A pointer to the EFI System Table.
> +
> + @retval EFI_SUCCESS The entry point is executed successfully.
> + @retval Other Some error occurred when executing this entry point.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +StandaloneMmMain (
> + IN VOID *HobStart
> + )
> +{
> + EFI_STATUS Status;
> + UINTN Index;
> + VOID *MmHobStart;
> + UINTN HobSize;
> + VOID *Registration;
> + EFI_HOB_GUID_TYPE *GuidHob;
> + MM_CORE_DATA_HOB_DATA *DataInHob;
> + EFI_HOB_GUID_TYPE *MmramRangesHob;
> + EFI_MMRAM_HOB_DESCRIPTOR_BLOCK *MmramRangesHobData;
> + EFI_MMRAM_DESCRIPTOR *MmramRanges;
> + UINT32 MmramRangeCount;
> + EFI_HOB_FIRMWARE_VOLUME *BfvHob;
> +
> + ProcessLibraryConstructorList (HobStart, &gMmCoreMmst);
> +
> + DEBUG ((DEBUG_INFO, "MmMain - 0x%x\n", HobStart));
> +
> + //
> + // Determine if the caller has passed a reference to a MM_CORE_PRIVATE_DATA
> + // structure in the Hoblist. This choice will govern how boot information is
> + // extracted later.
> + //
> + GuidHob = GetNextGuidHob (&gMmCoreDataHobGuid, HobStart);
> + if (GuidHob == NULL) {
> + //
> + // Allocate and zero memory for a MM_CORE_PRIVATE_DATA table and then
> + // initialise it
> + //
> + gMmCorePrivate = (MM_CORE_PRIVATE_DATA *) AllocateRuntimePages(EFI_SIZE_TO_PAGES(sizeof(MM_CORE_PRIVATE_DATA)));
> + SetMem ((VOID *)(UINTN)gMmCorePrivate, sizeof(MM_CORE_PRIVATE_DATA), 0);
> + gMmCorePrivate->Signature = MM_CORE_PRIVATE_DATA_SIGNATURE;
> + gMmCorePrivate->MmEntryPointRegistered = FALSE;
> + gMmCorePrivate->InMm = FALSE;
> + gMmCorePrivate->ReturnStatus = EFI_SUCCESS;
> +
> + //
> + // Extract the MMRAM ranges from the MMRAM descriptor HOB
> + //
> + MmramRangesHob = GetNextGuidHob (&gEfiMmPeiMmramMemoryReserveGuid, HobStart);
> + if (MmramRangesHob == NULL)
> + return EFI_UNSUPPORTED;
> +
> + MmramRangesHobData = GET_GUID_HOB_DATA (MmramRangesHob);
> + ASSERT (MmramRangesHobData != NULL);
> + MmramRanges = MmramRangesHobData->Descriptor;
> + MmramRangeCount = MmramRangesHobData->NumberOfMmReservedRegions;
> + ASSERT (MmramRanges);
> + ASSERT (MmramRangeCount);
> +
> + //
> + // Copy the MMRAM ranges into MM_CORE_PRIVATE_DATA table just in case any
> + // code relies on them being present there
> + //
> + gMmCorePrivate->MmramRangeCount = MmramRangeCount;
> + gMmCorePrivate->MmramRanges = (EFI_PHYSICAL_ADDRESS)(UINTN)AllocatePool (MmramRangeCount * sizeof(EFI_MMRAM_DESCRIPTOR));
> + ASSERT (gMmCorePrivate->MmramRanges != 0);
> + CopyMem ((VOID *)(UINTN)gMmCorePrivate->MmramRanges,
> + MmramRanges,
> + MmramRangeCount * sizeof(EFI_MMRAM_DESCRIPTOR));
> + } else {
> + DataInHob = GET_GUID_HOB_DATA (GuidHob);
> + gMmCorePrivate = (MM_CORE_PRIVATE_DATA *)(UINTN)DataInHob->Address;
> + MmramRanges = (EFI_MMRAM_DESCRIPTOR *)(UINTN)gMmCorePrivate->MmramRanges;
> + MmramRangeCount = gMmCorePrivate->MmramRangeCount;
> + }
> +
> + //
> + // Print the MMRAM ranges passed by the caller
> + //
> + DEBUG ((DEBUG_INFO, "MmramRangeCount - 0x%x\n", MmramRangeCount));
> + for (Index = 0; Index < MmramRangeCount; Index++) {
> + DEBUG ((DEBUG_INFO, "MmramRanges[%d]: 0x%016lx - 0x%lx\n", Index,
> + MmramRanges[Index].CpuStart,
> + MmramRanges[Index].PhysicalSize));
> + }
> +
> + //
> + // Copy the MMRAM ranges into private MMRAM
> + //
> + mMmramRangeCount = MmramRangeCount;
> + DEBUG ((DEBUG_INFO, "mMmramRangeCount - 0x%x\n", mMmramRangeCount));
> + mMmramRanges = AllocatePool (mMmramRangeCount * sizeof (EFI_MMRAM_DESCRIPTOR));
> + DEBUG ((DEBUG_INFO, "mMmramRanges - 0x%x\n", mMmramRanges));
> + ASSERT (mMmramRanges != NULL);
> + CopyMem (mMmramRanges, (VOID *)(UINTN)MmramRanges, mMmramRangeCount * sizeof (EFI_MMRAM_DESCRIPTOR));
> +
> + //
> + // Get Boot Firmware Volume address from the BFV Hob
> + //
> + BfvHob = GetFirstHob (EFI_HOB_TYPE_FV);
> + if (BfvHob != NULL) {
> + DEBUG ((DEBUG_INFO, "BFV address - 0x%x\n", BfvHob->BaseAddress));
> + DEBUG ((DEBUG_INFO, "BFV size - 0x%x\n", BfvHob->Length));
> + gMmCorePrivate->StandaloneBfvAddress = BfvHob->BaseAddress;
> + }
> +
> + gMmCorePrivate->Mmst = (EFI_PHYSICAL_ADDRESS)(UINTN)&gMmCoreMmst;
> + gMmCorePrivate->MmEntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)MmEntryPoint;
> +
> + //
> + // No need to initialize memory service.
> + // It is done in constructor of StandaloneMmCoreMemoryAllocationLib(),
> + // so that the library linked with StandaloneMmCore can use AllocatePool() in constuctor.
> + //
> +
> + DEBUG ((DEBUG_INFO, "MmInstallConfigurationTable For HobList\n"));
> + //
> + // Install HobList
> + //
> + HobSize = GetHobListSize (HobStart);
> + DEBUG ((DEBUG_INFO, "HobSize - 0x%x\n", HobSize));
> + MmHobStart = AllocatePool (HobSize);
> + DEBUG ((DEBUG_INFO, "MmHobStart - 0x%x\n", MmHobStart));
> + ASSERT (MmHobStart != NULL);
> + CopyMem (MmHobStart, HobStart, HobSize);
> + Status = MmInstallConfigurationTable (&gMmCoreMmst, &gEfiHobListGuid, MmHobStart, HobSize);
> + ASSERT_EFI_ERROR (Status);
> +
> + //
> + // Register notification for EFI_MM_CONFIGURATION_PROTOCOL registration and
> + // use it to register the MM Foundation entrypoint
> + //
> + DEBUG ((DEBUG_INFO, "MmRegisterProtocolNotify - MmConfigurationMmProtocol\n"));
> + Status = MmRegisterProtocolNotify (
> + &gEfiMmConfigurationProtocolGuid,
> + MmConfigurationMmNotify,
> + &Registration
> + );
> + ASSERT_EFI_ERROR (Status);
> +
> + //
> + // Dispatch standalone BFV
> + //
> + DEBUG ((DEBUG_INFO, "Mm Dispatch StandaloneBfvAddress - 0x%08x\n", gMmCorePrivate->StandaloneBfvAddress));
> + if (gMmCorePrivate->StandaloneBfvAddress != 0) {
> + MmCoreFfsFindMmDriver ((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)gMmCorePrivate->StandaloneBfvAddress);
> + MmDispatcher ();
> + }
> +
> + //
> + // Register all handlers in the core table
> + //
> + for (Index = 0; mMmCoreMmiHandlers[Index].HandlerType != NULL; Index++) {
> + Status = MmiHandlerRegister(mMmCoreMmiHandlers[Index].Handler,
> + mMmCoreMmiHandlers[Index].HandlerType,
> + &mMmCoreMmiHandlers[Index].DispatchHandle);
> + DEBUG ((DEBUG_INFO, "MmiHandlerRegister - GUID %g - Status %d\n", mMmCoreMmiHandlers[Index].HandlerType, Status));
> + }
> +
> + DEBUG ((DEBUG_INFO, "MmMain Done!\n"));
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/StandaloneMmPkg/Core/StandaloneMmCore.h b/StandaloneMmPkg/Core/StandaloneMmCore.h
> new file mode 100644
> index 0000000000..53921b7844
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/StandaloneMmCore.h
> @@ -0,0 +1,903 @@
> +/** @file
> + The internal header file includes the common header files, defines
> + internal structure and functions used by MmCore module.
> +
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#ifndef _MM_CORE_H_
> +#define _MM_CORE_H_
> +
> +#include <PiMm.h>
> +#include <StandaloneMm.h>
> +
> +#include <Protocol/DxeMmReadyToLock.h>
> +#include <Protocol/MmReadyToLock.h>
> +#include <Protocol/MmEndOfDxe.h>
> +#include <Protocol/MmCommunication.h>
> +#include <Protocol/LoadedImage.h>
> +#include <Protocol/MmConfiguration.h>
> +
> +#include <Guid/Apriori.h>
> +#include <Guid/EventGroup.h>
> +#include <Guid/EventLegacyBios.h>
> +#include <Guid/ZeroGuid.h>
> +#include <Guid/MemoryProfile.h>
> +#include <Guid/HobList.h>
> +#include <Guid/MmFvDispatch.h>
> +#include <Guid/MmramMemoryReserve.h>
> +
> +#include <Library/MmCoreStandaloneEntryPoint.h>
> +#include <Library/BaseLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/PeCoffLib.h>
> +#include <Library/CacheMaintenanceLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/ReportStatusCodeLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/PcdLib.h>
> +//#include <Library/MmCorePlatformHookLib.h>
> +#include <Library/MemLib.h>
> +#include <Library/HobLib.h>
> +
> +#include "StandaloneMmCorePrivateData.h"
> +
> +//
> +// Used to build a table of MMI Handlers that the MM Core registers
> +//
> +typedef struct {
> + EFI_MM_HANDLER_ENTRY_POINT Handler;
> + EFI_GUID *HandlerType;
> + EFI_HANDLE DispatchHandle;
> + BOOLEAN UnRegister;
> +} MM_CORE_MMI_HANDLERS;
> +
> +//
> +// Structure for recording the state of an MM Driver
> +//
> +#define EFI_MM_DRIVER_ENTRY_SIGNATURE SIGNATURE_32('s', 'd','r','v')
> +
> +typedef struct {
> + UINTN Signature;
> + LIST_ENTRY Link; // mDriverList
> +
> + LIST_ENTRY ScheduledLink; // mScheduledQueue
> +
> + EFI_HANDLE FvHandle;
> + EFI_GUID FileName;
> + VOID *Pe32Data;
> + UINTN Pe32DataSize;
> +
> + VOID *Depex;
> + UINTN DepexSize;
> +
> + BOOLEAN Before;
> + BOOLEAN After;
> + EFI_GUID BeforeAfterGuid;
> +
> + BOOLEAN Dependent;
> + BOOLEAN Scheduled;
> + BOOLEAN Initialized;
> + BOOLEAN DepexProtocolError;
> +
> + EFI_HANDLE ImageHandle;
> + EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
> + //
> + // Image EntryPoint in MMRAM
> + //
> + PHYSICAL_ADDRESS ImageEntryPoint;
> + //
> + // Image Buffer in MMRAM
> + //
> + PHYSICAL_ADDRESS ImageBuffer;
> + //
> + // Image Page Number
> + //
> + UINTN NumberOfPage;
> +} EFI_MM_DRIVER_ENTRY;
> +
> +#define EFI_HANDLE_SIGNATURE SIGNATURE_32('h','n','d','l')
> +
> +///
> +/// IHANDLE - contains a list of protocol handles
> +///
> +typedef struct {
> + UINTN Signature;
> + /// All handles list of IHANDLE
> + LIST_ENTRY AllHandles;
> + /// List of PROTOCOL_INTERFACE's for this handle
> + LIST_ENTRY Protocols;
> + UINTN LocateRequest;
> +} IHANDLE;
> +
> +#define ASSERT_IS_HANDLE(a) ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)
> +
> +#define PROTOCOL_ENTRY_SIGNATURE SIGNATURE_32('p','r','t','e')
> +
> +///
> +/// PROTOCOL_ENTRY - each different protocol has 1 entry in the protocol
> +/// database. Each handler that supports this protocol is listed, along
> +/// with a list of registered notifies.
> +///
> +typedef struct {
> + UINTN Signature;
> + /// Link Entry inserted to mProtocolDatabase
> + LIST_ENTRY AllEntries;
> + /// ID of the protocol
> + EFI_GUID ProtocolID;
> + /// All protocol interfaces
> + LIST_ENTRY Protocols;
> + /// Registerd notification handlers
> + LIST_ENTRY Notify;
> +} PROTOCOL_ENTRY;
> +
> +#define PROTOCOL_INTERFACE_SIGNATURE SIGNATURE_32('p','i','f','c')
> +
> +///
> +/// PROTOCOL_INTERFACE - each protocol installed on a handle is tracked
> +/// with a protocol interface structure
> +///
> +typedef struct {
> + UINTN Signature;
> + /// Link on IHANDLE.Protocols
> + LIST_ENTRY Link;
> + /// Back pointer
> + IHANDLE *Handle;
> + /// Link on PROTOCOL_ENTRY.Protocols
> + LIST_ENTRY ByProtocol;
> + /// The protocol ID
> + PROTOCOL_ENTRY *Protocol;
> + /// The interface value
> + VOID *Interface;
> +} PROTOCOL_INTERFACE;
> +
> +#define PROTOCOL_NOTIFY_SIGNATURE SIGNATURE_32('p','r','t','n')
> +
> +///
> +/// PROTOCOL_NOTIFY - used for each register notification for a protocol
> +///
> +typedef struct {
> + UINTN Signature;
> + PROTOCOL_ENTRY *Protocol;
> + /// All notifications for this protocol
> + LIST_ENTRY Link;
> + /// Notification function
> + EFI_MM_NOTIFY_FN Function;
> + /// Last position notified
> + LIST_ENTRY *Position;
> +} PROTOCOL_NOTIFY;
> +
> +//
> +// MM Core Global Variables
> +//
> +extern MM_CORE_PRIVATE_DATA *gMmCorePrivate;
> +extern EFI_MM_SYSTEM_TABLE gMmCoreMmst;
> +extern LIST_ENTRY gHandleList;
> +extern EFI_PHYSICAL_ADDRESS gLoadModuleAtFixAddressMmramBase;
> +
> +/**
> + Called to initialize the memory service.
> +
> + @param MmramRangeCount Number of MMRAM Regions
> + @param MmramRanges Pointer to MMRAM Descriptors
> +
> +**/
> +VOID
> +MmInitializeMemoryServices (
> + IN UINTN MmramRangeCount,
> + IN EFI_MMRAM_DESCRIPTOR *MmramRanges
> + );
> +
> +/**
> + The MmInstallConfigurationTable() function is used to maintain the list
> + of configuration tables that are stored in the System Management System
> + Table. The list is stored as an array of (GUID, Pointer) pairs. The list
> + must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
> +
> + @param SystemTable A pointer to the MM System Table (SMST).
> + @param Guid A pointer to the GUID for the entry to add, update, or remove.
> + @param Table A pointer to the buffer of the table to add.
> + @param TableSize The size of the table to install.
> +
> + @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or removed.
> + @retval EFI_INVALID_PARAMETER Guid is not valid.
> + @retval EFI_NOT_FOUND An attempt was made to delete a non-existent entry.
> + @retval EFI_OUT_OF_RESOURCES There is not enough memory available to complete the operation.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInstallConfigurationTable (
> + IN CONST EFI_MM_SYSTEM_TABLE *SystemTable,
> + IN CONST EFI_GUID *Guid,
> + IN VOID *Table,
> + IN UINTN TableSize
> + );
> +
> +/**
> + Wrapper function to MmInstallProtocolInterfaceNotify. This is the public API which
> + Calls the private one which contains a BOOLEAN parameter for notifications
> +
> + @param UserHandle The handle to install the protocol handler on,
> + or NULL if a new handle is to be allocated
> + @param Protocol The protocol to add to the handle
> + @param InterfaceType Indicates whether Interface is supplied in
> + native form.
> + @param Interface The interface for the protocol being added
> +
> + @return Status code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInstallProtocolInterface (
> + IN OUT EFI_HANDLE *UserHandle,
> + IN EFI_GUID *Protocol,
> + IN EFI_INTERFACE_TYPE InterfaceType,
> + IN VOID *Interface
> + );
> +
> +/**
> + 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
> +
> + @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
> +MmAllocatePages (
> + IN EFI_ALLOCATE_TYPE Type,
> + IN EFI_MEMORY_TYPE MemoryType,
> + IN UINTN NumberOfPages,
> + OUT EFI_PHYSICAL_ADDRESS *Memory
> + );
> +
> +/**
> + 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
> +
> + @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
> +MmInternalAllocatePages (
> + IN EFI_ALLOCATE_TYPE Type,
> + IN EFI_MEMORY_TYPE MemoryType,
> + IN UINTN NumberOfPages,
> + OUT EFI_PHYSICAL_ADDRESS *Memory
> + );
> +
> +/**
> + Frees previous allocated pages.
> +
> + @param Memory Base address of memory being freed
> + @param 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, Address is zero or NumberOfPages is zero.
> + @return EFI_SUCCESS Pages successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmFreePages (
> + IN EFI_PHYSICAL_ADDRESS Memory,
> + IN UINTN NumberOfPages
> + );
> +
> +/**
> + Frees previous allocated pages.
> +
> + @param Memory Base address of memory being freed
> + @param 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, Address is zero or NumberOfPages is zero.
> + @return EFI_SUCCESS Pages successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInternalFreePages (
> + IN EFI_PHYSICAL_ADDRESS Memory,
> + IN UINTN NumberOfPages
> + );
> +
> +/**
> + Allocate pool of a particular type.
> +
> + @param PoolType Type of pool to allocate
> + @param Size The amount of pool to allocate
> + @param Buffer The address to return a pointer to the allocated
> + pool
> +
> + @retval EFI_INVALID_PARAMETER PoolType not valid
> + @retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed.
> + @retval EFI_SUCCESS Pool successfully allocated.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmAllocatePool (
> + IN EFI_MEMORY_TYPE PoolType,
> + IN UINTN Size,
> + OUT VOID **Buffer
> + );
> +
> +/**
> + Allocate pool of a particular type.
> +
> + @param PoolType Type of pool to allocate
> + @param Size The amount of pool to allocate
> + @param Buffer The address to return a pointer to the allocated
> + pool
> +
> + @retval EFI_INVALID_PARAMETER PoolType not valid
> + @retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed.
> + @retval EFI_SUCCESS Pool successfully allocated.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInternalAllocatePool (
> + IN EFI_MEMORY_TYPE PoolType,
> + IN UINTN Size,
> + OUT VOID **Buffer
> + );
> +
> +/**
> + Frees pool.
> +
> + @param Buffer The allocated pool entry to free
> +
> + @retval EFI_INVALID_PARAMETER Buffer is not a valid value.
> + @retval EFI_SUCCESS Pool successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmFreePool (
> + IN VOID *Buffer
> + );
> +
> +/**
> + Frees pool.
> +
> + @param Buffer The allocated pool entry to free
> +
> + @retval EFI_INVALID_PARAMETER Buffer is not a valid value.
> + @retval EFI_SUCCESS Pool successfully freed.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmInternalFreePool (
> + IN VOID *Buffer
> + );
> +
> +/**
> + Installs a protocol interface into the boot services environment.
> +
> + @param UserHandle The handle to install the protocol handler on,
> + or NULL if a new handle is to be allocated
> + @param Protocol The protocol to add to the handle
> + @param InterfaceType Indicates whether Interface is supplied in
> + native form.
> + @param Interface The interface for the protocol being added
> + @param Notify indicates whether notify the notification list
> + for this protocol
> +
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
> + @retval EFI_SUCCESS Protocol interface successfully installed
> +
> +**/
> +EFI_STATUS
> +MmInstallProtocolInterfaceNotify (
> + IN OUT EFI_HANDLE *UserHandle,
> + IN EFI_GUID *Protocol,
> + IN EFI_INTERFACE_TYPE InterfaceType,
> + IN VOID *Interface,
> + IN BOOLEAN Notify
> + );
> +
> +/**
> + Uninstalls all instances of a protocol:interfacer from a handle.
> + If the last protocol interface is remove from the handle, the
> + handle is freed.
> +
> + @param UserHandle The handle to remove the protocol handler from
> + @param Protocol The protocol, of protocol:interface, to remove
> + @param Interface The interface, of protocol:interface, to remove
> +
> + @retval EFI_INVALID_PARAMETER Protocol is NULL.
> + @retval EFI_SUCCESS Protocol interface successfully uninstalled.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmUninstallProtocolInterface (
> + IN EFI_HANDLE UserHandle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + );
> +
> +/**
> + Queries a handle to determine if it supports a specified protocol.
> +
> + @param UserHandle The handle being queried.
> + @param Protocol The published unique identifier of the protocol.
> + @param Interface Supplies the address where a pointer to the
> + corresponding Protocol Interface is returned.
> +
> + @return The requested protocol interface for the handle
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmHandleProtocol (
> + IN EFI_HANDLE UserHandle,
> + IN EFI_GUID *Protocol,
> + OUT VOID **Interface
> + );
> +
> +/**
> + Add a new protocol notification record for the request protocol.
> +
> + @param Protocol The requested protocol to add the notify
> + registration
> + @param Function Points to the notification function
> + @param Registration Returns the registration record
> +
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_SUCCESS Successfully returned the registration record
> + that has been added
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmRegisterProtocolNotify (
> + IN CONST EFI_GUID *Protocol,
> + IN EFI_MM_NOTIFY_FN Function,
> + OUT VOID **Registration
> + );
> +
> +/**
> + Locates the requested handle(s) and returns them in Buffer.
> +
> + @param SearchType The type of search to perform to locate the
> + handles
> + @param Protocol The protocol to search for
> + @param SearchKey Dependant on SearchType
> + @param BufferSize On input the size of Buffer. On output the
> + size of data returned.
> + @param Buffer The buffer to return the results in
> +
> + @retval EFI_BUFFER_TOO_SMALL Buffer too small, required buffer size is
> + returned in BufferSize.
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_SUCCESS Successfully found the requested handle(s) and
> + returns them in Buffer.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLocateHandle (
> + IN EFI_LOCATE_SEARCH_TYPE SearchType,
> + IN EFI_GUID *Protocol OPTIONAL,
> + IN VOID *SearchKey OPTIONAL,
> + IN OUT UINTN *BufferSize,
> + OUT EFI_HANDLE *Buffer
> + );
> +
> +/**
> + Return the first Protocol Interface that matches the Protocol GUID. If
> + Registration is pasased in return a Protocol Instance that was just add
> + to the system. If Retistration is NULL return the first Protocol Interface
> + you find.
> +
> + @param Protocol The protocol to search for
> + @param Registration Optional Registration Key returned from
> + RegisterProtocolNotify()
> + @param Interface Return the Protocol interface (instance).
> +
> + @retval EFI_SUCCESS If a valid Interface is returned
> + @retval EFI_INVALID_PARAMETER Invalid parameter
> + @retval EFI_NOT_FOUND Protocol interface not found
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLocateProtocol (
> + IN EFI_GUID *Protocol,
> + IN VOID *Registration OPTIONAL,
> + OUT VOID **Interface
> + );
> +
> +/**
> + Manage MMI of a particular type.
> +
> + @param HandlerType Points to the handler type or NULL for root MMI handlers.
> + @param Context Points to an optional context buffer.
> + @param CommBuffer Points to the optional communication buffer.
> + @param CommBufferSize Points to the size of the optional communication buffer.
> +
> + @retval EFI_SUCCESS Interrupt source was processed successfully but not quiesced.
> + @retval EFI_INTERRUPT_PENDING One or more MMI sources could not be quiesced.
> + @retval EFI_WARN_INTERRUPT_SOURCE_PENDING Interrupt source was not handled or quiesced.
> + @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED Interrupt source was handled and quiesced.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiManage (
> + IN CONST EFI_GUID *HandlerType,
> + IN CONST VOID *Context OPTIONAL,
> + IN OUT VOID *CommBuffer OPTIONAL,
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + Registers a handler to execute within MM.
> +
> + @param Handler Handler service funtion pointer.
> + @param HandlerType Points to the handler type or NULL for root MMI handlers.
> + @param DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.
> +
> + @retval EFI_SUCCESS Handler register success.
> + @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiHandlerRegister (
> + IN EFI_MM_HANDLER_ENTRY_POINT Handler,
> + IN CONST EFI_GUID *HandlerType OPTIONAL,
> + OUT EFI_HANDLE *DispatchHandle
> + );
> +
> +/**
> + Unregister a handler in MM.
> +
> + @param DispatchHandle The handle that was specified when the handler was registered.
> +
> + @retval EFI_SUCCESS Handler function was successfully unregistered.
> + @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmiHandlerUnRegister (
> + IN EFI_HANDLE DispatchHandle
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmDriverDispatchHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmFvDispatchHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmLegacyBootHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmExitBootServiceHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmReadyToBootHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmReadyToLockHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + This function is the main entry point for an MM handler dispatch
> + or communicate-based callback.
> +
> + @param DispatchHandle The unique handle assigned to this handler by MmiHandlerRegister().
> + @param Context Points to an optional handler context which was specified when the handler was registered.
> + @param CommBuffer A pointer to a collection of data in memory that will
> + be conveyed from a non-MM environment into an MM environment.
> + @param CommBufferSize The size of the CommBuffer.
> +
> + @return Status Code
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmEndOfDxeHandler (
> + IN EFI_HANDLE DispatchHandle,
> + IN CONST VOID *Context, OPTIONAL
> + IN OUT VOID *CommBuffer, OPTIONAL
> + IN OUT UINTN *CommBufferSize OPTIONAL
> + );
> +
> +/**
> + Place holder function until all the MM System Table Service are available.
> +
> + @param Arg1 Undefined
> + @param Arg2 Undefined
> + @param Arg3 Undefined
> + @param Arg4 Undefined
> + @param Arg5 Undefined
> +
> + @return EFI_NOT_AVAILABLE_YET
> +
> +**/
> +EFI_STATUS
> +EFIAPI
> +MmEfiNotAvailableYetArg5 (
> + UINTN Arg1,
> + UINTN Arg2,
> + UINTN Arg3,
> + UINTN Arg4,
> + UINTN Arg5
> + );
> +
> +//
> +//Functions used during debug buils
> +//
> +
> +/**
> + Traverse the discovered list for any drivers that were discovered but not loaded
> + because the dependency expressions evaluated to false.
> +
> +**/
> +VOID
> +MmDisplayDiscoveredNotDispatched (
> + VOID
> + );
> +
> +/**
> + Add free MMRAM region for use by memory service.
> +
> + @param MemBase Base address of memory region.
> + @param MemLength Length of the memory region.
> + @param Type Memory type.
> + @param Attributes Memory region state.
> +
> +**/
> +VOID
> +MmAddMemoryRegion (
> + IN EFI_PHYSICAL_ADDRESS MemBase,
> + IN UINT64 MemLength,
> + IN EFI_MEMORY_TYPE Type,
> + IN UINT64 Attributes
> + );
> +
> +/**
> + Finds the protocol entry for the requested protocol.
> +
> + @param Protocol The ID of the protocol
> + @param Create Create a new entry if not found
> +
> + @return Protocol entry
> +
> +**/
> +PROTOCOL_ENTRY *
> +MmFindProtocolEntry (
> + IN EFI_GUID *Protocol,
> + IN BOOLEAN Create
> + );
> +
> +/**
> + Signal event for every protocol in protocol entry.
> +
> + @param Prot Protocol interface
> +
> +**/
> +VOID
> +MmNotifyProtocol (
> + IN PROTOCOL_INTERFACE *Prot
> + );
> +
> +/**
> + Finds the protocol instance for the requested handle and protocol.
> + Note: This function doesn't do parameters checking, it's caller's responsibility
> + to pass in valid parameters.
> +
> + @param Handle The handle to search the protocol on
> + @param Protocol GUID of the protocol
> + @param Interface The interface for the protocol being searched
> +
> + @return Protocol instance (NULL: Not found)
> +
> +**/
> +PROTOCOL_INTERFACE *
> +MmFindProtocolInterface (
> + IN IHANDLE *Handle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + );
> +
> +/**
> + Removes Protocol from the protocol list (but not the handle list).
> +
> + @param Handle The handle to remove protocol on.
> + @param Protocol GUID of the protocol to be moved
> + @param Interface The interface of the protocol
> +
> + @return Protocol Entry
> +
> +**/
> +PROTOCOL_INTERFACE *
> +MmRemoveInterfaceFromProtocol (
> + IN IHANDLE *Handle,
> + IN EFI_GUID *Protocol,
> + IN VOID *Interface
> + );
> +
> +/**
> + This is the POSTFIX version of the dependency evaluator. This code does
> + not need to handle Before or After, as it is not valid to call this
> + routine in this case. POSTFIX means all the math is done on top of the stack.
> +
> + @param DriverEntry DriverEntry element to update.
> +
> + @retval TRUE If driver is ready to run.
> + @retval FALSE If driver is not ready to run or some fatal error
> + was found.
> +
> +**/
> +BOOLEAN
> +MmIsSchedulable (
> + IN EFI_MM_DRIVER_ENTRY *DriverEntry
> + );
> +
> +/**
> + Dump MMRAM information.
> +
> +**/
> +VOID
> +DumpMmramInfo (
> + VOID
> + );
> +
> +extern UINTN mMmramRangeCount;
> +extern EFI_MMRAM_DESCRIPTOR *mMmramRanges;
> +extern EFI_SYSTEM_TABLE *mEfiSystemTable;
> +
> +#endif
> diff --git a/StandaloneMmPkg/Core/StandaloneMmCore.inf b/StandaloneMmPkg/Core/StandaloneMmCore.inf
> new file mode 100644
> index 0000000000..c5eaa14ba3
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/StandaloneMmCore.inf
> @@ -0,0 +1,80 @@
> +## @file
> +# This module provide an SMM CIS compliant implementation of SMM Core.
> +#
> +# Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
> +# Copyright (c) 2016 - 2017, ARM Limited. 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
> +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +#
> +##
> +
> +[Defines]
> + INF_VERSION = 0x0001001A
> + BASE_NAME = StandaloneMmCore
> + FILE_GUID = 6E14B6FD-3600-4DD6-A17A-206B3B6DCE16
> + MODULE_TYPE = MM_CORE_STANDALONE
> + VERSION_STRING = 1.0
> + PI_SPECIFICATION_VERSION = 0x00010032
> + ENTRY_POINT = StandaloneMmMain
> +
> +# VALID_ARCHITECTURES = IA32 X64 AARCH64
> +
> +[Sources]
> + StandaloneMmCore.c
> + StandaloneMmCore.h
> + StandaloneMmCorePrivateData.h
> + Page.c
> + Pool.c
> + Handle.c
> + Locate.c
> + Notify.c
> + Dependency.c
> + Dispatcher.c
> + Mmi.c
> + InstallConfigurationTable.c
> + FwVol.c
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> + MdeModulePkg/MdeModulePkg.dec
> + StandaloneMmPkg/StandaloneMmPkg.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + CacheMaintenanceLib
> + DebugLib
> + FvLib
> + HobLib
> + MemoryAllocationLib
> + MemLib
> + PeCoffLib
> + ReportStatusCodeLib
> + StandaloneMmCoreEntryPoint
> +
> +[Protocols]
> + gEfiDxeMmReadyToLockProtocolGuid ## UNDEFINED # SmiHandlerRegister
> + gEfiMmReadyToLockProtocolGuid ## PRODUCES
> + gEfiMmEndOfDxeProtocolGuid ## PRODUCES
> + gEfiLoadedImageProtocolGuid ## PRODUCES
> + gEfiMmConfigurationProtocolGuid ## CONSUMES
> +
> +[Guids]
> + gAprioriGuid ## SOMETIMES_CONSUMES ## File
> + gEfiEventDxeDispatchGuid ## PRODUCES ## GUID # SmiHandlerRegister
> + gEfiEndOfDxeEventGroupGuid ## PRODUCES ## GUID # SmiHandlerRegister
> + ## SOMETIMES_CONSUMES ## GUID # Locate protocol
> + ## SOMETIMES_PRODUCES ## GUID # SmiHandlerRegister
> + gEdkiiMemoryProfileGuid
> + gZeroGuid ## SOMETIMES_CONSUMES ## GUID
> + gEfiHobListGuid
> + gMmCoreDataHobGuid
> + gMmFvDispatchGuid
> + gEfiEventLegacyBootGuid
> + gEfiEventExitBootServicesGuid
> + gEfiEventReadyToBootGuid
> diff --git a/StandaloneMmPkg/Core/StandaloneMmCorePrivateData.h b/StandaloneMmPkg/Core/StandaloneMmCorePrivateData.h
> new file mode 100644
> index 0000000000..faedf3ff2d
> --- /dev/null
> +++ b/StandaloneMmPkg/Core/StandaloneMmCorePrivateData.h
> @@ -0,0 +1,66 @@
> +/** @file
> + The internal header file that declared a data structure that is shared
> + between the MM IPL and the MM Core.
> +
> + Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
> + Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#ifndef _STANDALONE_MM_CORE_PRIVATE_DATA_H_
> +#define _STANDALONE_MM_CORE_PRIVATE_DATA_H_
> +
> +#include <Guid/MmCoreData.h>
> +
> +//
> +// Page management
> +//
> +
> +typedef struct {
> + LIST_ENTRY Link;
> + UINTN NumberOfPages;
> +} FREE_PAGE_LIST;
> +
> +extern LIST_ENTRY mMmMemoryMap;
> +
> +//
> +// Pool management
> +//
> +
> +//
> +// MIN_POOL_SHIFT must not be less than 5
> +//
> +#define MIN_POOL_SHIFT 6
> +#define MIN_POOL_SIZE (1 << MIN_POOL_SHIFT)
> +
> +//
> +// MAX_POOL_SHIFT must not be less than EFI_PAGE_SHIFT - 1
> +//
> +#define MAX_POOL_SHIFT (EFI_PAGE_SHIFT - 1)
> +#define MAX_POOL_SIZE (1 << MAX_POOL_SHIFT)
> +
> +//
> +// MAX_POOL_INDEX are calculated by maximum and minimum pool sizes
> +//
> +#define MAX_POOL_INDEX (MAX_POOL_SHIFT - MIN_POOL_SHIFT + 1)
> +
> +typedef struct {
> + UINTN Size;
> + BOOLEAN Available;
> +} POOL_HEADER;
> +
> +typedef struct {
> + POOL_HEADER Header;
> + LIST_ENTRY Link;
> +} FREE_POOL_HEADER;
> +
> +extern LIST_ENTRY mMmPoolLists[MAX_POOL_INDEX];
> +
> +#endif
> diff --git a/StandaloneMmPkg/Include/Guid/MmFvDispatch.h b/StandaloneMmPkg/Include/Guid/MmFvDispatch.h
> new file mode 100644
> index 0000000000..fb194d3474
> --- /dev/null
> +++ b/StandaloneMmPkg/Include/Guid/MmFvDispatch.h
> @@ -0,0 +1,38 @@
> +/** @file
> + GUIDs for MM Event.
> +
> +Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
> +Copyright (c) 2016 - 2017, ARM Limited. All rights reserved.<BR>
> +
> +This program and the accompanying materials are licensed and made available under
> +the terms and conditions of the BSD License that 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.
> +
> +**/
> +
> +#ifndef __MM_FV_DISPATCH_H__
> +#define __MM_FV_DISPATCH_H__
> +
> +#define MM_FV_DISPATCH_GUID \
> + { 0xb65694cc, 0x9e3, 0x4c3b, { 0xb5, 0xcd, 0x5, 0xf4, 0x4d, 0x3c, 0xdb, 0xff }}
> +
> +extern EFI_GUID gMmFvDispatchGuid;
> +
> +#pragma pack(1)
> +typedef struct {
> + EFI_PHYSICAL_ADDRESS Address;
> + UINT64 Size;
> +} EFI_MM_COMMUNICATE_FV_DISPATCH_DATA;
> +
> +typedef struct {
> + EFI_GUID HeaderGuid;
> + UINTN MessageLength;
> + EFI_MM_COMMUNICATE_FV_DISPATCH_DATA Data;
> +} EFI_MM_COMMUNICATE_FV_DISPATCH;
> +#pragma pack()
> +
> +#endif
> diff --git a/StandaloneMmPkg/Include/StandaloneMm.h b/StandaloneMmPkg/Include/StandaloneMm.h
> new file mode 100644
> index 0000000000..0e420315bb
> --- /dev/null
> +++ b/StandaloneMmPkg/Include/StandaloneMm.h
> @@ -0,0 +1,36 @@
> +/** @file
> + Standalone MM.
> +
> +Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
> +Copyright (c) 2016 - 2017, ARM Limited. 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
> +
> +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#ifndef _STANDALONE_MM_H_
> +#define _STANDALONE_MM_H_
> +
> +#include <PiMm.h>
> +
> +typedef
> +EFI_STATUS
> +(EFIAPI *MM_IMAGE_ENTRY_POINT) (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_MM_SYSTEM_TABLE *MmSystemTable
> + );
> +
> +typedef
> +EFI_STATUS
> +(EFIAPI *STANDALONE_MM_FOUNDATION_ENTRY_POINT) (
> + IN VOID *HobStart
> + );
> +
> +#endif
> --
> 2.16.2
>
next prev parent reply other threads:[~2018-04-30 19:18 UTC|newest]
Thread overview: 70+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-04-06 14:42 [PATCH v1 00/18] *** Standalone Management Mode Core Interface for AARCH64 Platforms *** Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 01/18] ArmPkg: Add PCDs needed for MM communication driver Supreeth Venkatesh
2018-04-11 14:43 ` Achin Gupta
[not found] ` <AM4PR0802MB23063743A3B2F5A552BE320580870@AM4PR0802MB2306.eurprd08.prod.outlook.com>
2018-05-04 23:13 ` Supreeth Venkatesh
2018-05-04 23:17 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 02/18] ArmPkg/Drivers: Add EFI_MM_COMMUNICATION_PROTOCOL DXE driver Supreeth Venkatesh
2018-04-11 14:00 ` Achin Gupta
2018-05-04 23:18 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 03/18] ArmPkg/Include: Add MM interface SVC return codes Supreeth Venkatesh
2018-04-11 14:38 ` Achin Gupta
2018-05-04 23:19 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 04/18] ArmPkg/ArmMmuLib: Add MMU Library suitable for use in S-EL0 Supreeth Venkatesh
2018-04-11 19:21 ` Achin Gupta
2018-05-04 23:19 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 05/18] ArmPkg/ArmMmuLib: Add MMU library inf file " Supreeth Venkatesh
2018-04-11 19:24 ` Achin Gupta
2018-05-04 23:19 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 06/18] StandaloneMmPkg: Add an AArch64 specific entry point library Supreeth Venkatesh
2018-04-16 14:04 ` Achin Gupta
2018-05-04 23:20 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 07/18] StandaloneMmPkg/FvLib: Add a common FV Library for management mode Supreeth Venkatesh
2018-04-16 14:44 ` Achin Gupta
2018-05-04 23:21 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 08/18] StandaloneMmPkg/MemLib: AARCH64 Specific instance of memory check library Supreeth Venkatesh
2018-04-16 15:12 ` Achin Gupta
2018-04-16 22:30 ` Yao, Jiewen
2018-04-25 10:35 ` Achin Gupta
2018-04-26 13:02 ` Yao, Jiewen
2018-05-04 23:21 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 09/18] StandaloneMmPkg/MemoryAllocationLib: Add MM memory allocation library Supreeth Venkatesh
2018-04-25 14:33 ` Achin Gupta
2018-04-26 13:05 ` Yao, Jiewen
2018-05-04 23:23 ` Supreeth Venkatesh
2018-05-04 23:21 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 10/18] StandaloneMmPkg/HobLib: Add AARCH64 Specific HOB Library for management mode Supreeth Venkatesh
2018-04-25 14:50 ` Achin Gupta
2018-04-26 13:04 ` Yao, Jiewen
2018-05-04 23:22 ` Supreeth Venkatesh
2018-05-04 23:25 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 11/18] StandaloneMmPkg: MM driver entry point library Supreeth Venkatesh
2018-04-30 14:29 ` Achin Gupta
2018-05-04 23:24 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 12/18] StandaloneMmPkg/CpuMm: Add CPU driver suitable for ARM Platforms Supreeth Venkatesh
2018-04-18 22:09 ` Daniil Egranov
2018-05-04 23:25 ` Supreeth Venkatesh
2018-04-30 15:50 ` Achin Gupta
2018-05-04 23:24 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 13/18] StandaloneMmPkg/Core: Implementation of Standalone MM Core Module Supreeth Venkatesh
2018-04-30 19:19 ` Achin Gupta [this message]
2018-04-30 19:28 ` Ard Biesheuvel
2018-04-30 20:17 ` Achin Gupta
2018-05-01 8:18 ` Laszlo Ersek
2018-05-04 23:28 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 14/18] StandaloneMmPkg: Describe the declaration, definition and fdf files Supreeth Venkatesh
2018-04-18 19:50 ` Daniil Egranov
2018-05-04 23:29 ` Supreeth Venkatesh
2018-04-30 19:32 ` Achin Gupta
2018-05-04 23:28 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 15/18] ArmPkg: Extra action to update permissions for S-ELO MM Image Supreeth Venkatesh
2018-04-30 19:49 ` Achin Gupta
2018-05-04 23:30 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 16/18] BaseTools/AutoGen: Update header file for MM modules Supreeth Venkatesh
2018-04-30 19:52 ` Achin Gupta
2018-05-04 23:30 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 17/18] StandaloneMmPkg: Add application to test MM communication protocol Supreeth Venkatesh
2018-04-30 20:02 ` Achin Gupta
2018-05-04 23:31 ` Supreeth Venkatesh
2018-04-06 14:42 ` [PATCH v1 18/18] StandaloneMmPkg: Add handler to handle event received from Normal World Supreeth Venkatesh
2018-04-08 6:01 ` [PATCH v1 00/18] *** Standalone Management Mode Core Interface for AARCH64 Platforms *** Yao, Jiewen
2018-05-04 23:15 ` Supreeth Venkatesh
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20180430191942.GX663@e104320-lin \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox