DxeDebugPrintErrorLevelLib.c

Go to the documentation of this file.

 
#include <PiDxe.h>
 
#include <Library/DebugPrintErrorLevelLib.h>
#include <Library/PcdLib.h>
#include <Library/HobLib.h>
 
#include <Guid/DebugMask.h>
 
 
EFI_STATUS
EFIAPI
GetDebugMask (
  IN EFI_DEBUG_MASK_PROTOCOL  *This,
  IN OUT UINTN                *CurrentDebugMask
  );
 
EFI_STATUS
EFIAPI
SetDebugMask (
  IN EFI_DEBUG_MASK_PROTOCOL  *This,
  IN UINTN                    NewDebugMask
  );
 
EFI_DEBUG_MASK_PROTOCOL  mDebugMaskProtocol = {
  EFI_DEBUG_MASK_REVISION,
  GetDebugMask,
  SetDebugMask
};
 
BOOLEAN  mGlobalErrorLevelInitialized = FALSE;
 
UINT32  mDebugPrintErrorLevel = 0;
 
EFI_SYSTEM_TABLE  *mSystemTable = NULL;
 
EFI_STATUS
EFIAPI
DxeDebugPrintErrorLevelLibConstructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Initialize the error level mask from PCD setting.
  //
  mDebugPrintErrorLevel = PcdGet32 (PcdDebugPrintErrorLevel);
 
  //
  // Install Debug Mask Protocol onto ImageHandle
  //
  mSystemTable = SystemTable;
  Status       = SystemTable->BootServices->InstallMultipleProtocolInterfaces (
                                              &ImageHandle,
                                              &gEfiDebugMaskProtocolGuid,
                                              &mDebugMaskProtocol,
                                              NULL
                                              );
 
  //
  // Attempt to retrieve the global debug print error level mask from the EFI Variable
  // If the EFI Variable can not be accessed when this module's library constructors are
  // executed a HOB can be used to set the global debug print error level. If no value
  // was found then the EFI Variable access will be reattempted on every DEBUG() print
  // from this module until the EFI Variable services are available.
  //
  GetDebugPrintErrorLevel ();
 
  return Status;
}
 
EFI_STATUS
EFIAPI
DxeDebugPrintErrorLevelLibDestructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  //
  // Uninstall the Debug Mask Protocol from ImageHandle
  //
  return SystemTable->BootServices->UninstallMultipleProtocolInterfaces (
                                      ImageHandle,
                                      &gEfiDebugMaskProtocolGuid,
                                      &mDebugMaskProtocol,
                                      NULL
                                      );
}
 
UINT32
EFIAPI
GetDebugPrintErrorLevel (
  VOID
  )
{
  EFI_STATUS  Status;
  EFI_TPL     CurrentTpl;
  UINTN       Size;
  UINTN       GlobalErrorLevel;
  VOID        *Hob;
 
  //
  // If the constructor has not been executed yet, then just return the PCD value.
  // This case should only occur if debug print is generated by a library
  // constructor for this module
  //
  if (mSystemTable == NULL) {
    return PcdGet32 (PcdDebugPrintErrorLevel);
  }
 
  //
  // Check to see if an attempt has been made to retrieve the global debug print
  // error level mask.  Since this library instance stores the global debug print
  // error level mask in an EFI Variable, the EFI Variable should only be accessed
  // once to reduce the overhead of reading the EFI Variable on every debug print
  //
  if (!mGlobalErrorLevelInitialized) {
    //
    // Make sure the TPL Level is low enough for EFI Variable Services to be called
    //
    CurrentTpl = mSystemTable->BootServices->RaiseTPL (TPL_HIGH_LEVEL);
    mSystemTable->BootServices->RestoreTPL (CurrentTpl);
    if (CurrentTpl <= TPL_CALLBACK) {
      //
      // Attempt to retrieve the global debug print error level mask from the
      // EFI Variable
      //
      Size   = sizeof (GlobalErrorLevel);
      Status = mSystemTable->RuntimeServices->GetVariable (
                                                DEBUG_MASK_VARIABLE_NAME,
                                                &gEfiGenericVariableGuid,
                                                NULL,
                                                &Size,
                                                &GlobalErrorLevel
                                                );
      if (Status != EFI_NOT_AVAILABLE_YET) {
        //
        // If EFI Variable Services are available, then set a flag so the EFI
        // Variable will not be read again by this module.
        //
        mGlobalErrorLevelInitialized = TRUE;
        if (!EFI_ERROR (Status)) {
          //
          // If the EFI Varible exists, then set this module's module's mask to
          // the global debug print error level mask value.
          //
          mDebugPrintErrorLevel = (UINT32)GlobalErrorLevel;
        }
      } else {
        //
        // If variable services are not yet available optionally get the global
        // debug print error level mask from a HOB.
        //
        Hob = GetFirstGuidHob (&gEfiGenericVariableGuid);
        if (Hob != NULL) {
          if (GET_GUID_HOB_DATA_SIZE (Hob) == sizeof (UINT32)) {
            mDebugPrintErrorLevel        = *(UINT32 *)GET_GUID_HOB_DATA (Hob);
            mGlobalErrorLevelInitialized = TRUE;
          }
        }
      }
    }
  }
 
  //
  // Return the current mask value for this module.
  //
  return mDebugPrintErrorLevel;
}
 
BOOLEAN
EFIAPI
SetDebugPrintErrorLevel (
  UINT32  ErrorLevel
  )
{
  EFI_STATUS  Status;
  EFI_TPL     CurrentTpl;
  UINTN       Size;
  UINTN       GlobalErrorLevel;
 
  //
  // Make sure the constructor has been executed
  //
  if (mSystemTable != NULL) {
    //
    // Make sure the TPL Level is low enough for EFI Variable Services
    //
    CurrentTpl = mSystemTable->BootServices->RaiseTPL (TPL_HIGH_LEVEL);
    mSystemTable->BootServices->RestoreTPL (CurrentTpl);
    if (CurrentTpl <= TPL_CALLBACK) {
      //
      // Attempt to store the global debug print error level mask in an EFI Variable
      //
      GlobalErrorLevel = (UINTN)ErrorLevel;
      Size             = sizeof (GlobalErrorLevel);
      Status           = mSystemTable->RuntimeServices->SetVariable (
                                                          DEBUG_MASK_VARIABLE_NAME,
                                                          &gEfiGenericVariableGuid,
                                                          (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS),
                                                          Size,
                                                          &GlobalErrorLevel
                                                          );
      if (!EFI_ERROR (Status)) {
        //
        // If the EFI Variable was updated, then update the mask value for this
        // module and return TRUE.
        //
        mGlobalErrorLevelInitialized = TRUE;
        mDebugPrintErrorLevel        = ErrorLevel;
        return TRUE;
      }
    }
  }
 
  //
  // Return FALSE since the EFI Variable could not be updated.
  //
  return FALSE;
}
 
EFI_STATUS
EFIAPI
GetDebugMask (
  IN EFI_DEBUG_MASK_PROTOCOL  *This,
  IN OUT UINTN                *CurrentDebugMask
  )
{
  if (CurrentDebugMask == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the current debug mask from mDebugPrintErrorLevel
  //
  *CurrentDebugMask = (UINTN)mDebugPrintErrorLevel;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
SetDebugMask (
  IN EFI_DEBUG_MASK_PROTOCOL  *This,
  IN UINTN                    NewDebugMask
  )
{
  //
  // Store the new debug mask into mDebugPrintErrorLevel
  //
  mDebugPrintErrorLevel = (UINT32)NewDebugMask;
  return EFI_SUCCESS;
}