EventHandle.c

Go to the documentation of this file.

 
#include <Base.h>
#include <Pi/PiMmCis.h>
 
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/HobLib.h>
 
#include <Protocol/DebugSupport.h> // for EFI_SYSTEM_CONTEXT
 
#include <Guid/ZeroGuid.h>
#include <Guid/MmramMemoryReserve.h>
 
#include <StandaloneMmCpu.h>
 
EFI_STATUS
EFIAPI
MmFoundationEntryRegister (
  IN CONST EFI_MM_CONFIGURATION_PROTOCOL  *This,
  IN EFI_MM_ENTRY_POINT                   MmEntryPoint
  );
 
//
// On ARM platforms every event is expected to have a GUID associated with
// it. It will be used by the MM Entry point to find the handler for the
// event. It will either be populated in a EFI_MM_COMMUNICATE_HEADER by the
// caller of the event (e.g. MM_COMMUNICATE SMC) or by the CPU driver
// (e.g. during an asynchronous event). In either case, this context is
// maintained in an array which has an entry for each CPU. The pointer to this
// array is held in PerCpuGuidedEventContext. Memory is allocated once the
// number of CPUs in the system are made known through the
// MP_INFORMATION_HOB_DATA.
//
EFI_MM_COMMUNICATE_HEADER  **PerCpuGuidedEventContext = NULL;
 
// Descriptor with whereabouts of memory used for communication with the normal world
EFI_MMRAM_DESCRIPTOR  mNsCommBuffer;
EFI_MMRAM_DESCRIPTOR  mSCommBuffer;
 
MP_INFORMATION_HOB_DATA  *mMpInformationHobData;
 
EFI_MM_CONFIGURATION_PROTOCOL  mMmConfig = {
  0,
  MmFoundationEntryRegister
};
 
STATIC EFI_MM_ENTRY_POINT  mMmEntryPoint = NULL;
 
