Mmi.c

Go to the documentation of this file.

 
#include "StandaloneMmCore.h"
 
//
// MM_HANDLER_STATE_NOTIFIER
//
 
//
// MM_HANDLER - used for each MM handler
//
 
#define MMI_ENTRY_SIGNATURE  SIGNATURE_32('m','m','i','e')
 
typedef struct {
  UINTN         Signature;
  LIST_ENTRY    AllEntries; // All entries
 
  EFI_GUID      HandlerType; // Type of interrupt
  LIST_ENTRY    MmiHandlers; // All handlers
} MMI_ENTRY;
 
#define MMI_HANDLER_SIGNATURE  SIGNATURE_32('m','m','i','h')
 
typedef struct {
  UINTN                         Signature;
  LIST_ENTRY                    Link;        // Link on MMI_ENTRY.MmiHandlers
  EFI_MM_HANDLER_ENTRY_POINT    Handler;     // The mm handler's entry point
  MMI_ENTRY                     *MmiEntry;
  BOOLEAN                       ToRemove;    // To remove this MMI_HANDLER later
} MMI_HANDLER;
 
//
// mMmiManageCallingDepth is used to track the depth of recursive calls of MmiManage.
//
UINTN  mMmiManageCallingDepth = 0;
 
LIST_ENTRY  mRootMmiHandlerList = INITIALIZE_LIST_HEAD_VARIABLE (mRootMmiHandlerList);
LIST_ENTRY  mMmiEntryList       = INITIALIZE_LIST_HEAD_VARIABLE (mMmiEntryList);
 
BOOLEAN
RemoveMmiHandler (
  IN MMI_HANDLER  *MmiHandler,
  IN MMI_ENTRY    *MmiEntry
  )
{
  ASSERT (MmiHandler->ToRemove);
  RemoveEntryList (&MmiHandler->Link);
  FreePool (MmiHandler);
 
  //
  // Remove the MMI_ENTRY if all handlers have been removed.
  //
  if (MmiEntry != NULL) {
    if (IsListEmpty (&MmiEntry->MmiHandlers)) {
      RemoveEntryList (&MmiEntry->AllEntries);
      FreePool (MmiEntry);
      return TRUE;
    }
  }
 
  return FALSE;
}
 
MMI_ENTRY  *
EFIAPI
MmCoreFindMmiEntry (
  IN EFI_GUID  *HandlerType,
  IN BOOLEAN   Create
  )
{
  LIST_ENTRY  *Link;
  MMI_ENTRY   *Item;
  MMI_ENTRY   *MmiEntry;
 
  //
  // Search the MMI entry list for the matching GUID
  //
  MmiEntry = NULL;
  for (Link = mMmiEntryList.ForwardLink;
       Link != &mMmiEntryList;
       Link = Link->ForwardLink)
  {
    Item = CR (Link, MMI_ENTRY, AllEntries, MMI_ENTRY_SIGNATURE);
    if (CompareGuid (&Item->HandlerType, HandlerType)) {
      //
      // This is the MMI entry
      //
      MmiEntry = Item;
      break;
    }
  }
 
  //
  // If the protocol entry was not found and Create is TRUE, then
  // allocate a new entry
  //
  if ((MmiEntry == NULL) && Create) {
    MmiEntry = AllocatePool (sizeof (MMI_ENTRY));
    if (MmiEntry != NULL) {
      //
      // Initialize new MMI entry structure
      //
      MmiEntry->Signature = MMI_ENTRY_SIGNATURE;
      CopyGuid ((VOID *)&MmiEntry->HandlerType, HandlerType);
      InitializeListHead (&MmiEntry->MmiHandlers);
 
      //
      // Add it to MMI entry list
      //
      InsertTailList (&mMmiEntryList, &MmiEntry->AllEntries);
    }
  }
 
  return MmiEntry;
}
 
