[mirror_edk2.git] / MdeModulePkg / Core / PiSmmCore / PiSmmCore.h

/** @file\r
  The internal header file includes the common header files, defines\r
  internal structure and functions used by SmmCore module.\r
\r
  Copyright (c) 2009 - 2019, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#ifndef _SMM_CORE_H_\r
#define _SMM_CORE_H_\r
\r
#include <PiSmm.h>\r
\r
#include <Protocol/DxeSmmReadyToLock.h>\r
#include <Protocol/SmmReadyToLock.h>\r
#include <Protocol/SmmEndOfDxe.h>\r
#include <Protocol/CpuIo2.h>\r
#include <Protocol/SmmCommunication.h>\r
#include <Protocol/SmmAccess2.h>\r
#include <Protocol/FirmwareVolume2.h>\r
#include <Protocol/LoadedImage.h>\r
#include <Protocol/DevicePath.h>\r
#include <Protocol/Security.h>\r
#include <Protocol/Security2.h>\r
#include <Protocol/SmmExitBootServices.h>\r
#include <Protocol/SmmLegacyBoot.h>\r
#include <Protocol/SmmReadyToBoot.h>\r
#include <Protocol/SmmMemoryAttribute.h>\r
#include <Protocol/SmmSxDispatch2.h>\r
\r
#include <Guid/Apriori.h>\r
#include <Guid/EventGroup.h>\r
#include <Guid/EventLegacyBios.h>\r
#include <Guid/MemoryProfile.h>\r
#include <Guid/LoadModuleAtFixedAddress.h>\r
#include <Guid/SmiHandlerProfile.h>\r
#include <Guid/EndOfS3Resume.h>\r
#include <Guid/S3SmmInitDone.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/PeCoffLib.h>\r
#include <Library/PeCoffGetEntryPointLib.h>\r
#include <Library/CacheMaintenanceLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/ReportStatusCodeLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/SmmCorePlatformHookLib.h>\r
#include <Library/PerformanceLib.h>\r
#include <Library/HobLib.h>\r
#include <Library/SmmMemLib.h>\r
#include <Library/SafeIntLib.h>\r
\r
#include "PiSmmCorePrivateData.h"\r
#include "HeapGuard.h"\r
\r
//\r
// Used to build a table of SMI Handlers that the SMM Core registers\r
//\r
typedef struct {\r
  EFI_SMM_HANDLER_ENTRY_POINT2    Handler;\r
  EFI_GUID                        *HandlerType;\r
  EFI_HANDLE                      DispatchHandle;\r
  BOOLEAN                         UnRegister;\r
} SMM_CORE_SMI_HANDLERS;\r
\r
//\r
// SMM_HANDLER - used for each SMM handler\r
//\r
\r
#define SMI_ENTRY_SIGNATURE  SIGNATURE_32('s','m','i','e')\r
\r
typedef struct {\r
  UINTN         Signature;\r
  LIST_ENTRY    AllEntries; // All entries\r
\r
  EFI_GUID      HandlerType; // Type of interrupt\r
  LIST_ENTRY    SmiHandlers; // All handlers\r
} SMI_ENTRY;\r
\r
#define SMI_HANDLER_SIGNATURE  SIGNATURE_32('s','m','i','h')\r
\r
typedef struct {\r
  UINTN                           Signature;\r
  LIST_ENTRY                      Link;       // Link on SMI_ENTRY.SmiHandlers\r
  EFI_SMM_HANDLER_ENTRY_POINT2    Handler;    // The smm handler's entry point\r
  UINTN                           CallerAddr; // The address of caller who register the SMI handler.\r
  SMI_ENTRY                       *SmiEntry;\r
  VOID                            *Context;    // for profile\r
  UINTN                           ContextSize; // for profile\r
} SMI_HANDLER;\r
\r
//\r
// Structure for recording the state of an SMM Driver\r
//\r
#define EFI_SMM_DRIVER_ENTRY_SIGNATURE  SIGNATURE_32('s', 'd','r','v')\r
\r
typedef struct {\r
  UINTN                            Signature;\r
  LIST_ENTRY                       Link;            // mDriverList\r
\r
  LIST_ENTRY                       ScheduledLink;   // mScheduledQueue\r
\r
  EFI_HANDLE                       FvHandle;\r
  EFI_GUID                         FileName;\r
  EFI_DEVICE_PATH_PROTOCOL         *FvFileDevicePath;\r
  EFI_FIRMWARE_VOLUME2_PROTOCOL    *Fv;\r
\r
  VOID                             *Depex;\r
  UINTN                            DepexSize;\r
\r
  BOOLEAN                          Before;\r
  BOOLEAN                          After;\r
  EFI_GUID                         BeforeAfterGuid;\r
\r
  BOOLEAN                          Dependent;\r
  BOOLEAN                          Scheduled;\r
  BOOLEAN                          Initialized;\r
  BOOLEAN                          DepexProtocolError;\r
\r
  EFI_HANDLE                       ImageHandle;\r
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;\r
  //\r
  // Image EntryPoint in SMRAM\r
  //\r
  PHYSICAL_ADDRESS                 ImageEntryPoint;\r
  //\r
  // Image Buffer in SMRAM\r
  //\r
  PHYSICAL_ADDRESS                 ImageBuffer;\r
  //\r
  // Image Page Number\r
  //\r
  UINTN                            NumberOfPage;\r
  EFI_HANDLE                       SmmImageHandle;\r
  EFI_LOADED_IMAGE_PROTOCOL        SmmLoadedImage;\r
} EFI_SMM_DRIVER_ENTRY;\r
\r
#define EFI_HANDLE_SIGNATURE  SIGNATURE_32('s','h','d','l')\r
\r
///\r
/// IHANDLE - contains a list of protocol handles\r
///\r
typedef struct {\r
  UINTN         Signature;\r
  /// All handles list of IHANDLE\r
  LIST_ENTRY    AllHandles;\r
  /// List of PROTOCOL_INTERFACE's for this handle\r
  LIST_ENTRY    Protocols;\r
  UINTN         LocateRequest;\r
} IHANDLE;\r
\r
#define ASSERT_IS_HANDLE(a)  ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)\r
\r
#define PROTOCOL_ENTRY_SIGNATURE  SIGNATURE_32('s','p','t','e')\r
\r
///\r
/// PROTOCOL_ENTRY - each different protocol has 1 entry in the protocol\r
/// database.  Each handler that supports this protocol is listed, along\r
/// with a list of registered notifies.\r
///\r
typedef struct {\r
  UINTN         Signature;\r
  /// Link Entry inserted to mProtocolDatabase\r
  LIST_ENTRY    AllEntries;\r
  /// ID of the protocol\r
  EFI_GUID      ProtocolID;\r
  /// All protocol interfaces\r
  LIST_ENTRY    Protocols;\r
  /// Registered notification handlers\r
  LIST_ENTRY    Notify;\r
} PROTOCOL_ENTRY;\r
\r
#define PROTOCOL_INTERFACE_SIGNATURE  SIGNATURE_32('s','p','i','f')\r
\r
///\r
/// PROTOCOL_INTERFACE - each protocol installed on a handle is tracked\r
/// with a protocol interface structure\r
///\r
typedef struct {\r
  UINTN             Signature;\r
  /// Link on IHANDLE.Protocols\r
  LIST_ENTRY        Link;\r
  /// Back pointer\r
  IHANDLE           *Handle;\r
  /// Link on PROTOCOL_ENTRY.Protocols\r
  LIST_ENTRY        ByProtocol;\r
  /// The protocol ID\r
  PROTOCOL_ENTRY    *Protocol;\r
  /// The interface value\r
  VOID              *Interface;\r
} PROTOCOL_INTERFACE;\r
\r
#define PROTOCOL_NOTIFY_SIGNATURE  SIGNATURE_32('s','p','t','n')\r
\r
///\r
/// PROTOCOL_NOTIFY - used for each register notification for a protocol\r
///\r
typedef struct {\r
  UINTN                Signature;\r
  PROTOCOL_ENTRY       *Protocol;\r
  /// All notifications for this protocol\r
  LIST_ENTRY           Link;\r
  /// Notification function\r
  EFI_SMM_NOTIFY_FN    Function;\r
  /// Last position notified\r
  LIST_ENTRY           *Position;\r
} PROTOCOL_NOTIFY;\r
\r
//\r
// SMM Core Global Variables\r
//\r
extern SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate;\r
extern EFI_SMM_SYSTEM_TABLE2  gSmmCoreSmst;\r
extern LIST_ENTRY             gHandleList;\r
extern EFI_PHYSICAL_ADDRESS   gLoadModuleAtFixAddressSmramBase;\r
\r
/**\r
  Called to initialize the memory service.\r
\r
  @param   SmramRangeCount       Number of SMRAM Regions\r
  @param   SmramRanges           Pointer to SMRAM Descriptors\r
\r
**/\r
VOID\r
SmmInitializeMemoryServices (\r
  IN UINTN                 SmramRangeCount,\r
  IN EFI_SMRAM_DESCRIPTOR  *SmramRanges\r
  );\r
