SmmPeriodicSmiLib.c

Go to the documentation of this file.

 
#include <PiSmm.h>
 
#include <Protocol/SmmPeriodicTimerDispatch2.h>
 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/SynchronizationLib.h>
#include <Library/DebugLib.h>
#include <Library/TimerLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/SmmServicesTableLib.h>
 
#include <Library/SmmPeriodicSmiLib.h>
 
#define PERIODIC_SMI_LIBRARY_ALLOCATE_SIZE  0x08
 
#define PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE  SIGNATURE_32 ('P', 'S', 'M', 'I')
 
typedef struct {
  UINT32                                     Signature;
  LIST_ENTRY                                 Link;
  PERIODIC_SMI_LIBRARY_HANDLER               DispatchFunction;
  VOID                                       *Context;
  UINT64                                     TickPeriod;
  UINTN                                      Cpu;
  UINTN                                      StackSize;
  VOID                                       *Stack;
  SPIN_LOCK                                  DispatchLock;
  UINT64                                     PerfomanceCounterRate;
  UINT64                                     PerfomanceCounterStartValue;
  UINT64                                     PerfomanceCounterEndValue;
  EFI_SMM_PERIODIC_TIMER_REGISTER_CONTEXT    RegisterContext;
  EFI_HANDLE                                 DispatchHandle;
  UINT64                                     DispatchTotalTime;
  UINT64                                     DispatchCheckPointTime;
  BASE_LIBRARY_JUMP_BUFFER                   DispatchJumpBuffer;
  BOOLEAN                                    YieldFlag;
  BASE_LIBRARY_JUMP_BUFFER                   YieldJumpBuffer;
  UINT64                                     ElapsedTime;
} PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT;
 
#define PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK(a)             \
  CR (                                                                \
    a,                                                                \
    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT,                             \
    Link,                                                             \
    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE                    \
    )
 
EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  *gSmmPeriodicTimerDispatch2 = NULL;
 
UINT64  *gSmiTickPeriodTable = NULL;
 
LIST_ENTRY  gFreePeriodicSmiLibraryHandlers =
  INITIALIZE_LIST_HEAD_VARIABLE (gFreePeriodicSmiLibraryHandlers);
 
LIST_ENTRY  gPeriodicSmiLibraryHandlers =
  INITIALIZE_LIST_HEAD_VARIABLE (gPeriodicSmiLibraryHandlers);
 
PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *gActivePeriodicSmiLibraryHandler = NULL;
 
PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
GetActivePeriodicSmiLibraryHandler (
  VOID
  )
{
  return gActivePeriodicSmiLibraryHandler;
}
 
PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
LookupPeriodicSmiLibraryHandler (
  IN EFI_HANDLE  DispatchHandle    OPTIONAL
  )
{
  LIST_ENTRY                            *Link;
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // If DispatchHandle is NULL, then return the active periodic SMI handler
  //
  if (DispatchHandle == NULL) {
    return GetActivePeriodicSmiLibraryHandler ();
  }
 
  //
  // Search the periodic SMI handler entries for a a matching DispatchHandle
  //
  for ( Link = GetFirstNode (&gPeriodicSmiLibraryHandlers)
        ; !IsNull (&gPeriodicSmiLibraryHandlers, Link)
        ; Link = GetNextNode (&gPeriodicSmiLibraryHandlers, Link)
        )
  {
    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
 
    if (PeriodicSmiLibraryHandler->DispatchHandle == DispatchHandle) {
      return PeriodicSmiLibraryHandler;
    }
  }
 
  //
  // No entries match DispatchHandle, so return NULL
  //
  return NULL;
}
 
PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
SetActivePeriodicSmiLibraryHandler (
  IN EFI_HANDLE  DispatchHandle    OPTIONAL
  )
{
  if (DispatchHandle == NULL) {
    gActivePeriodicSmiLibraryHandler = NULL;
  } else {
    gActivePeriodicSmiLibraryHandler = LookupPeriodicSmiLibraryHandler (DispatchHandle);
  }
 
  return gActivePeriodicSmiLibraryHandler;
}
 