EFI_STATUS
EFIAPI
MmiManage (
  IN     CONST EFI_GUID  *HandlerType,
  IN     CONST VOID      *Context         OPTIONAL,
  IN OUT VOID            *CommBuffer      OPTIONAL,
  IN OUT UINTN           *CommBufferSize  OPTIONAL
  )
{
  LIST_ENTRY   *Link;
  LIST_ENTRY   *Head;
  LIST_ENTRY   *EntryLink;
  MMI_ENTRY    *MmiEntry;
  MMI_HANDLER  *MmiHandler;
  EFI_STATUS   ReturnStatus;
  BOOLEAN      WillReturn;
  EFI_STATUS   Status;
 
  mMmiManageCallingDepth++;
  WillReturn   = FALSE;
  Status       = EFI_NOT_FOUND;
  ReturnStatus = Status;
  if (HandlerType == NULL) {
    //
    // Root MMI handler
    //
 
    Head = &mRootMmiHandlerList;
  } else {
    //
    // Non-root MMI handler
    //
    MmiEntry = MmCoreFindMmiEntry ((EFI_GUID *)HandlerType, FALSE);
    if (MmiEntry == NULL) {
      //
      // There is no handler registered for this interrupt source
      //
      return Status;
    }
 
    Head = &MmiEntry->MmiHandlers;
  }
 
  for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
    MmiHandler = CR (Link, MMI_HANDLER, Link, MMI_HANDLER_SIGNATURE);
 
    Status = MmiHandler->Handler (
                           (EFI_HANDLE)MmiHandler,
                           Context,
                           CommBuffer,
                           CommBufferSize
                           );
 
    switch (Status) {
      case EFI_INTERRUPT_PENDING:
        //
        // If a handler returns EFI_INTERRUPT_PENDING and HandlerType is not NULL then
        // no additional handlers will be processed and EFI_INTERRUPT_PENDING will be returned.
        //
        if (HandlerType != NULL) {
          ReturnStatus = EFI_INTERRUPT_PENDING;
          WillReturn   = TRUE;
        } else {
          //
          // If any other handler's result sets ReturnStatus as EFI_SUCCESS, the return status
          // will be EFI_SUCCESS.
          //
          if (ReturnStatus != EFI_SUCCESS) {
            ReturnStatus = Status;
          }
        }
 
        break;
 
      case EFI_SUCCESS:
        //
        // If at least one of the handlers returns EFI_SUCCESS then the function will return
        // EFI_SUCCESS. If a handler returns EFI_SUCCESS and HandlerType is not NULL then no
        // additional handlers will be processed.
        //
        if (HandlerType != NULL) {
          WillReturn = TRUE;
        }
 
        ReturnStatus = EFI_SUCCESS;
        break;
 
      case EFI_WARN_INTERRUPT_SOURCE_QUIESCED:
        //
        // If at least one of the handlers returns EFI_WARN_INTERRUPT_SOURCE_QUIESCED
        // then the function will return EFI_SUCCESS.
        //
        ReturnStatus = EFI_SUCCESS;
        break;
 
      case EFI_WARN_INTERRUPT_SOURCE_PENDING:
        //
        // If all the handlers returned EFI_WARN_INTERRUPT_SOURCE_PENDING
        // then EFI_WARN_INTERRUPT_SOURCE_PENDING will be returned.
        //
        if (ReturnStatus != EFI_SUCCESS) {
          ReturnStatus = Status;
        }
 
        break;
 
      default:
        //
        // Unexpected status code returned.
        //
        ASSERT_EFI_ERROR (Status);
        break;
    }
 
    if (WillReturn) {
      break;
    }
  }
 
  ASSERT (mMmiManageCallingDepth > 0);
  mMmiManageCallingDepth--;
 
  //
  // MmiHandlerUnRegister() calls from MMI handlers are deferred till this point.
  // Before returned from MmiManage, delete the MmiHandler which is
  // marked as ToRemove.
  // Note that MmiManage can be called recursively.
  //
  if (mMmiManageCallingDepth == 0) {
    //
    // Go through all MmiHandler in root Mmi handlers
    //
    for ( Link = GetFirstNode (&mRootMmiHandlerList)
          ; !IsNull (&mRootMmiHandlerList, Link);
          )
    {
      //
      // MmiHandler might be removed in below, so cache the next link in Link
      //
      MmiHandler = CR (Link, MMI_HANDLER, Link, MMI_HANDLER_SIGNATURE);
      Link       = GetNextNode (&mRootMmiHandlerList, Link);
      if (MmiHandler->ToRemove) {
        //
        // Remove MmiHandler if the ToRemove is set.
        //
        RemoveMmiHandler (MmiHandler, NULL);
      }
    }
 
    //
    // Go through all MmiHandler in non-root MMI handlers
    //
    for ( EntryLink = GetFirstNode (&mMmiEntryList)
          ; !IsNull (&mMmiEntryList, EntryLink);
          )
    {
      //
      // MmiEntry might be removed in below, so cache the next link in EntryLink
      //
      MmiEntry  = CR (EntryLink, MMI_ENTRY, AllEntries, MMI_ENTRY_SIGNATURE);
      EntryLink = GetNextNode (&mMmiEntryList, EntryLink);
      for ( Link = GetFirstNode (&MmiEntry->MmiHandlers)
            ; !IsNull (&MmiEntry->MmiHandlers, Link);
            )
      {
        //
        // MmiHandler might be removed in below, so cache the next link in Link
        //
        MmiHandler = CR (Link, MMI_HANDLER, Link, MMI_HANDLER_SIGNATURE);
        Link       = GetNextNode (&MmiEntry->MmiHandlers, Link);
        if (MmiHandler->ToRemove) {
          //
          // Remove MmiHandler if the ToRemove is set.
          //
          if (RemoveMmiHandler (MmiHandler, MmiEntry)) {
            break;
          }
        }
      }
    }
  }
 
  return ReturnStatus;
}
 