\r
/**\r
  The SmmInstallConfigurationTable() function is used to maintain the list\r
  of configuration tables that are stored in the System Management System\r
  Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list\r
  must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.\r
\r
  @param  SystemTable      A pointer to the SMM System Table (SMST).\r
  @param  Guid             A pointer to the GUID for the entry to add, update, or remove.\r
  @param  Table            A pointer to the buffer of the table to add.\r
  @param  TableSize        The size of the table to install.\r
\r
  @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.\r
  @retval EFI_INVALID_PARAMETER Guid is not valid.\r
  @retval EFI_NOT_FOUND         An attempt was made to delete a non-existent entry.\r
  @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInstallConfigurationTable (\r
  IN  CONST EFI_SMM_SYSTEM_TABLE2  *SystemTable,\r
  IN  CONST EFI_GUID               *Guid,\r
  IN  VOID                         *Table,\r
  IN  UINTN                        TableSize\r
  );\r
\r
/**\r
  Wrapper function to SmmInstallProtocolInterfaceNotify.  This is the public API which\r
  Calls the private one which contains a BOOLEAN parameter for notifications\r
\r
  @param  UserHandle             The handle to install the protocol handler on,\r
                                 or NULL if a new handle is to be allocated\r
  @param  Protocol               The protocol to add to the handle\r
  @param  InterfaceType          Indicates whether Interface is supplied in\r
                                 native form.\r
  @param  Interface              The interface for the protocol being added\r
\r
  @return Status code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInstallProtocolInterface (\r
  IN OUT EFI_HANDLE      *UserHandle,\r
  IN EFI_GUID            *Protocol,\r
  IN EFI_INTERFACE_TYPE  InterfaceType,\r
  IN VOID                *Interface\r
  );\r
\r
/**\r
  Allocates pages from the memory map.\r
\r
  @param  Type                   The type of allocation to perform\r
  @param  MemoryType             The type of memory to turn the allocated pages\r
                                 into\r
  @param  NumberOfPages          The number of pages to allocate\r
  @param  Memory                 A pointer to receive the base allocated memory\r
                                 address\r
\r
  @retval EFI_INVALID_PARAMETER  Parameters violate checking rules defined in spec.\r
  @retval EFI_NOT_FOUND          Could not allocate pages match the requirement.\r
  @retval EFI_OUT_OF_RESOURCES   No enough pages to allocate.\r
  @retval EFI_SUCCESS            Pages successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmAllocatePages (\r
  IN      EFI_ALLOCATE_TYPE     Type,\r
  IN      EFI_MEMORY_TYPE       MemoryType,\r
  IN      UINTN                 NumberOfPages,\r
  OUT     EFI_PHYSICAL_ADDRESS  *Memory\r
  );\r
\r
/**\r
  Allocates pages from the memory map.\r
\r
  @param  Type                   The type of allocation to perform\r
  @param  MemoryType             The type of memory to turn the allocated pages\r
                                 into\r
  @param  NumberOfPages          The number of pages to allocate\r
  @param  Memory                 A pointer to receive the base allocated memory\r
                                 address\r
  @param  NeedGuard              Flag to indicate Guard page is needed or not\r
\r
  @retval EFI_INVALID_PARAMETER  Parameters violate checking rules defined in spec.\r
  @retval EFI_NOT_FOUND          Could not allocate pages match the requirement.\r
  @retval EFI_OUT_OF_RESOURCES   No enough pages to allocate.\r
  @retval EFI_SUCCESS            Pages successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalAllocatePages (\r
  IN      EFI_ALLOCATE_TYPE     Type,\r
  IN      EFI_MEMORY_TYPE       MemoryType,\r
  IN      UINTN                 NumberOfPages,\r
  OUT     EFI_PHYSICAL_ADDRESS  *Memory,\r
  IN      BOOLEAN               NeedGuard\r
  );\r
\r
/**\r
  Frees previous allocated pages.\r
\r
  @param  Memory                 Base address of memory being freed\r
  @param  NumberOfPages          The number of pages to free\r
\r
  @retval EFI_NOT_FOUND          Could not find the entry that covers the range\r
  @retval EFI_INVALID_PARAMETER  Address not aligned, Address is zero or NumberOfPages is zero.\r
  @return EFI_SUCCESS            Pages successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmFreePages (\r
  IN      EFI_PHYSICAL_ADDRESS  Memory,\r
  IN      UINTN                 NumberOfPages\r
  );\r
\r
/**\r
  Frees previous allocated pages.\r
\r
  @param  Memory                 Base address of memory being freed\r
  @param  NumberOfPages          The number of pages to free\r
  @param  IsGuarded              Flag to indicate if the memory is guarded\r
                                 or not\r
\r
  @retval EFI_NOT_FOUND          Could not find the entry that covers the range\r
  @retval EFI_INVALID_PARAMETER  Address not aligned, Address is zero or NumberOfPages is zero.\r
  @return EFI_SUCCESS            Pages successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalFreePages (\r
  IN      EFI_PHYSICAL_ADDRESS  Memory,\r
  IN      UINTN                 NumberOfPages,\r
  IN      BOOLEAN               IsGuarded\r
  );\r
\r
/**\r
  Allocate pool of a particular type.\r
\r
  @param  PoolType               Type of pool to allocate\r
  @param  Size                   The amount of pool to allocate\r
  @param  Buffer                 The address to return a pointer to the allocated\r
                                 pool\r
\r
  @retval EFI_INVALID_PARAMETER  PoolType not valid\r
  @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.\r
  @retval EFI_SUCCESS            Pool successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmAllocatePool (\r
  IN      EFI_MEMORY_TYPE  PoolType,\r
  IN      UINTN            Size,\r
  OUT     VOID             **Buffer\r
  );\r
\r
/**\r
  Allocate pool of a particular type.\r
\r
  @param  PoolType               Type of pool to allocate\r
  @param  Size                   The amount of pool to allocate\r
  @param  Buffer                 The address to return a pointer to the allocated\r
                                 pool\r
\r
  @retval EFI_INVALID_PARAMETER  PoolType not valid\r
  @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.\r
  @retval EFI_SUCCESS            Pool successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalAllocatePool (\r
  IN      EFI_MEMORY_TYPE  PoolType,\r
  IN      UINTN            Size,\r
  OUT     VOID             **Buffer\r
  );\r
\r
/**\r
  Frees pool.\r
\r
  @param  Buffer                 The allocated pool entry to free\r
\r
  @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.\r
  @retval EFI_SUCCESS            Pool successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmFreePool (\r
  IN      VOID  *Buffer\r
  );\r
\r
/**\r
  Frees pool.\r
\r
  @param  Buffer                 The allocated pool entry to free\r
\r
  @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.\r
  @retval EFI_SUCCESS            Pool successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalFreePool (\r
  IN      VOID  *Buffer\r
  );\r
\r
/**\r
  Installs a protocol interface into the boot services environment.\r
\r
  @param  UserHandle             The handle to install the protocol handler on,\r
                                 or NULL if a new handle is to be allocated\r
  @param  Protocol               The protocol to add to the handle\r
  @param  InterfaceType          Indicates whether Interface is supplied in\r
                                 native form.\r
  @param  Interface              The interface for the protocol being added\r
  @param  Notify                 indicates whether notify the notification list\r
                                 for this protocol\r
\r
  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
  @retval EFI_OUT_OF_RESOURCES   No enough buffer to allocate\r
  @retval EFI_SUCCESS            Protocol interface successfully installed\r
\r
**/\r
EFI_STATUS\r
SmmInstallProtocolInterfaceNotify (\r
  IN OUT EFI_HANDLE      *UserHandle,\r
  IN EFI_GUID            *Protocol,\r
  IN EFI_INTERFACE_TYPE  InterfaceType,\r
  IN VOID                *Interface,\r
  IN BOOLEAN             Notify\r
  );\r