STATIC
EFI_STATUS
CheckBufferAddr (
  IN UINTN  BufferAddr
  )
{
  UINT64  NsCommBufferEnd;
  UINT64  SCommBufferEnd;
  UINT64  CommBufferEnd;
 
  NsCommBufferEnd = mNsCommBuffer.PhysicalStart + mNsCommBuffer.PhysicalSize;
  SCommBufferEnd  = mSCommBuffer.PhysicalStart + mSCommBuffer.PhysicalSize;
 
  if ((BufferAddr >= mNsCommBuffer.PhysicalStart) &&
      (BufferAddr < NsCommBufferEnd))
  {
    CommBufferEnd = NsCommBufferEnd;
  } else if ((BufferAddr >= mSCommBuffer.PhysicalStart) &&
             (BufferAddr < SCommBufferEnd))
  {
    CommBufferEnd = SCommBufferEnd;
  } else {
    return EFI_ACCESS_DENIED;
  }
 
  if ((CommBufferEnd - BufferAddr) < sizeof (EFI_MM_COMMUNICATE_HEADER)) {
    return EFI_ACCESS_DENIED;
  }
 
  // perform bounds check.
  if ((CommBufferEnd - BufferAddr - sizeof (EFI_MM_COMMUNICATE_HEADER)) <
      ((EFI_MM_COMMUNICATE_HEADER *)BufferAddr)->MessageLength)
  {
    return EFI_ACCESS_DENIED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PiMmStandaloneMmCpuDriverEntry (
  IN UINTN  EventId,
  IN UINTN  CpuNumber,
  IN UINTN  NsCommBufferAddr
  )
{
  EFI_MM_COMMUNICATE_HEADER  *GuidedEventContext;
  EFI_MM_ENTRY_CONTEXT       MmEntryPointContext;
  EFI_STATUS                 Status;
  UINTN                      NsCommBufferSize;
 
  DEBUG ((DEBUG_INFO, "Received event - 0x%x on cpu %d\n", EventId, CpuNumber));
 
  Status = EFI_SUCCESS;
 
  // Perform parameter validation of NsCommBufferAddr
  if (NsCommBufferAddr == (UINTN)NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = CheckBufferAddr (NsCommBufferAddr);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Check Buffer failed: %r\n", Status));
    return Status;
  }
 
  // Find out the size of the buffer passed
  NsCommBufferSize = ((EFI_MM_COMMUNICATE_HEADER *)NsCommBufferAddr)->MessageLength +
                     sizeof (EFI_MM_COMMUNICATE_HEADER);
 
  GuidedEventContext = NULL;
  // Now that the secure world can see the normal world buffer, allocate
  // memory to copy the communication buffer to the secure world.
  Status = mMmst->MmAllocatePool (
                    EfiRuntimeServicesData,
                    NsCommBufferSize,
                    (VOID **)&GuidedEventContext
                    );
 
  if (Status != EFI_SUCCESS) {
    DEBUG ((DEBUG_ERROR, "Mem alloc failed - 0x%x\n", EventId));
    return EFI_OUT_OF_RESOURCES;
  }
 
  // X1 contains the VA of the normal world memory accessible from
  // secure world.
  CopyMem (GuidedEventContext, (CONST VOID *)NsCommBufferAddr, NsCommBufferSize);
 
  // Stash the pointer to the allocated Event Context for this CPU
  PerCpuGuidedEventContext[CpuNumber] = GuidedEventContext;
 
  ZeroMem (&MmEntryPointContext, sizeof (EFI_MM_ENTRY_CONTEXT));
 
  MmEntryPointContext.CurrentlyExecutingCpu = CpuNumber;
  MmEntryPointContext.NumberOfCpus          = mMpInformationHobData->NumberOfProcessors;
 
  // Populate the MM system table with MP and state information
  mMmst->CurrentlyExecutingCpu = CpuNumber;
  mMmst->NumberOfCpus          = mMpInformationHobData->NumberOfProcessors;
  mMmst->CpuSaveStateSize      = 0;
  mMmst->CpuSaveState          = NULL;
 
  if (mMmEntryPoint == NULL) {
    DEBUG ((DEBUG_ERROR, "Mm Entry point Not Found\n"));
    return EFI_UNSUPPORTED;
  }
 
  mMmEntryPoint (&MmEntryPointContext);
 
  // Free the memory allocation done earlier and reset the per-cpu context
  ASSERT (GuidedEventContext);
  CopyMem ((VOID *)NsCommBufferAddr, (CONST VOID *)GuidedEventContext, NsCommBufferSize);
 
  Status = mMmst->MmFreePool ((VOID *)GuidedEventContext);
  if (Status != EFI_SUCCESS) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  PerCpuGuidedEventContext[CpuNumber] = NULL;
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MmFoundationEntryRegister (
  IN CONST EFI_MM_CONFIGURATION_PROTOCOL  *This,
  IN EFI_MM_ENTRY_POINT                   MmEntryPoint
  )
{
  // store the entry point in a global
  mMmEntryPoint = MmEntryPoint;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PiMmCpuTpFwRootMmiHandler (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *Context         OPTIONAL,
  IN OUT VOID        *CommBuffer      OPTIONAL,
  IN OUT UINTN       *CommBufferSize  OPTIONAL
  )
{
  EFI_STATUS  Status;
  UINTN       CpuNumber;
 
  ASSERT (Context == NULL);
  ASSERT (CommBuffer == NULL);
  ASSERT (CommBufferSize == NULL);
 
  CpuNumber = mMmst->CurrentlyExecutingCpu;
  if (PerCpuGuidedEventContext[CpuNumber] == NULL) {
    return EFI_NOT_FOUND;
  }
 
  DEBUG ((
    DEBUG_INFO,
    "CommBuffer - 0x%x, CommBufferSize - 0x%x\n",
    PerCpuGuidedEventContext[CpuNumber],
    PerCpuGuidedEventContext[CpuNumber]->MessageLength
    ));
 
  Status = mMmst->MmiManage (
                    &PerCpuGuidedEventContext[CpuNumber]->HeaderGuid,
                    NULL,
                    PerCpuGuidedEventContext[CpuNumber]->Data,
                    &PerCpuGuidedEventContext[CpuNumber]->MessageLength
                    );
 
  if (Status != EFI_SUCCESS) {
    DEBUG ((DEBUG_WARN, "Unable to manage Guided Event - %d\n", Status));
  }
 
  return Status;
}