EFI_STATUS
EFIAPI
MmiHandlerRegister (
  IN  EFI_MM_HANDLER_ENTRY_POINT  Handler,
  IN  CONST EFI_GUID              *HandlerType  OPTIONAL,
  OUT EFI_HANDLE                  *DispatchHandle
  )
{
  MMI_HANDLER  *MmiHandler;
  MMI_ENTRY    *MmiEntry;
  LIST_ENTRY   *List;
 
  if ((Handler == NULL) || (DispatchHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  MmiHandler = AllocateZeroPool (sizeof (MMI_HANDLER));
  if (MmiHandler == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  MmiHandler->Signature = MMI_HANDLER_SIGNATURE;
  MmiHandler->Handler   = Handler;
  MmiHandler->ToRemove  = FALSE;
 
  if (HandlerType == NULL) {
    //
    // This is root MMI handler
    //
    MmiEntry = NULL;
    List     = &mRootMmiHandlerList;
  } else {
    //
    // None root MMI handler
    //
    MmiEntry = MmCoreFindMmiEntry ((EFI_GUID *)HandlerType, TRUE);
    if (MmiEntry == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    List = &MmiEntry->MmiHandlers;
  }
 
  MmiHandler->MmiEntry = MmiEntry;
  InsertTailList (List, &MmiHandler->Link);
 
  *DispatchHandle = (EFI_HANDLE)MmiHandler;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
MmiHandlerUnRegister (
  IN EFI_HANDLE  DispatchHandle
  )
{
  MMI_HANDLER  *MmiHandler;
  MMI_ENTRY    *MmiEntry;
 
  MmiHandler = (MMI_HANDLER *)DispatchHandle;
 
  if (MmiHandler == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (MmiHandler->Signature != MMI_HANDLER_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }
 
  MmiHandler->ToRemove = TRUE;
  if (mMmiManageCallingDepth > 0) {
    //
    // This function is called from MmiManage()
    // Do not delete or remove MmiHandler or MmiEntry now.
    //
    return EFI_SUCCESS;
  }
 
  MmiEntry = MmiHandler->MmiEntry;
  RemoveMmiHandler (MmiHandler, MmiEntry);
 
  return EFI_SUCCESS;
}