\r
/**\r
  Uninstalls all instances of a protocol:interfacer from a handle.\r
  If the last protocol interface is remove from the handle, the\r
  handle is freed.\r
\r
  @param  UserHandle             The handle to remove the protocol handler from\r
  @param  Protocol               The protocol, of protocol:interface, to remove\r
  @param  Interface              The interface, of protocol:interface, to remove\r
\r
  @retval EFI_INVALID_PARAMETER  Protocol is NULL.\r
  @retval EFI_SUCCESS            Protocol interface successfully uninstalled.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmUninstallProtocolInterface (\r
  IN EFI_HANDLE  UserHandle,\r
  IN EFI_GUID    *Protocol,\r
  IN VOID        *Interface\r
  );\r
\r
/**\r
  Queries a handle to determine if it supports a specified protocol.\r
\r
  @param  UserHandle             The handle being queried.\r
  @param  Protocol               The published unique identifier of the protocol.\r
  @param  Interface              Supplies the address where a pointer to the\r
                                 corresponding Protocol Interface is returned.\r
\r
  @return The requested protocol interface for the handle\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmHandleProtocol (\r
  IN EFI_HANDLE  UserHandle,\r
  IN EFI_GUID    *Protocol,\r
  OUT VOID       **Interface\r
  );\r
\r
/**\r
  Add a new protocol notification record for the request protocol.\r
\r
  @param  Protocol               The requested protocol to add the notify\r
                                 registration\r
  @param  Function               Points to the notification function\r
  @param  Registration           Returns the registration record\r
\r
  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
  @retval EFI_SUCCESS            Successfully returned the registration record\r
                                 that has been added\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmRegisterProtocolNotify (\r
  IN  CONST EFI_GUID     *Protocol,\r
  IN  EFI_SMM_NOTIFY_FN  Function,\r
  OUT VOID               **Registration\r
  );\r
\r
/**\r
  Locates the requested handle(s) and returns them in Buffer.\r
\r
  @param  SearchType             The type of search to perform to locate the\r
                                 handles\r
  @param  Protocol               The protocol to search for\r
  @param  SearchKey              Dependant on SearchType\r
  @param  BufferSize             On input the size of Buffer.  On output the\r
                                 size of data returned.\r
  @param  Buffer                 The buffer to return the results in\r
\r
  @retval EFI_BUFFER_TOO_SMALL   Buffer too small, required buffer size is\r
                                 returned in BufferSize.\r
  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
  @retval EFI_SUCCESS            Successfully found the requested handle(s) and\r
                                 returns them in Buffer.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmLocateHandle (\r
  IN EFI_LOCATE_SEARCH_TYPE  SearchType,\r
  IN EFI_GUID                *Protocol   OPTIONAL,\r
  IN VOID                    *SearchKey  OPTIONAL,\r
  IN OUT UINTN               *BufferSize,\r
  OUT EFI_HANDLE             *Buffer\r
  );\r
\r
/**\r
  Return the first Protocol Interface that matches the Protocol GUID. If\r
  Registration is pasased in return a Protocol Instance that was just add\r
  to the system. If Registration is NULL return the first Protocol Interface\r
  you find.\r
\r
  @param  Protocol               The protocol to search for\r
  @param  Registration           Optional Registration Key returned from\r
                                 RegisterProtocolNotify()\r
  @param  Interface              Return the Protocol interface (instance).\r
\r
  @retval EFI_SUCCESS            If a valid Interface is returned\r
  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
  @retval EFI_NOT_FOUND          Protocol interface not found\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmLocateProtocol (\r
  IN  EFI_GUID  *Protocol,\r
  IN  VOID      *Registration OPTIONAL,\r
  OUT VOID      **Interface\r
  );\r
\r
/**\r
  Function returns an array of handles that support the requested protocol\r
  in a buffer allocated from pool. This is a version of SmmLocateHandle()\r
  that allocates a buffer for the caller.\r
\r
  @param  SearchType             Specifies which handle(s) are to be returned.\r
  @param  Protocol               Provides the protocol to search by.    This\r
                                 parameter is only valid for SearchType\r
                                 ByProtocol.\r
  @param  SearchKey              Supplies the search key depending on the\r
                                 SearchType.\r
  @param  NumberHandles          The number of handles returned in Buffer.\r
  @param  Buffer                 A pointer to the buffer to return the requested\r
                                 array of  handles that support Protocol.\r
\r
  @retval EFI_SUCCESS            The result array of handles was returned.\r
  @retval EFI_NOT_FOUND          No handles match the search.\r
  @retval EFI_OUT_OF_RESOURCES   There is not enough pool memory to store the\r
                                 matching results.\r
  @retval EFI_INVALID_PARAMETER  One or more parameters are not valid.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmLocateHandleBuffer (\r
  IN     EFI_LOCATE_SEARCH_TYPE  SearchType,\r
  IN     EFI_GUID                *Protocol OPTIONAL,\r
  IN     VOID                    *SearchKey OPTIONAL,\r
  IN OUT UINTN                   *NumberHandles,\r
  OUT    EFI_HANDLE              **Buffer\r
  );\r
\r
/**\r
  Manage SMI of a particular type.\r
\r
  @param  HandlerType    Points to the handler type or NULL for root SMI handlers.\r
  @param  Context        Points to an optional context buffer.\r
  @param  CommBuffer     Points to the optional communication buffer.\r
  @param  CommBufferSize Points to the size of the optional communication buffer.\r
\r
  @retval EFI_SUCCESS                        Interrupt source was processed successfully but not quiesced.\r
  @retval EFI_INTERRUPT_PENDING              One or more SMI sources could not be quiesced.\r
  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING  Interrupt source was not handled or quiesced.\r
  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED Interrupt source was handled and quiesced.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmiManage (\r
  IN     CONST EFI_GUID  *HandlerType,\r
  IN     CONST VOID      *Context         OPTIONAL,\r
  IN OUT VOID            *CommBuffer      OPTIONAL,\r
  IN OUT UINTN           *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  Registers a handler to execute within SMM.\r
\r
  @param  Handler        Handler service function pointer.\r
  @param  HandlerType    Points to the handler type or NULL for root SMI handlers.\r
  @param  DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.\r
\r
  @retval EFI_SUCCESS           Handler register success.\r
  @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmiHandlerRegister (\r
  IN   EFI_SMM_HANDLER_ENTRY_POINT2  Handler,\r
  IN   CONST EFI_GUID                *HandlerType  OPTIONAL,\r
  OUT  EFI_HANDLE                    *DispatchHandle\r
  );\r
\r
/**\r
  Unregister a handler in SMM.\r
\r
  @param  DispatchHandle  The handle that was specified when the handler was registered.\r
\r
  @retval EFI_SUCCESS           Handler function was successfully unregistered.\r
  @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmiHandlerUnRegister (\r
  IN  EFI_HANDLE  DispatchHandle\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmDriverDispatchHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmLegacyBootHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmReadyToLockHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmEndOfDxeHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmExitBootServicesHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  This function is the main entry point for an SMM handler dispatch\r
  or communicate-based callback.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmReadyToBootHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  Software SMI handler that is called when the S3SmmInitDone signal is triggered.\r
  This function installs the SMM S3SmmInitDone Protocol so SMM Drivers are informed that\r
  S3 SMM initialization has been done.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmS3SmmInitDoneHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  Software SMI handler that is called when the EndOfS3Resume event is trigged.\r
  This function installs the SMM EndOfS3Resume Protocol so SMM Drivers are informed that\r
  S3 resume has finished.\r
\r
  @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().\r
  @param  Context         Points to an optional handler context which was specified when the handler was registered.\r
  @param  CommBuffer      A pointer to a collection of data in memory that will\r
                          be conveyed from a non-SMM environment into an SMM environment.\r
  @param  CommBufferSize  The size of the CommBuffer.\r
\r
  @return Status Code\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmEndOfS3ResumeHandler (\r
  IN     EFI_HANDLE  DispatchHandle,\r
  IN     CONST VOID  *Context         OPTIONAL,\r
  IN OUT VOID        *CommBuffer      OPTIONAL,\r
  IN OUT UINTN       *CommBufferSize  OPTIONAL\r
  );\r
\r
/**\r
  Place holder function until all the SMM System Table Service are available.\r
\r
  @param  Arg1                   Undefined\r
  @param  Arg2                   Undefined\r
  @param  Arg3                   Undefined\r
  @param  Arg4                   Undefined\r
  @param  Arg5                   Undefined\r
\r
  @return EFI_NOT_AVAILABLE_YET\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmEfiNotAvailableYetArg5 (\r
  UINTN  Arg1,\r
  UINTN  Arg2,\r
  UINTN  Arg3,\r
  UINTN  Arg4,\r
  UINTN  Arg5\r
  );\r
\r
//\r
// Functions used during debug builds\r
//\r
\r
/**\r
  Traverse the discovered list for any drivers that were discovered but not loaded\r
  because the dependency expressions evaluated to false.\r
\r
**/\r
VOID\r
SmmDisplayDiscoveredNotDispatched (\r
  VOID\r
  );\r
