StandaloneMmCore.h

Go to the documentation of this file.

 
#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/MmCommunication2.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 <Guid/MmCommBuffer.h>
#include <Guid/PiSmmMemoryAttributesTable.h>
 
#include <Library/StandaloneMmCoreEntryPoint.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/HobPrintLib.h>
#include <Library/ImagePropertiesRecordLib.h>
#include <Library/PeCoffGetEntryPointLib.h>
#include <Library/StandaloneMmMemLib.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_FIRMWARE_VOLUME_HEADER    *FwVolHeader;
  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')
 
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('p','r','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('p','i','f','c')
 
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('p','r','t','n')
 
typedef struct {
  UINTN               Signature;
  PROTOCOL_ENTRY      *Protocol;
  LIST_ENTRY          Link;
  EFI_MM_NOTIFY_FN    Function;
  LIST_ENTRY          *Position;
} PROTOCOL_NOTIFY;
 
//
// MM Core Global Variables
//
extern EFI_MM_SYSTEM_TABLE         gMmCoreMmst;
extern LIST_ENTRY                  gHandleList;
extern BOOLEAN                     mMmEntryPointRegistered;
extern EFI_FIRMWARE_VOLUME_HEADER  *mBfv;
 
VOID
MmInitializeMemoryServices (
  IN UINTN                 MmramRangeCount,
  IN EFI_MMRAM_DESCRIPTOR  *MmramRanges
  );
 
EFI_STATUS
EFIAPI
MmInstallConfigurationTable (
  IN  CONST EFI_MM_SYSTEM_TABLE  *SystemTable,
  IN  CONST EFI_GUID             *Guid,
  IN  VOID                       *Table,
  IN  UINTN                      TableSize
  );
 
EFI_STATUS
EFIAPI
MmInstallProtocolInterface (
  IN OUT EFI_HANDLE      *UserHandle,
  IN EFI_GUID            *Protocol,
  IN EFI_INTERFACE_TYPE  InterfaceType,
  IN VOID                *Interface
  );
 
EFI_STATUS
EFIAPI
MmAllocatePages (
  IN      EFI_ALLOCATE_TYPE     Type,
  IN      EFI_MEMORY_TYPE       MemoryType,
  IN      UINTN                 NumberOfPages,
  OUT     EFI_PHYSICAL_ADDRESS  *Memory
  );
 
EFI_STATUS
EFIAPI
MmInternalAllocatePages (
  IN      EFI_ALLOCATE_TYPE     Type,
  IN      EFI_MEMORY_TYPE       MemoryType,
  IN      UINTN                 NumberOfPages,
  OUT     EFI_PHYSICAL_ADDRESS  *Memory
  );
 
EFI_STATUS
EFIAPI
MmFreePages (
  IN      EFI_PHYSICAL_ADDRESS  Memory,
  IN      UINTN                 NumberOfPages
  );
 
EFI_STATUS
EFIAPI
MmInternalFreePages (
  IN      EFI_PHYSICAL_ADDRESS  Memory,
  IN      UINTN                 NumberOfPages
  );
 
EFI_STATUS
EFIAPI
MmAllocatePool (
  IN      EFI_MEMORY_TYPE  PoolType,
  IN      UINTN            Size,
  OUT     VOID             **Buffer
  );
 
EFI_STATUS
EFIAPI
MmInternalAllocatePool (
  IN      EFI_MEMORY_TYPE  PoolType,
  IN      UINTN            Size,
  OUT     VOID             **Buffer
  );
 
EFI_STATUS
EFIAPI
MmFreePool (
  IN      VOID  *Buffer
  );
 
EFI_STATUS
EFIAPI
MmInternalFreePool (
  IN      VOID  *Buffer
  );
 
EFI_STATUS
MmInstallProtocolInterfaceNotify (
  IN OUT EFI_HANDLE      *UserHandle,
  IN EFI_GUID            *Protocol,
  IN EFI_INTERFACE_TYPE  InterfaceType,
  IN VOID                *Interface,
  IN BOOLEAN             Notify
  );
 
EFI_STATUS
EFIAPI
MmUninstallProtocolInterface (
  IN EFI_HANDLE  UserHandle,
  IN EFI_GUID    *Protocol,
  IN VOID        *Interface
  );
 
EFI_STATUS
EFIAPI
MmHandleProtocol (
  IN EFI_HANDLE  UserHandle,
  IN EFI_GUID    *Protocol,
  OUT VOID       **Interface
  );
 
EFI_STATUS
EFIAPI
MmRegisterProtocolNotify (
  IN  CONST EFI_GUID    *Protocol,
  IN  EFI_MM_NOTIFY_FN  Function,
  OUT VOID              **Registration
  );
 
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
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
EFIAPI
MmLocateProtocol (
  IN  EFI_GUID  *Protocol,
  IN  VOID      *Registration OPTIONAL,
  OUT VOID      **Interface
  );
 
EFI_STATUS
EFIAPI
MmiManage (
  IN     CONST EFI_GUID  *HandlerType,
  IN     CONST VOID      *Context         OPTIONAL,
  IN OUT VOID            *CommBuffer      OPTIONAL,
  IN OUT UINTN           *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
MmiHandlerRegister (
  IN   EFI_MM_HANDLER_ENTRY_POINT  Handler,
  IN   CONST EFI_GUID              *HandlerType  OPTIONAL,
  OUT  EFI_HANDLE                  *DispatchHandle
  );
 
EFI_STATUS
EFIAPI
MmiHandlerUnRegister (
  IN  EFI_HANDLE  DispatchHandle
  );
 
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
EFIAPI
MmExitBootServiceHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
EFI_STATUS
EFIAPI
MmReadyToBootHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
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
EFIAPI
MmEndOfPeiHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  );
 
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
EFIAPI
MmEfiNotAvailableYetArg5 (
  UINTN  Arg1,
  UINTN  Arg2,
  UINTN  Arg3,
  UINTN  Arg4,
  UINTN  Arg5
  );
 
//
// Functions used during debug builds
//
 
VOID
MmDisplayDiscoveredNotDispatched (
  VOID
  );
 
VOID
MmAddMemoryRegion (
  IN      EFI_PHYSICAL_ADDRESS  MemBase,
  IN      UINT64                MemLength,
  IN      EFI_MEMORY_TYPE       Type,
  IN      UINT64                Attributes
  );
 
PROTOCOL_ENTRY  *
MmFindProtocolEntry (
  IN EFI_GUID  *Protocol,
  IN BOOLEAN   Create
  );
 
VOID
MmNotifyProtocol (
  IN PROTOCOL_INTERFACE  *Prot
  );
 
PROTOCOL_INTERFACE *
MmFindProtocolInterface (
  IN IHANDLE   *Handle,
  IN EFI_GUID  *Protocol,
  IN VOID      *Interface
  );
 
PROTOCOL_INTERFACE *
MmRemoveInterfaceFromProtocol (
  IN IHANDLE   *Handle,
  IN EFI_GUID  *Protocol,
  IN VOID      *Interface
  );
 
BOOLEAN
MmIsSchedulable (
  IN  EFI_MM_DRIVER_ENTRY  *DriverEntry
  );
 
VOID
DumpMmramInfo (
  VOID
  );
 
EFI_STATUS
MmCoreFfsFindMmDriver (
  IN  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader,
  IN  UINT32                      Depth
  );
 
#define NEXT_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \
  ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) + (Size)))
 
VOID
EFIAPI
MmCoreInitializeMemoryAttributesTable (
  VOID
  );
 
EFI_STATUS
EFIAPI
MmCoreGetMemoryMap (
  IN OUT UINTN                  *MemoryMapSize,
  IN OUT EFI_MEMORY_DESCRIPTOR  *MemoryMap,
  OUT UINTN                     *MapKey,
  OUT UINTN                     *DescriptorSize,
  OUT UINT32                    *DescriptorVersion
  );
 
#endif