PiSmmCore.h

Go to the documentation of this file.

 
#ifndef _SMM_CORE_H_
#define _SMM_CORE_H_
 
#include <PiSmm.h>
 
#include <Protocol/DxeSmmReadyToLock.h>
#include <Protocol/SmmReadyToLock.h>
#include <Protocol/SmmEndOfDxe.h>
#include <Protocol/CpuIo2.h>
#include <Protocol/SmmCommunication.h>
#include <Protocol/SmmAccess2.h>
#include <Protocol/FirmwareVolume2.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/DevicePath.h>
#include <Protocol/Security.h>
#include <Protocol/Security2.h>
#include <Protocol/SmmExitBootServices.h>
#include <Protocol/SmmLegacyBoot.h>
#include <Protocol/SmmReadyToBoot.h>
#include <Protocol/SmmMemoryAttribute.h>
#include <Protocol/SmmSxDispatch2.h>
 
#include <Guid/Apriori.h>
#include <Guid/EventGroup.h>
#include <Guid/EventLegacyBios.h>
#include <Guid/MemoryProfile.h>
#include <Guid/LoadModuleAtFixedAddress.h>
#include <Guid/SmiHandlerProfile.h>
#include <Guid/EndOfS3Resume.h>
#include <Guid/S3SmmInitDone.h>
 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/PeCoffLib.h>
#include <Library/PeCoffGetEntryPointLib.h>
#include <Library/CacheMaintenanceLib.h>
#include <Library/DebugLib.h>
#include <Library/ReportStatusCodeLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DevicePathLib.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/PcdLib.h>
#include <Library/SmmCorePlatformHookLib.h>
#include <Library/PerformanceLib.h>
#include <Library/HobLib.h>
#include <Library/SmmMemLib.h>
#include <Library/SafeIntLib.h>
 
#include "PiSmmCorePrivateData.h"
#include "HeapGuard.h"
 
//
// Used to build a table of SMI Handlers that the SMM Core registers
//
typedef struct {
  EFI_SMM_HANDLER_ENTRY_POINT2    Handler;
  EFI_GUID                        *HandlerType;
  EFI_HANDLE                      DispatchHandle;
  BOOLEAN                         UnRegister;
} SMM_CORE_SMI_HANDLERS;
 
//
// SMM_HANDLER - used for each SMM handler
//
 
#define SMI_ENTRY_SIGNATURE  SIGNATURE_32('s','m','i','e')
 
typedef struct {
  UINTN         Signature;
  LIST_ENTRY    AllEntries; // All entries
 
  EFI_GUID      HandlerType; // Type of interrupt
  LIST_ENTRY    SmiHandlers; // All handlers
} SMI_ENTRY;
 
#define SMI_HANDLER_SIGNATURE  SIGNATURE_32('s','m','i','h')
 
typedef struct {
  UINTN                           Signature;
  LIST_ENTRY                      Link;       // Link on SMI_ENTRY.SmiHandlers
  EFI_SMM_HANDLER_ENTRY_POINT2    Handler;    // The smm handler's entry point
  UINTN                           CallerAddr; // The address of caller who register the SMI handler.
  SMI_ENTRY                       *SmiEntry;
  VOID                            *Context;    // for profile
  UINTN                           ContextSize; // for profile
  BOOLEAN                         ToRemove;    // To remove this SMI_HANDLER later
} SMI_HANDLER;
 
//
// Structure for recording the state of an SMM Driver
//
#define EFI_SMM_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;
  EFI_DEVICE_PATH_PROTOCOL         *FvFileDevicePath;
  EFI_FIRMWARE_VOLUME2_PROTOCOL    *Fv;
 
  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 SMRAM
  //
  PHYSICAL_ADDRESS                 ImageEntryPoint;
  //
  // Image Buffer in SMRAM
  //
  PHYSICAL_ADDRESS                 ImageBuffer;
  //
  // Image Page Number
  //
  UINTN                            NumberOfPage;
  EFI_HANDLE                       SmmImageHandle;
  EFI_LOADED_IMAGE_PROTOCOL        SmmLoadedImage;
} EFI_SMM_DRIVER_ENTRY;
 
#define EFI_HANDLE_SIGNATURE  SIGNATURE_32('s','h','d','l')
 
typedef struct {
  UINTN         Signature;
  LIST_ENTRY    AllHandles;
  LIST_ENTRY    Protocols;
  UINTN         LocateRequest;
} IHANDLE;
 
#define ASSERT_IS_HANDLE(a)  ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)
 