\r
/**\r
  Add free SMRAM region for use by memory service.\r
\r
  @param  MemBase                Base address of memory region.\r
  @param  MemLength              Length of the memory region.\r
  @param  Type                   Memory type.\r
  @param  Attributes             Memory region state.\r
\r
**/\r
VOID\r
SmmAddMemoryRegion (\r
  IN      EFI_PHYSICAL_ADDRESS  MemBase,\r
  IN      UINT64                MemLength,\r
  IN      EFI_MEMORY_TYPE       Type,\r
  IN      UINT64                Attributes\r
  );\r
\r
/**\r
  Finds the protocol entry for the requested protocol.\r
\r
  @param  Protocol               The ID of the protocol\r
  @param  Create                 Create a new entry if not found\r
\r
  @return Protocol entry\r
\r
**/\r
PROTOCOL_ENTRY  *\r
SmmFindProtocolEntry (\r
  IN EFI_GUID  *Protocol,\r
  IN BOOLEAN   Create\r
  );\r
\r
/**\r
  Signal event for every protocol in protocol entry.\r
\r
  @param  Prot                   Protocol interface\r
\r
**/\r
VOID\r
SmmNotifyProtocol (\r
  IN PROTOCOL_INTERFACE  *Prot\r
  );\r
\r
/**\r
  Finds the protocol instance for the requested handle and protocol.\r
  Note: This function doesn't do parameters checking, it's caller's responsibility\r
  to pass in valid parameters.\r
\r
  @param  Handle                 The handle to search the protocol on\r
  @param  Protocol               GUID of the protocol\r
  @param  Interface              The interface for the protocol being searched\r
\r
  @return Protocol instance (NULL: Not found)\r
\r
**/\r
PROTOCOL_INTERFACE *\r
SmmFindProtocolInterface (\r
  IN IHANDLE   *Handle,\r
  IN EFI_GUID  *Protocol,\r
  IN VOID      *Interface\r
  );\r
