SmmCpuSyncLib.c

Go to the documentation of this file.

 
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/SafeIntLib.h>
#include <Library/SmmCpuSyncLib.h>
#include <Library/SynchronizationLib.h>
#include <Uefi.h>
 
typedef volatile UINT32 SMM_CPU_SYNC_SEMAPHORE;
 
typedef struct {
  SMM_CPU_SYNC_SEMAPHORE    *Run;
} SMM_CPU_SYNC_SEMAPHORE_FOR_EACH_CPU;
 
struct SMM_CPU_SYNC_CONTEXT  {
  UINTN                                  NumberOfCpus;
  VOID                                   *SemBuffer;
  UINTN                                  SemBufferPages;
  UINTN                                  ArrivedCpuCountUponLock;
  SMM_CPU_SYNC_SEMAPHORE                 *CpuCount;
  SMM_CPU_SYNC_SEMAPHORE_FOR_EACH_CPU    CpuSem[];
};
 
STATIC
UINT32
InternalWaitForSemaphore (
  IN OUT  volatile UINT32  *Sem
  )
{
  UINT32  Value;
 
  for ( ; ;) {
    Value = *Sem;
    if (Value == MAX_UINT32) {
      return Value;
    }
 
    if ((Value != 0) &&
        (InterlockedCompareExchange32 (
           (UINT32 *)Sem,
           Value,
           Value - 1
           ) == Value))
    {
      break;
    }
 
    CpuPause ();
  }
 
  return Value - 1;
}
 
STATIC
UINT32
InternalReleaseSemaphore (
  IN OUT  volatile UINT32  *Sem
  )
{
  UINT32  Value;
 
  do {
    Value = *Sem;
  } while (Value + 1 != 0 &&
           InterlockedCompareExchange32 (
             (UINT32 *)Sem,
             Value,
             Value + 1
             ) != Value);
 
  if (Value == MAX_UINT32) {
    return Value;
  }
 
  return Value + 1;
}
 
STATIC
UINT32
InternalLockdownSemaphore (
  IN OUT  volatile UINT32  *Sem
  )
{
  UINT32  Value;
 
  do {
    Value = *Sem;
  } while (InterlockedCompareExchange32 (
             (UINT32 *)Sem,
             Value,
             (UINT32)-1
             ) != Value);
 
  return Value;
}
 