VOID
ReclaimPeriodicSmiLibraryHandler (
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler
  )
{
  ASSERT (PeriodicSmiLibraryHandler->DispatchHandle == NULL);
  if (PeriodicSmiLibraryHandler->Stack != NULL) {
    FreePages (
      PeriodicSmiLibraryHandler->Stack,
      EFI_SIZE_TO_PAGES (PeriodicSmiLibraryHandler->StackSize)
      );
    PeriodicSmiLibraryHandler->Stack = NULL;
  }
 
  RemoveEntryList (&PeriodicSmiLibraryHandler->Link);
  InsertHeadList (&gFreePeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
}
 
BOOLEAN
EnlargeFreePeriodicSmiLibraryHandlerList (
  VOID
  )
{
  UINTN                                 Index;
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // Add the entries to the list
  //
  for (Index = 0; Index < PERIODIC_SMI_LIBRARY_ALLOCATE_SIZE; Index++) {
    PeriodicSmiLibraryHandler = AllocatePool (sizeof (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT));
    if (PeriodicSmiLibraryHandler == NULL) {
      break;
    }
 
    PeriodicSmiLibraryHandler->Signature = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE;
    InsertHeadList (&gFreePeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
  }
 
  return (BOOLEAN)(Index > 0);
}
 
PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
FindFreePeriodicSmiLibraryHandler (
  VOID
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  if (IsListEmpty (&gFreePeriodicSmiLibraryHandlers)) {
    if (!EnlargeFreePeriodicSmiLibraryHandlerList ()) {
      return NULL;
    }
  }
 
  //
  // Get one from the list of free periodic SMI handlers.
  //
  PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (
                                GetFirstNode (&gFreePeriodicSmiLibraryHandlers)
                                );
  RemoveEntryList (&PeriodicSmiLibraryHandler->Link);
  InsertTailList (&gPeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
 
  return PeriodicSmiLibraryHandler;
}
 
UINT64 *
EFIAPI
PeriodicSmiSupportedTickPeriod (
  VOID
  )
{
  //
  // Return the table allocated and populated by SmmPeriodicSmiLibConstructor()
  //
  return gSmiTickPeriodTable;
}
 
UINT64
EFIAPI
PeriodicSmiExecutionTime (
  VOID
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
  UINT64                                Current;
  UINT64                                Count;
 
  //
  // If there is no active periodic SMI handler, then return 0
  //
  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
  if (PeriodicSmiLibraryHandler == NULL) {
    return 0;
  }
 
  //
  // Get the current performance counter value
  //
  Current = GetPerformanceCounter ();
 
  //
  // Count the number of performance counter ticks since the periodic SMI handler
  // was dispatched or the last time this function was called.
  //
  if (PeriodicSmiLibraryHandler->PerfomanceCounterEndValue > PeriodicSmiLibraryHandler->PerfomanceCounterStartValue) {
    //
    // The performance counter counts up.  Check for roll over condition.
    //
    if (Current > PeriodicSmiLibraryHandler->DispatchCheckPointTime) {
      Count = Current - PeriodicSmiLibraryHandler->DispatchCheckPointTime;
    } else {
      Count = (Current - PeriodicSmiLibraryHandler->PerfomanceCounterStartValue) + (PeriodicSmiLibraryHandler->PerfomanceCounterEndValue - PeriodicSmiLibraryHandler->DispatchCheckPointTime);
    }
  } else {
    //
    // The performance counter counts down.  Check for roll over condition.
    //
    if (PeriodicSmiLibraryHandler->DispatchCheckPointTime > Current) {
      Count = PeriodicSmiLibraryHandler->DispatchCheckPointTime - Current;
    } else {
      Count = (PeriodicSmiLibraryHandler->DispatchCheckPointTime - PeriodicSmiLibraryHandler->PerfomanceCounterEndValue) + (PeriodicSmiLibraryHandler->PerfomanceCounterStartValue - Current);
    }
  }
 
  //
  // Accumulate the total number of performance counter ticks since the periodic
  // SMI handler was dispatched or resumed.
  //
  PeriodicSmiLibraryHandler->DispatchTotalTime += Count;
 
  //
  // Update the checkpoint value to the current performance counter value
  //
  PeriodicSmiLibraryHandler->DispatchCheckPointTime = Current;
 
  //
  // Convert the total number of performance counter ticks to 100 ns units
  //
  return DivU64x64Remainder (
           MultU64x32 (PeriodicSmiLibraryHandler->DispatchTotalTime, 10000000),
           PeriodicSmiLibraryHandler->PerfomanceCounterRate,
           NULL
           );
}
 
VOID
EFIAPI
PeriodicSmiExit (
  VOID
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // If there is no active periodic SMI handler, then return
  //
  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
  if (PeriodicSmiLibraryHandler == NULL) {
    return;
  }
 
  //
  // Perform a long jump back to the point when the currently executing dispatch
  // function was dispatched.
  //
  LongJump (&PeriodicSmiLibraryHandler->DispatchJumpBuffer, 1);
 
  //
  // Must never return
  //
  ASSERT (FALSE);
  CpuDeadLoop ();
}
 
UINT64
EFIAPI
PeriodicSmiYield (
  VOID
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
  UINTN                                 SetJumpFlag;
 
  //
  // If there is no active periodic SMI handler, then return
  //
  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
  if (PeriodicSmiLibraryHandler == NULL) {
    return 0;
  }
 
  //
  // If PeriodicSmiYield() is called without an allocated stack, then just return
  // immediately with an elapsed time of 0.
  //
  if (PeriodicSmiLibraryHandler->Stack == NULL) {
    return 0;
  }
 
  //
  // Set a flag so the next periodic SMI event will resume at where SetJump()
  // is called below.
  //
  PeriodicSmiLibraryHandler->YieldFlag = TRUE;
 
  //
  // Save context in YieldJumpBuffer
  //
  SetJumpFlag = SetJump (&PeriodicSmiLibraryHandler->YieldJumpBuffer);
  if (SetJumpFlag == 0) {
    //
    // The initial call to SetJump() always returns 0.
    // If this is the initial call, then exit the current periodic SMI handler
    //
    PeriodicSmiExit ();
  }
 
  //
  // We get here when a LongJump is performed from PeriodicSmiDispatchFunctionOnCpu()
  // to resume a periodic SMI handler that called PeriodicSmiYield() on the
  // previous time this periodic SMI handler was dispatched.
  //
  // Clear the flag so the next periodic SMI dispatch will not resume.
  //
  PeriodicSmiLibraryHandler->YieldFlag = FALSE;
 
  //
  // Return the amount elapsed time that occurred while yielded
  //
  return PeriodicSmiLibraryHandler->ElapsedTime;
}
 
VOID
EFIAPI
PeriodicSmiDispatchFunctionSwitchStack (
  IN VOID  *Context1   OPTIONAL,
  IN VOID  *Context2   OPTIONAL
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // Convert Context1 to PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
  //
  PeriodicSmiLibraryHandler = (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *)Context1;
 
  //
  // Dispatch the registered handler passing in the context that was registered
  // and the amount of time that has elapsed since the previous time this
  // periodic SMI handler was dispatched.
  //
  PeriodicSmiLibraryHandler->DispatchFunction (
                               PeriodicSmiLibraryHandler->Context,
                               PeriodicSmiLibraryHandler->ElapsedTime
                               );
 
  //
  // If this DispatchFunction() returns, then unconditionally call PeriodicSmiExit()
  // to perform a LongJump() back to PeriodicSmiDispatchFunctionOnCpu(). The
  // LongJump() will resume execution on the original stack.
  //
  PeriodicSmiExit ();
}
 
VOID
EFIAPI
PeriodicSmiDispatchFunctionOnCpu (
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler
  )
{
  //
  // Save context in DispatchJumpBuffer.  The initial call to SetJump() always
  // returns 0.  If this is the initial call, then either resume from a prior
  // call to PeriodicSmiYield() or call the DispatchFunction registered in
  // PeriodicSmiEnable() using an allocated stack if one was specified.
  //
  if (SetJump (&PeriodicSmiLibraryHandler->DispatchJumpBuffer) != 0) {
    return;
  }
 
  //
  // Capture the performance counter value just before the periodic SMI handler
  // is resumed so the amount of time the periodic SMI handler executes can be
  // calculated.
  //
  PeriodicSmiLibraryHandler->DispatchTotalTime      = 0;
  PeriodicSmiLibraryHandler->DispatchCheckPointTime = GetPerformanceCounter ();
 
  if (PeriodicSmiLibraryHandler->YieldFlag) {
    //
    // Perform a long jump back to the point where the previously dispatched
    // function called PeriodicSmiYield().
    //
    LongJump (&PeriodicSmiLibraryHandler->YieldJumpBuffer, 1);
  } else if (PeriodicSmiLibraryHandler->Stack == NULL) {
    //
    // If Stack is NULL then call DispatchFunction using current stack passing
    // in the context that was registered and the amount of time that has
    // elapsed since the previous time this periodic SMI handler was dispatched.
    //
    PeriodicSmiLibraryHandler->DispatchFunction (
                                 PeriodicSmiLibraryHandler->Context,
                                 PeriodicSmiLibraryHandler->ElapsedTime
                                 );
 
    //
    // If this DispatchFunction() returns, then unconditionally call PeriodicSmiExit()
    // to perform a LongJump() back to this function.
    //
    PeriodicSmiExit ();
  } else {
    //
    // If Stack is not NULL then call DispatchFunction switching to the allocated stack
    //
    SwitchStack (
      PeriodicSmiDispatchFunctionSwitchStack,
      PeriodicSmiLibraryHandler,
      NULL,
      (UINT8 *)PeriodicSmiLibraryHandler->Stack + PeriodicSmiLibraryHandler->StackSize
      );
  }
 
  //
  // Must never return
  //
  ASSERT (FALSE);
  CpuDeadLoop ();
}
 
VOID
EFIAPI
PeriodicSmiDispatchFunctionWithLock (
  IN OUT VOID  *Buffer
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // Get context
  //
  PeriodicSmiLibraryHandler = (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *)Buffer;
 
  //
  // Execute dispatch function on the currently executing logical CPU
  //
  PeriodicSmiDispatchFunctionOnCpu (PeriodicSmiLibraryHandler);
 
  //
  // Release the dispatch spin lock
  //
  ReleaseSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
}
 
EFI_STATUS
EFIAPI
PeriodicSmiDispatchFunction (
  IN EFI_HANDLE  DispatchHandle,
  IN CONST VOID  *Context         OPTIONAL,
  IN OUT VOID    *CommBuffer      OPTIONAL,
  IN OUT UINTN   *CommBufferSize  OPTIONAL
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
  EFI_SMM_PERIODIC_TIMER_CONTEXT        *TimerContext;
  EFI_STATUS                            Status;
 
  //
  // Set the active periodic SMI handler
  //
  PeriodicSmiLibraryHandler = SetActivePeriodicSmiLibraryHandler (DispatchHandle);
  if (PeriodicSmiLibraryHandler == NULL) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Retrieve the elapsed time since the last time this periodic SMI handler was called
  //
  PeriodicSmiLibraryHandler->ElapsedTime = 0;
  if (CommBuffer != NULL) {
    TimerContext                           = (EFI_SMM_PERIODIC_TIMER_CONTEXT  *)CommBuffer;
    PeriodicSmiLibraryHandler->ElapsedTime = TimerContext->ElapsedTime;
  }
 
  //
  // Dispatch the periodic SMI handler
  //
  if ((PeriodicSmiLibraryHandler->Cpu == PERIODIC_SMI_LIBRARY_ANY_CPU) ||
      (PeriodicSmiLibraryHandler->Cpu == gSmst->CurrentlyExecutingCpu))
  {
    //
    // Dispatch on the currently execution CPU if the CPU specified in PeriodicSmiEnable()
    // was PERIODIC_SMI_LIBRARY_ANY_CPU or the currently executing CPU matches the CPU
    // that was specified in PeriodicSmiEnable().
    //
    PeriodicSmiDispatchFunctionOnCpu (PeriodicSmiLibraryHandler);
  } else {
    //
    // Acquire spin lock for ths periodic SMI handler.  The AP will release the
    // spin lock when it is done executing the periodic SMI handler.
    //
    AcquireSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
 
    //
    // Execute the periodic SMI handler on the CPU that was specified in
    // PeriodicSmiEnable().
    //
    Status = gSmst->SmmStartupThisAp (
                      PeriodicSmiDispatchFunctionWithLock,
                      PeriodicSmiLibraryHandler->Cpu,
                      PeriodicSmiLibraryHandler
                      );
    if (!EFI_ERROR (Status)) {
      //
      // Wait for the AP to release the spin lock.
      //
      while (!AcquireSpinLockOrFail (&PeriodicSmiLibraryHandler->DispatchLock)) {
        CpuPause ();
      }
    }
 
    //
    // Release the spin lock for the periodic SMI handler.
    //
    ReleaseSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
  }
 
  //
  // Reclaim the active periodic SMI handler if it was disabled during the current dispatch.
  //
  if (PeriodicSmiLibraryHandler->DispatchHandle == NULL) {
    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
  }
 
  //
  // Update state to show that there is no active periodic SMI handler
  //
  SetActivePeriodicSmiLibraryHandler (NULL);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PeriodicSmiEnable (
  IN OUT EFI_HANDLE                    *DispatchHandle     OPTIONAL,
  IN     PERIODIC_SMI_LIBRARY_HANDLER  DispatchFunction,
  IN     CONST VOID                    *Context            OPTIONAL,
  IN     UINT64                        TickPeriod,
  IN     UINTN                         Cpu,
  IN     UINTN                         StackSize
  )
{
  EFI_STATUS                            Status;
  UINTN                                 Index;
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // Make sure all the input parameters are valid
  //
  if (DispatchFunction == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  for (Index = 0; gSmiTickPeriodTable[Index] != 0; Index++) {
    if (gSmiTickPeriodTable[Index] == TickPeriod) {
      break;
    }
  }
 
  if (gSmiTickPeriodTable[Index] == 0) {
    return EFI_UNSUPPORTED;
  }
 
  if ((Cpu != PERIODIC_SMI_LIBRARY_ANY_CPU) && (Cpu >= gSmst->NumberOfCpus)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Find a free periodic SMI handler entry
  //
  PeriodicSmiLibraryHandler = FindFreePeriodicSmiLibraryHandler ();
  if (PeriodicSmiLibraryHandler == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Initialize a new periodic SMI handler entry
  //
  PeriodicSmiLibraryHandler->YieldFlag        = FALSE;
  PeriodicSmiLibraryHandler->DispatchHandle   = NULL;
  PeriodicSmiLibraryHandler->DispatchFunction = DispatchFunction;
  PeriodicSmiLibraryHandler->Context          = (VOID *)Context;
  PeriodicSmiLibraryHandler->Cpu              = Cpu;
  PeriodicSmiLibraryHandler->StackSize        = ALIGN_VALUE (StackSize, EFI_PAGE_SIZE);
  if (PeriodicSmiLibraryHandler->StackSize > 0) {
    PeriodicSmiLibraryHandler->Stack = AllocatePages (EFI_SIZE_TO_PAGES (PeriodicSmiLibraryHandler->StackSize));
    if (PeriodicSmiLibraryHandler->Stack == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    ZeroMem (PeriodicSmiLibraryHandler->Stack, PeriodicSmiLibraryHandler->StackSize);
  } else {
    PeriodicSmiLibraryHandler->Stack = NULL;
  }
 
  InitializeSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
  PeriodicSmiLibraryHandler->PerfomanceCounterRate = GetPerformanceCounterProperties (
                                                       &PeriodicSmiLibraryHandler->PerfomanceCounterStartValue,
                                                       &PeriodicSmiLibraryHandler->PerfomanceCounterEndValue
                                                       );
  PeriodicSmiLibraryHandler->RegisterContext.Period          = TickPeriod;
  PeriodicSmiLibraryHandler->RegisterContext.SmiTickInterval = TickPeriod;
  Status                                                     = gSmmPeriodicTimerDispatch2->Register (
                                                                                             gSmmPeriodicTimerDispatch2,
                                                                                             PeriodicSmiDispatchFunction,
                                                                                             &PeriodicSmiLibraryHandler->RegisterContext,
                                                                                             &PeriodicSmiLibraryHandler->DispatchHandle
                                                                                             );
  if (EFI_ERROR (Status)) {
    PeriodicSmiLibraryHandler->DispatchHandle = NULL;
    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Return the registered handle if the optional DispatchHandle parameter is not NULL
  //
  if (DispatchHandle != NULL) {
    *DispatchHandle = PeriodicSmiLibraryHandler->DispatchHandle;
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
EFIAPI
PeriodicSmiDisable (
  IN EFI_HANDLE  DispatchHandle    OPTIONAL
  )
{
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
  EFI_STATUS                            Status;
 
  //
  // Lookup the periodic SMI handler specified by DispatchHandle
  //
  PeriodicSmiLibraryHandler = LookupPeriodicSmiLibraryHandler (DispatchHandle);
  if (PeriodicSmiLibraryHandler == NULL) {
    return FALSE;
  }
 
  //
  // Unregister the periodic SMI handler from the SMM Periodic Timer Dispatch 2 Protocol
  //
  Status = gSmmPeriodicTimerDispatch2->UnRegister (
                                         gSmmPeriodicTimerDispatch2,
                                         PeriodicSmiLibraryHandler->DispatchHandle
                                         );
  if (EFI_ERROR (Status)) {
    return FALSE;
  }
 
  //
  // Mark the entry for the disabled periodic SMI handler as free, and
  // call ReclaimPeriodicSmiLibraryHandler to move it to the list of free
  // periodic SMI handlers.
  //
  PeriodicSmiLibraryHandler->DispatchHandle = NULL;
  if (PeriodicSmiLibraryHandler != GetActivePeriodicSmiLibraryHandler ()) {
    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
  }
 
  return TRUE;
}
 
EFI_STATUS
EFIAPI
SmmPeriodicSmiLibConstructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
  UINT64      *SmiTickInterval;
  UINTN       Count;
 
  //
  // Locate the SMM Periodic Timer Dispatch 2 Protocol
  //
  Status = gSmst->SmmLocateProtocol (
                    &gEfiSmmPeriodicTimerDispatch2ProtocolGuid,
                    NULL,
                    (VOID **)&gSmmPeriodicTimerDispatch2
                    );
  ASSERT_EFI_ERROR (Status);
  ASSERT (gSmmPeriodicTimerDispatch2 != NULL);
 
  //
  // Count the number of periodic SMI tick intervals that the SMM Periodic Timer
  // Dispatch 2 Protocol supports.
  //
  SmiTickInterval = NULL;
  Count           = 0;
  do {
    Status = gSmmPeriodicTimerDispatch2->GetNextShorterInterval (
                                           gSmmPeriodicTimerDispatch2,
                                           &SmiTickInterval
                                           );
    Count++;
  } while (SmiTickInterval != NULL);
 
  //
  // Allocate a buffer for the table of supported periodic SMI tick periods.
  //
  gSmiTickPeriodTable = AllocateZeroPool (Count * sizeof (UINT64));
  ASSERT (gSmiTickPeriodTable != NULL);
 
  //
  // Fill in the table of supported periodic SMI tick periods.
  //
  SmiTickInterval = NULL;
  Count           = 0;
  do {
    gSmiTickPeriodTable[Count] = 0;
    Status                     = gSmmPeriodicTimerDispatch2->GetNextShorterInterval (
                                                               gSmmPeriodicTimerDispatch2,
                                                               &SmiTickInterval
                                                               );
    if (SmiTickInterval != NULL) {
      gSmiTickPeriodTable[Count] = *SmiTickInterval;
    }
 
    Count++;
  } while (SmiTickInterval != NULL);
 
  //
  // Allocate buffer for initial set of periodic SMI handlers
  //
  EnlargeFreePeriodicSmiLibraryHandlerList ();
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SmmPeriodicSmiLibDestructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  LIST_ENTRY                            *Link;
  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
 
  //
  // Free the table of supported periodic SMI tick rates
  //
  if (gSmiTickPeriodTable != NULL) {
    FreePool (gSmiTickPeriodTable);
  }
 
  //
  // Disable all periodic SMI handlers
  //
  for (Link = GetFirstNode (&gPeriodicSmiLibraryHandlers); !IsNull (&gPeriodicSmiLibraryHandlers, Link);) {
    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
    Link                      = GetNextNode (&gPeriodicSmiLibraryHandlers, Link);
    PeriodicSmiDisable (PeriodicSmiLibraryHandler->DispatchHandle);
  }
 
  //
  // Free all the periodic SMI handler entries
  //
  for (Link = GetFirstNode (&gFreePeriodicSmiLibraryHandlers); !IsNull (&gFreePeriodicSmiLibraryHandlers, Link);) {
    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
    Link                      = RemoveEntryList (Link);
    FreePool (PeriodicSmiLibraryHandler);
  }
 
  return EFI_SUCCESS;
}