#define PROTOCOL_ENTRY_SIGNATURE  SIGNATURE_32('s','p','t','e')
 
typedef struct {
  UINTN         Signature;
  LIST_ENTRY    AllEntries;
  EFI_GUID      ProtocolID;
  LIST_ENTRY    Protocols;
  LIST_ENTRY    Notify;
} PROTOCOL_ENTRY;
 
#define PROTOCOL_INTERFACE_SIGNATURE  SIGNATURE_32('s','p','i','f')
 
typedef struct {
  UINTN             Signature;
  LIST_ENTRY        Link;
  IHANDLE           *Handle;
  LIST_ENTRY        ByProtocol;
  PROTOCOL_ENTRY    *Protocol;
  VOID              *Interface;
} PROTOCOL_INTERFACE;
 
#define PROTOCOL_NOTIFY_SIGNATURE  SIGNATURE_32('s','p','t','n')
 
typedef struct {
  UINTN                Signature;
  PROTOCOL_ENTRY       *Protocol;
  LIST_ENTRY           Link;
  EFI_SMM_NOTIFY_FN    Function;
  LIST_ENTRY           *Position;
} PROTOCOL_NOTIFY;
 
//
// SMM Core Global Variables
//
extern SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate;
extern EFI_SMM_SYSTEM_TABLE2  gSmmCoreSmst;
extern LIST_ENTRY             gHandleList;
extern EFI_PHYSICAL_ADDRESS   gLoadModuleAtFixAddressSmramBase;
 
VOID
SmmInitializeMemoryServices (
  IN UINTN                 SmramRangeCount,
  IN EFI_SMRAM_DESCRIPTOR  *SmramRanges
  );
 
EFI_STATUS
EFIAPI
SmmInstallConfigurationTable (
  IN  CONST EFI_SMM_SYSTEM_TABLE2  *SystemTable,
  IN  CONST EFI_GUID               *Guid,
  IN  VOID                         *Table,
  IN  UINTN                        TableSize
  );
 
EFI_STATUS
EFIAPI
SmmInstallProtocolInterface (
  IN OUT EFI_HANDLE      *UserHandle,
  IN EFI_GUID            *Protocol,
  IN EFI_INTERFACE_TYPE  InterfaceType,
  IN VOID                *Interface
  );
 
EFI_STATUS
EFIAPI
SmmAllocatePages (
  IN      EFI_ALLOCATE_TYPE     Type,
  IN      EFI_MEMORY_TYPE       MemoryType,
  IN      UINTN                 NumberOfPages,
  OUT     EFI_PHYSICAL_ADDRESS  *Memory
  );
 
EFI_STATUS
EFIAPI
SmmInternalAllocatePages (
  IN      EFI_ALLOCATE_TYPE     Type,
  IN      EFI_MEMORY_TYPE       MemoryType,
  IN      UINTN                 NumberOfPages,
  OUT     EFI_PHYSICAL_ADDRESS  *Memory,
  IN      BOOLEAN               NeedGuard
  );
 
EFI_STATUS
EFIAPI
SmmFreePages (
  IN      EFI_PHYSICAL_ADDRESS  Memory,
  IN      UINTN                 NumberOfPages
  );
 
EFI_STATUS
EFIAPI
SmmInternalFreePages (
  IN      EFI_PHYSICAL_ADDRESS  Memory,
  IN      UINTN                 NumberOfPages,
  IN      BOOLEAN               IsGuarded
  );
 
EFI_STATUS
EFIAPI
SmmAllocatePool (
  IN      EFI_MEMORY_TYPE  PoolType,
  IN      UINTN            Size,
  OUT     VOID             **Buffer
  );
 
EFI_STATUS
EFIAPI
SmmInternalAllocatePool (
  IN      EFI_MEMORY_TYPE  PoolType,
  IN      UINTN            Size,
  OUT     VOID             **Buffer
  );
 
EFI_STATUS
EFIAPI
SmmFreePool (
  IN      VOID  *Buffer
  );
 
EFI_STATUS
EFIAPI
SmmInternalFreePool (
  IN      VOID  *Buffer
  );
 
EFI_STATUS
SmmInstallProtocolInterfaceNotify (
  IN OUT EFI_HANDLE      *UserHandle,
  IN EFI_GUID            *Protocol,
  IN EFI_INTERFACE_TYPE  InterfaceType,
  IN VOID                *Interface,
  IN BOOLEAN             Notify
  );
 
EFI_STATUS
EFIAPI
SmmUninstallProtocolInterface (
  IN EFI_HANDLE  UserHandle,
  IN EFI_GUID    *Protocol,
  IN VOID        *Interface
  );
 