\r
/**\r
  Removes Protocol from the protocol list (but not the handle list).\r
\r
  @param  Handle                 The handle to remove protocol on.\r
  @param  Protocol               GUID of the protocol to be moved\r
  @param  Interface              The interface of the protocol\r
\r
  @return Protocol Entry\r
\r
**/\r
PROTOCOL_INTERFACE *\r
SmmRemoveInterfaceFromProtocol (\r
  IN IHANDLE   *Handle,\r
  IN EFI_GUID  *Protocol,\r
  IN VOID      *Interface\r
  );\r
\r
/**\r
  This is the POSTFIX version of the dependency evaluator.  This code does\r
  not need to handle Before or After, as it is not valid to call this\r
  routine in this case. POSTFIX means all the math is done on top of the stack.\r
\r
  @param  DriverEntry           DriverEntry element to update.\r
\r
  @retval TRUE                  If driver is ready to run.\r
  @retval FALSE                 If driver is not ready to run or some fatal error\r
                                was found.\r
\r
**/\r
BOOLEAN\r
SmmIsSchedulable (\r
  IN  EFI_SMM_DRIVER_ENTRY  *DriverEntry\r
  );\r
\r
//\r
// SmramProfile\r
//\r
\r
/**\r
  Initialize SMRAM profile.\r
\r
**/\r
VOID\r
SmramProfileInit (\r
  VOID\r
  );\r