RETURN_STATUS
EFIAPI
SmmCpuSyncContextInit (
  IN   UINTN                 NumberOfCpus,
  OUT  SMM_CPU_SYNC_CONTEXT  **Context
  )
{
  RETURN_STATUS                        Status;
  UINTN                                ContextSize;
  UINTN                                OneSemSize;
  UINTN                                NumSem;
  UINTN                                TotalSemSize;
  UINTN                                SemAddr;
  UINTN                                CpuIndex;
  SMM_CPU_SYNC_SEMAPHORE_FOR_EACH_CPU  *CpuSem;
 
  ASSERT (Context != NULL);
 
  //
  // Calculate ContextSize
  //
  Status = SafeUintnMult (NumberOfCpus, sizeof (SMM_CPU_SYNC_SEMAPHORE_FOR_EACH_CPU), &ContextSize);
  if (RETURN_ERROR (Status)) {
    return Status;
  }
 
  Status = SafeUintnAdd (ContextSize, sizeof (SMM_CPU_SYNC_CONTEXT), &ContextSize);
  if (RETURN_ERROR (Status)) {
    return Status;
  }
 
  //
  // Allocate Buffer for Context
  //
  *Context = AllocatePool (ContextSize);
  if (*Context == NULL) {
    return RETURN_OUT_OF_RESOURCES;
  }
 
  (*Context)->ArrivedCpuCountUponLock = 0;
 
  //
  // Save NumberOfCpus
  //
  (*Context)->NumberOfCpus = NumberOfCpus;
 
  //
  // Calculate total semaphore size
  //
  OneSemSize = GetSpinLockProperties ();
  ASSERT (sizeof (SMM_CPU_SYNC_SEMAPHORE) <= OneSemSize);
 
  Status = SafeUintnAdd (1, NumberOfCpus, &NumSem);
  if (RETURN_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Status = SafeUintnMult (NumSem, OneSemSize, &TotalSemSize);
  if (RETURN_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Allocate for Semaphores in the *Context
  //
  (*Context)->SemBufferPages = EFI_SIZE_TO_PAGES (TotalSemSize);
  (*Context)->SemBuffer      = AllocatePages ((*Context)->SemBufferPages);
  if ((*Context)->SemBuffer == NULL) {
    Status = RETURN_OUT_OF_RESOURCES;
    goto ON_ERROR;
  }
 
  //
  // Assign Global Semaphore pointer
  //
  SemAddr               = (UINTN)(*Context)->SemBuffer;
  (*Context)->CpuCount  = (SMM_CPU_SYNC_SEMAPHORE *)SemAddr;
  *(*Context)->CpuCount = 0;
 
  SemAddr += OneSemSize;
 
  //
  // Assign CPU Semaphore pointer
  //
  CpuSem = (*Context)->CpuSem;
  for (CpuIndex = 0; CpuIndex < NumberOfCpus; CpuIndex++) {
    CpuSem->Run  = (SMM_CPU_SYNC_SEMAPHORE *)SemAddr;
    *CpuSem->Run = 0;
 
    CpuSem++;
    SemAddr += OneSemSize;
  }
 
  return RETURN_SUCCESS;
 
ON_ERROR:
  FreePool (*Context);
  return Status;
}
 
VOID
EFIAPI
SmmCpuSyncContextDeinit (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context
  )
{
  ASSERT (Context != NULL);
 
  FreePages (Context->SemBuffer, Context->SemBufferPages);
 
  FreePool (Context);
}
 
VOID
EFIAPI
SmmCpuSyncContextReset (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context
  )
{
  ASSERT (Context != NULL);
 
  Context->ArrivedCpuCountUponLock = 0;
  *Context->CpuCount               = 0;
}
 
UINTN
EFIAPI
SmmCpuSyncGetArrivedCpuCount (
  IN  SMM_CPU_SYNC_CONTEXT  *Context
  )
{
  UINT32  Value;
 
  ASSERT (Context != NULL);
 
  Value = *Context->CpuCount;
 
  if (Value == (UINT32)-1) {
    return Context->ArrivedCpuCountUponLock;
  }
 
  return Value;
}
 
RETURN_STATUS
EFIAPI
SmmCpuSyncCheckInCpu (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  //
  // Check to return if CpuCount has already been locked.
  //
  if (InternalReleaseSemaphore (Context->CpuCount) == MAX_UINT32) {
    return RETURN_ABORTED;
  }
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
SmmCpuSyncCheckOutCpu (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  if (InternalWaitForSemaphore (Context->CpuCount) == MAX_UINT32) {
    return RETURN_ABORTED;
  }
 
  return RETURN_SUCCESS;
}
 
VOID
EFIAPI
SmmCpuSyncLockDoor (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex,
  OUT UINTN                    *CpuCount
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (CpuCount != NULL);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  //
  // Temporarily record the CpuCount into the ArrivedCpuCountUponLock before lock door.
  // Recording before lock door is to avoid the Context->CpuCount is locked but possible
  // Context->ArrivedCpuCountUponLock is not updated.
  //
  Context->ArrivedCpuCountUponLock = *Context->CpuCount;
 
  //
  // Lock door operation
  //
  *CpuCount = InternalLockdownSemaphore (Context->CpuCount);
 
  //
  // Update the ArrivedCpuCountUponLock
  //
  Context->ArrivedCpuCountUponLock = *CpuCount;
}
 
VOID
EFIAPI
SmmCpuSyncWaitForAPs (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 NumberOfAPs,
  IN     UINTN                 BspIndex
  )
{
  UINTN  Arrived;
 
  ASSERT (Context != NULL);
 
  ASSERT (NumberOfAPs < Context->NumberOfCpus);
 
  ASSERT (BspIndex < Context->NumberOfCpus);
 
  for (Arrived = 0; Arrived < NumberOfAPs; Arrived++) {
    InternalWaitForSemaphore (Context->CpuSem[BspIndex].Run);
  }
}
 
VOID
EFIAPI
SmmCpuSyncReleaseOneAp   (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex,
  IN     UINTN                 BspIndex
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (BspIndex != CpuIndex);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  ASSERT (BspIndex < Context->NumberOfCpus);
 
  InternalReleaseSemaphore (Context->CpuSem[CpuIndex].Run);
}
 
VOID
EFIAPI
SmmCpuSyncWaitForBsp (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex,
  IN     UINTN                 BspIndex
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (BspIndex != CpuIndex);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  ASSERT (BspIndex < Context->NumberOfCpus);
 
  InternalWaitForSemaphore (Context->CpuSem[CpuIndex].Run);
}
 
VOID
EFIAPI
SmmCpuSyncReleaseBsp (
  IN OUT SMM_CPU_SYNC_CONTEXT  *Context,
  IN     UINTN                 CpuIndex,
  IN     UINTN                 BspIndex
  )
{
  ASSERT (Context != NULL);
 
  ASSERT (BspIndex != CpuIndex);
 
  ASSERT (CpuIndex < Context->NumberOfCpus);
 
  ASSERT (BspIndex < Context->NumberOfCpus);
 
  InternalReleaseSemaphore (Context->CpuSem[BspIndex].Run);
}