EFI_STATUS
EFIAPI
SmmHandleProtocol (
  IN EFI_HANDLE  UserHandle,
  IN EFI_GUID    *Protocol,
  OUT VOID       **Interface
  );
 
EFI_STATUS
EFIAPI
SmmRegisterProtocolNotify (
  IN  CONST EFI_GUID     *Protocol,
  IN  EFI_SMM_NOTIFY_FN  Function,
  OUT VOID               **Registration
  );
 
EFI_STATUS
EFIAPI
SmmLocateHandle (
  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
EFIAPI
SmmLocateProtocol (
  IN  EFI_GUID  *Protocol,
  IN  VOID      *Registration OPTIONAL,
  OUT VOID      **Interface
  );
 
EFI_STATUS
EFIAPI
SmmLocateHandleBuffer (
  IN     EFI_LOCATE_SEARCH_TYPE  SearchType,
  IN     EFI_GUID                *Protocol OPTIONAL,
  IN     VOID                    *SearchKey OPTIONAL,
  IN OUT UINTN                   *NumberHandles,
  OUT    EFI_HANDLE              **Buffer
  );
 
EFI_STATUS
EFIAPI
SmiManage (
  IN     CONST EFI_GUID  *HandlerType,
  IN     CONST VOID      *Context         OPTIONAL,
  IN OUT VOID            *CommBuffer      OPTIONAL,
  IN OUT UINTN           *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmiHandlerRegister (
  IN   EFI_SMM_HANDLER_ENTRY_POINT2  Handler,
  IN   CONST EFI_GUID                *HandlerType  OPTIONAL,
  OUT  EFI_HANDLE                    *DispatchHandle
  );
 
EFI_STATUS
EFIAPI
SmiHandlerUnRegister (
  IN  EFI_HANDLE  DispatchHandle
  );
 
EFI_STATUS
EFIAPI
SmmDriverDispatchHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmLegacyBootHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmReadyToLockHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmEndOfDxeHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmExitBootServicesHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmReadyToBootHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmS3SmmInitDoneHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmEndOfS3ResumeHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmmEfiNotAvailableYetArg5 (
  UINTN  Arg1,
  UINTN  Arg2,
  UINTN  Arg3,
  UINTN  Arg4,
  UINTN  Arg5
  );
 
//
// Functions used during debug builds
//
 
VOID
SmmDisplayDiscoveredNotDispatched (
  VOID
  );
 
VOID
SmmAddMemoryRegion (
  IN      EFI_PHYSICAL_ADDRESS  MemBase,
  IN      UINT64                MemLength,
  IN      EFI_MEMORY_TYPE       Type,
  IN      UINT64                Attributes
  );
 
PROTOCOL_ENTRY  *
SmmFindProtocolEntry (
  IN EFI_GUID  *Protocol,
  IN BOOLEAN   Create
  );
 
VOID
SmmNotifyProtocol (
  IN PROTOCOL_INTERFACE  *Prot
  );
 
PROTOCOL_INTERFACE *
SmmFindProtocolInterface (
  IN IHANDLE   *Handle,
  IN EFI_GUID  *Protocol,
  IN VOID      *Interface
  );
 
PROTOCOL_INTERFACE *
SmmRemoveInterfaceFromProtocol (
  IN IHANDLE   *Handle,
  IN EFI_GUID  *Protocol,
  IN VOID      *Interface
  );
 
BOOLEAN
SmmIsSchedulable (
  IN  EFI_SMM_DRIVER_ENTRY  *DriverEntry
  );
 
//
// SmramProfile
//
 
VOID
SmramProfileInit (
  VOID
  );
 
VOID
SmramProfileInstallProtocol (
  VOID
  );
 
EFI_STATUS
RegisterSmramProfileImage (
  IN EFI_SMM_DRIVER_ENTRY  *DriverEntry,
  IN BOOLEAN               RegisterToDxe
  );
 
EFI_STATUS
UnregisterSmramProfileImage (
  IN EFI_SMM_DRIVER_ENTRY  *DriverEntry,
  IN BOOLEAN               UnregisterToDxe
  );
 
EFI_STATUS
EFIAPI
SmmCoreUpdateProfile (
  IN PHYSICAL_ADDRESS       CallerAddress,
  IN MEMORY_PROFILE_ACTION  Action,
  IN EFI_MEMORY_TYPE        MemoryType, // Valid for AllocatePages/AllocatePool
  IN UINTN                  Size,       // Valid for AllocatePages/FreePages/AllocatePool
  IN VOID                   *Buffer,
  IN CHAR8                  *ActionString OPTIONAL
  );
 
VOID
RegisterSmramProfileHandler (
  VOID
  );
 
VOID
SmramProfileReadyToLock (
  VOID
  );
 
VOID
EFIAPI
SmmCoreInitializeMemoryAttributesTable (
  VOID
  );
 
EFI_STATUS
EFIAPI
SmmCoreGetMemoryMap (
  IN OUT UINTN                  *MemoryMapSize,
  IN OUT EFI_MEMORY_DESCRIPTOR  *MemoryMap,
  OUT UINTN                     *MapKey,
  OUT UINTN                     *DescriptorSize,
  OUT UINT32                    *DescriptorVersion
  );
 
VOID
SmmCoreInitializeSmiHandlerProfile (
  VOID
  );
 
EFI_STATUS
EFIAPI
SmiHandlerProfileRegisterHandler (
  IN SMI_HANDLER_PROFILE_PROTOCOL  *This,
  IN EFI_GUID                      *HandlerGuid,
  IN EFI_SMM_HANDLER_ENTRY_POINT2  Handler,
  IN PHYSICAL_ADDRESS              CallerAddress,
  IN VOID                          *Context  OPTIONAL,
  IN UINTN                         ContextSize OPTIONAL
  );
 
EFI_STATUS
EFIAPI
SmiHandlerProfileUnregisterHandler (
  IN SMI_HANDLER_PROFILE_PROTOCOL  *This,
  IN EFI_GUID                      *HandlerGuid,
  IN EFI_SMM_HANDLER_ENTRY_POINT2  Handler,
  IN VOID                          *Context  OPTIONAL,
  IN UINTN                         ContextSize OPTIONAL
  );
 
extern UINTN                 mFullSmramRangeCount;
extern EFI_SMRAM_DESCRIPTOR  *mFullSmramRanges;
 
extern EFI_SMM_DRIVER_ENTRY  *mSmmCoreDriverEntry;
 
extern EFI_LOADED_IMAGE_PROTOCOL  *mSmmCoreLoadedImage;
 
//
// Page management
//
 
typedef struct {
  LIST_ENTRY    Link;
  UINTN         NumberOfPages;
} FREE_PAGE_LIST;
 
extern LIST_ENTRY  mSmmMemoryMap;
 
//
// 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)
 
#define POOL_HEAD_SIGNATURE  SIGNATURE_32('s','p','h','d')
 
typedef struct {
  UINT32             Signature;
  BOOLEAN            Available;
  EFI_MEMORY_TYPE    Type;
  UINTN              Size;
} POOL_HEADER;
 
#define POOL_TAIL_SIGNATURE  SIGNATURE_32('s','p','t','l')
 
typedef struct {
  UINT32    Signature;
  UINT32    Reserved;
  UINTN     Size;
} POOL_TAIL;
 
#define POOL_OVERHEAD  (sizeof(POOL_HEADER) + sizeof(POOL_TAIL))
 
#define HEAD_TO_TAIL(a)   \
  ((POOL_TAIL *) (((CHAR8 *) (a)) + (a)->Size - sizeof(POOL_TAIL)));
 
typedef struct {
  POOL_HEADER    Header;
  LIST_ENTRY     Link;
} FREE_POOL_HEADER;
 
typedef enum {
  SmmPoolTypeCode,
  SmmPoolTypeData,
  SmmPoolTypeMax,
} SMM_POOL_TYPE;
 
extern LIST_ENTRY  mSmmPoolLists[SmmPoolTypeMax][MAX_POOL_INDEX];
 
UINTN
InternalAllocPagesOnOneNode (
  IN OUT FREE_PAGE_LIST  *Pages,
  IN     UINTN           NumberOfPages,
  IN     UINTN           MaxAddress
  );
 
VOID
ConvertSmmMemoryMapEntry (
  IN EFI_MEMORY_TYPE       Type,
  IN EFI_PHYSICAL_ADDRESS  Memory,
  IN UINTN                 NumberOfPages,
  IN BOOLEAN               AddRegion
  );
 
VOID
CoreFreeMemoryMapStack (
  VOID
  );
 
EFI_STATUS
SmmInternalFreePagesEx (
  IN EFI_PHYSICAL_ADDRESS  Memory,
  IN UINTN                 NumberOfPages,
  IN BOOLEAN               AddRegion
  );
 
VOID
SmmEntryPointMemoryManagementHook (
  VOID
  );
 
#endif