\r
/**\r
  Install SMRAM profile protocol.\r
\r
**/\r
VOID\r
SmramProfileInstallProtocol (\r
  VOID\r
  );\r
\r
/**\r
  Register SMM image to SMRAM profile.\r
\r
  @param DriverEntry    SMM image info.\r
  @param RegisterToDxe  Register image to DXE.\r
\r
  @return EFI_SUCCESS           Register successfully.\r
  @return EFI_UNSUPPORTED       Memory profile unsupported,\r
                                or memory profile for the image is not required.\r
  @return EFI_OUT_OF_RESOURCES  No enough resource for this register.\r
\r
**/\r
EFI_STATUS\r
RegisterSmramProfileImage (\r
  IN EFI_SMM_DRIVER_ENTRY  *DriverEntry,\r
  IN BOOLEAN               RegisterToDxe\r
  );\r
\r
/**\r
  Unregister image from SMRAM profile.\r
\r
  @param DriverEntry        SMM image info.\r
  @param UnregisterToDxe    Unregister image from DXE.\r
\r
  @return EFI_SUCCESS           Unregister successfully.\r
  @return EFI_UNSUPPORTED       Memory profile unsupported,\r
                                or memory profile for the image is not required.\r
  @return EFI_NOT_FOUND         The image is not found.\r
\r
**/\r
EFI_STATUS\r
UnregisterSmramProfileImage (\r
  IN EFI_SMM_DRIVER_ENTRY  *DriverEntry,\r
  IN BOOLEAN               UnregisterToDxe\r
  );\r
\r
/**\r
  Update SMRAM profile information.\r
\r
  @param CallerAddress  Address of caller who call Allocate or Free.\r
  @param Action         This Allocate or Free action.\r
  @param MemoryType     Memory type.\r
                        EfiMaxMemoryType means the MemoryType is unknown.\r
  @param Size           Buffer size.\r
  @param Buffer         Buffer address.\r
  @param ActionString   String for memory profile action.\r
                        Only needed for user defined allocate action.\r
\r
  @return EFI_SUCCESS           Memory profile is updated.\r
  @return EFI_UNSUPPORTED       Memory profile is unsupported,\r
                                or memory profile for the image is not required,\r
                                or memory profile for the memory type is not required.\r
  @return EFI_ACCESS_DENIED     It is during memory profile data getting.\r
  @return EFI_ABORTED           Memory profile recording is not enabled.\r
  @return EFI_OUT_OF_RESOURCES  No enough resource to update memory profile for allocate action.\r
  @return EFI_NOT_FOUND         No matched allocate info found for free action.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmCoreUpdateProfile (\r
  IN PHYSICAL_ADDRESS       CallerAddress,\r
  IN MEMORY_PROFILE_ACTION  Action,\r
  IN EFI_MEMORY_TYPE        MemoryType, // Valid for AllocatePages/AllocatePool\r
  IN UINTN                  Size,       // Valid for AllocatePages/FreePages/AllocatePool\r
  IN VOID                   *Buffer,\r
  IN CHAR8                  *ActionString OPTIONAL\r
  );\r
\r
/**\r
  Register SMRAM profile handler.\r
\r
**/\r
VOID\r
RegisterSmramProfileHandler (\r
  VOID\r
  );\r
\r
/**\r
  SMRAM profile ready to lock callback function.\r
\r
**/\r
VOID\r
SmramProfileReadyToLock (\r
  VOID\r
  );\r
\r
/**\r
  Initialize MemoryAttributes support.\r
**/\r
VOID\r
EFIAPI\r
SmmCoreInitializeMemoryAttributesTable (\r
  VOID\r
  );\r
\r
/**\r
  This function returns a copy of the current memory map. The map is an array of\r
  memory descriptors, each of which describes a contiguous block of memory.\r
\r
  @param[in, out]  MemoryMapSize          A pointer to the size, in bytes, of the\r
                                          MemoryMap buffer. On input, this is the size of\r
                                          the buffer allocated by the caller.  On output,\r
                                          it is the size of the buffer returned by the\r
                                          firmware  if the buffer was large enough, or the\r
                                          size of the buffer needed  to contain the map if\r
                                          the buffer was too small.\r
  @param[in, out]  MemoryMap              A pointer to the buffer in which firmware places\r
                                          the current memory map.\r
  @param[out]      MapKey                 A pointer to the location in which firmware\r
                                          returns the key for the current memory map.\r
  @param[out]      DescriptorSize         A pointer to the location in which firmware\r
                                          returns the size, in bytes, of an individual\r
                                          EFI_MEMORY_DESCRIPTOR.\r
  @param[out]      DescriptorVersion      A pointer to the location in which firmware\r
                                          returns the version number associated with the\r
                                          EFI_MEMORY_DESCRIPTOR.\r
\r
  @retval EFI_SUCCESS            The memory map was returned in the MemoryMap\r
                                 buffer.\r
  @retval EFI_BUFFER_TOO_SMALL   The MemoryMap buffer was too small. The current\r
                                 buffer size needed to hold the memory map is\r
                                 returned in MemoryMapSize.\r
  @retval EFI_INVALID_PARAMETER  One of the parameters has an invalid value.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmCoreGetMemoryMap (\r
  IN OUT UINTN                  *MemoryMapSize,\r
  IN OUT EFI_MEMORY_DESCRIPTOR  *MemoryMap,\r
  OUT UINTN                     *MapKey,\r
  OUT UINTN                     *DescriptorSize,\r
  OUT UINT32                    *DescriptorVersion\r
  );\r
\r
/**\r
  Initialize SmiHandler profile feature.\r
**/\r
VOID\r
SmmCoreInitializeSmiHandlerProfile (\r
  VOID\r
  );\r
\r
/**\r
  This function is called by SmmChildDispatcher module to report\r
  a new SMI handler is registered, to SmmCore.\r
\r
  @param This            The protocol instance\r
  @param HandlerGuid     The GUID to identify the type of the handler.\r
                         For the SmmChildDispatch protocol, the HandlerGuid\r
                         must be the GUID of SmmChildDispatch protocol.\r
  @param Handler         The SMI handler.\r
  @param CallerAddress   The address of the module who registers the SMI handler.\r
  @param Context         The context of the SMI handler.\r
                         For the SmmChildDispatch protocol, the Context\r
                         must match the one defined for SmmChildDispatch protocol.\r
  @param ContextSize     The size of the context in bytes.\r
                         For the SmmChildDispatch protocol, the Context\r
                         must match the one defined for SmmChildDispatch protocol.\r
\r
  @retval EFI_SUCCESS           The information is recorded.\r
  @retval EFI_OUT_OF_RESOURCES  There is no enough resource to record the information.\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmiHandlerProfileRegisterHandler (\r
  IN SMI_HANDLER_PROFILE_PROTOCOL  *This,\r
  IN EFI_GUID                      *HandlerGuid,\r
  IN EFI_SMM_HANDLER_ENTRY_POINT2  Handler,\r
  IN PHYSICAL_ADDRESS              CallerAddress,\r
  IN VOID                          *Context  OPTIONAL,\r
  IN UINTN                         ContextSize OPTIONAL\r
  );\r
\r
/**\r
  This function is called by SmmChildDispatcher module to report\r
  an existing SMI handler is unregistered, to SmmCore.\r
\r
  @param This            The protocol instance\r
  @param HandlerGuid     The GUID to identify the type of the handler.\r
                         For the SmmChildDispatch protocol, the HandlerGuid\r
                         must be the GUID of SmmChildDispatch protocol.\r
  @param Handler         The SMI handler.\r
  @param Context         The context of the SMI handler.\r
                         If it is NOT NULL, it will be used to check what is registered.\r
  @param ContextSize     The size of the context in bytes.\r
                         If Context is NOT NULL, it will be used to check what is registered.\r
\r
  @retval EFI_SUCCESS           The original record is removed.\r
  @retval EFI_NOT_FOUND         There is no record for the HandlerGuid and handler.\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmiHandlerProfileUnregisterHandler (\r
  IN SMI_HANDLER_PROFILE_PROTOCOL  *This,\r
  IN EFI_GUID                      *HandlerGuid,\r
  IN EFI_SMM_HANDLER_ENTRY_POINT2  Handler,\r
  IN VOID                          *Context  OPTIONAL,\r
  IN UINTN                         ContextSize OPTIONAL\r
  );\r
\r
extern UINTN                 mFullSmramRangeCount;\r
extern EFI_SMRAM_DESCRIPTOR  *mFullSmramRanges;\r
\r
extern EFI_SMM_DRIVER_ENTRY  *mSmmCoreDriverEntry;\r
\r
extern EFI_LOADED_IMAGE_PROTOCOL  *mSmmCoreLoadedImage;\r
\r
//\r
// Page management\r
//\r
\r
typedef struct {\r
  LIST_ENTRY    Link;\r
  UINTN         NumberOfPages;\r
} FREE_PAGE_LIST;\r
\r
extern LIST_ENTRY  mSmmMemoryMap;\r
\r
//\r
// Pool management\r
//\r
\r
//\r
// MIN_POOL_SHIFT must not be less than 5\r
//\r
#define MIN_POOL_SHIFT  6\r
#define MIN_POOL_SIZE   (1 << MIN_POOL_SHIFT)\r
\r
//\r
// MAX_POOL_SHIFT must not be less than EFI_PAGE_SHIFT - 1\r
//\r
#define MAX_POOL_SHIFT  (EFI_PAGE_SHIFT - 1)\r
#define MAX_POOL_SIZE   (1 << MAX_POOL_SHIFT)\r
\r
//\r
// MAX_POOL_INDEX are calculated by maximum and minimum pool sizes\r
//\r
#define MAX_POOL_INDEX  (MAX_POOL_SHIFT - MIN_POOL_SHIFT + 1)\r
\r
#define POOL_HEAD_SIGNATURE  SIGNATURE_32('s','p','h','d')\r
\r
typedef struct {\r
  UINT32             Signature;\r
  BOOLEAN            Available;\r
  EFI_MEMORY_TYPE    Type;\r
  UINTN              Size;\r
} POOL_HEADER;\r
\r
#define POOL_TAIL_SIGNATURE  SIGNATURE_32('s','p','t','l')\r
\r
typedef struct {\r
  UINT32    Signature;\r
  UINT32    Reserved;\r
  UINTN     Size;\r
} POOL_TAIL;\r
\r
#define POOL_OVERHEAD  (sizeof(POOL_HEADER) + sizeof(POOL_TAIL))\r
\r
#define HEAD_TO_TAIL(a)   \\r
  ((POOL_TAIL *) (((CHAR8 *) (a)) + (a)->Size - sizeof(POOL_TAIL)));\r
\r
typedef struct {\r
  POOL_HEADER    Header;\r
  LIST_ENTRY     Link;\r
} FREE_POOL_HEADER;\r
\r
typedef enum {\r
  SmmPoolTypeCode,\r
  SmmPoolTypeData,\r
  SmmPoolTypeMax,\r
} SMM_POOL_TYPE;\r
\r
extern LIST_ENTRY  mSmmPoolLists[SmmPoolTypeMax][MAX_POOL_INDEX];\r
\r
/**\r
  Internal Function. Allocate n pages from given free page node.\r
\r
  @param  Pages                  The free page node.\r
  @param  NumberOfPages          Number of pages to be allocated.\r
  @param  MaxAddress             Request to allocate memory below this address.\r
\r
  @return Memory address of allocated pages.\r
\r
**/\r
UINTN\r
InternalAllocPagesOnOneNode (\r
  IN OUT FREE_PAGE_LIST  *Pages,\r
  IN     UINTN           NumberOfPages,\r
  IN     UINTN           MaxAddress\r
  );\r
\r
/**\r
  Update SMM memory map entry.\r
\r
  @param[in]  Type                   The type of allocation to perform.\r
  @param[in]  Memory                 The base of memory address.\r
  @param[in]  NumberOfPages          The number of pages to allocate.\r
  @param[in]  AddRegion              If this memory is new added region.\r
**/\r
VOID\r
ConvertSmmMemoryMapEntry (\r
  IN EFI_MEMORY_TYPE       Type,\r
  IN EFI_PHYSICAL_ADDRESS  Memory,\r
  IN UINTN                 NumberOfPages,\r
  IN BOOLEAN               AddRegion\r
  );\r
\r
/**\r
  Internal function.  Moves any memory descriptors that are on the\r
  temporary descriptor stack to heap.\r
\r
**/\r
VOID\r
CoreFreeMemoryMapStack (\r
  VOID\r
  );\r
\r
/**\r
  Frees previous allocated pages.\r
\r
  @param[in]  Memory                 Base address of memory being freed.\r
  @param[in]  NumberOfPages          The number of pages to free.\r
  @param[in]  AddRegion              If this memory is new added region.\r
\r
  @retval EFI_NOT_FOUND          Could not find the entry that covers the range.\r
  @retval EFI_INVALID_PARAMETER  Address not aligned, Address is zero or NumberOfPages is zero.\r
  @return EFI_SUCCESS            Pages successfully freed.\r
\r
**/\r
EFI_STATUS\r
SmmInternalFreePagesEx (\r
  IN EFI_PHYSICAL_ADDRESS  Memory,\r
  IN UINTN                 NumberOfPages,\r
  IN BOOLEAN               AddRegion\r
  );\r
\r
/**\r
  Hook function used to set all Guard pages after entering SMM mode.\r
**/\r
VOID\r
SmmEntryPointMemoryManagementHook (\r
  VOID\r
  );\r
\r
#endif\r