DebugMp.c

Go to the documentation of this file.

 
#include "DebugAgent.h"
 
GLOBAL_REMOVE_IF_UNREFERENCED DEBUG_MP_CONTEXT volatile  mDebugMpContext = { 0, 0, 0, { 0 }, { 0 }, 0, 0, 0, 0, FALSE, FALSE };
 
GLOBAL_REMOVE_IF_UNREFERENCED DEBUG_CPU_DATA volatile  mDebugCpuData = { 0 };
 
VOID
AcquireMpSpinLock (
  IN OUT SPIN_LOCK  *MpSpinLock
  )
{
  if (!MultiProcessorDebugSupport ()) {
    return;
  }
 
  while (TRUE) {
    if (AcquireSpinLockOrFail (MpSpinLock)) {
      break;
    }
 
    CpuPause ();
    continue;
  }
}
 
VOID
ReleaseMpSpinLock (
  IN OUT SPIN_LOCK  *MpSpinLock
  )
{
  if (!MultiProcessorDebugSupport ()) {
    return;
  }
 
  ReleaseSpinLock (MpSpinLock);
}
 
VOID
HaltOtherProcessors (
  IN UINT32  CurrentProcessorIndex
  )
{
  DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Try to halt other processors.\n", CurrentProcessorIndex);
  if (!DebugAgentIsBsp (CurrentProcessorIndex)) {
    SetIpiSentByApFlag (TRUE);
  }
 
  mDebugMpContext.BreakAtCpuIndex = CurrentProcessorIndex;
 
  //
  // Set the debug viewpoint to the current breaking CPU.
  //
  SetDebugViewPoint (CurrentProcessorIndex);
 
  //
  // Send fixed IPI to other processors.
  //
  SendFixedIpiAllExcludingSelf (DEBUG_TIMER_VECTOR);
}
 
UINT32
GetProcessorIndex (
  VOID
  )
{
  UINT32  Index;
  UINT16  LocalApicID;
 
  LocalApicID = (UINT16)GetApicId ();
 
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 
  for (Index = 0; Index < mDebugCpuData.CpuCount; Index++) {
    if (mDebugCpuData.ApicID[Index] == LocalApicID) {
      break;
    }
  }
 
  if (Index == mDebugCpuData.CpuCount) {
    mDebugCpuData.ApicID[Index] = LocalApicID;
    mDebugCpuData.CpuCount++;
  }
 
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 
  return Index;
}
 
BOOLEAN
DebugAgentIsBsp (
  IN UINT32  ProcessorIndex
  )
{
  MSR_IA32_APIC_BASE_REGISTER  MsrApicBase;
 
  //
  // If there are less than 2 CPUs detected, then the currently executing CPU
  // must be the BSP.  This avoids an access to an MSR that may not be supported
  // on single core CPUs.
  //
  if (mDebugCpuData.CpuCount < 2) {
    return TRUE;
  }
 
  MsrApicBase.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE);
  if (MsrApicBase.Bits.BSP == 1) {
    if (mDebugMpContext.BspIndex != ProcessorIndex) {
      AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
      mDebugMpContext.BspIndex = ProcessorIndex;
      ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
    }
 
    return TRUE;
  } else {
    return FALSE;
  }
}
 
VOID
SetCpuStopFlagByIndex (
  IN UINT32   ProcessorIndex,
  IN BOOLEAN  StopFlag
  )
{
  UINT8  Value;
  UINTN  Index;
 
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 
  Value = mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8];
  Index = ProcessorIndex % 8;
  if (StopFlag) {
    Value = BitFieldWrite8 (Value, Index, Index, 1);
  } else {
    Value = BitFieldWrite8 (Value, Index, Index, 0);
  }
 
  mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] = Value;
 
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
}
 
VOID
SetCpuBreakFlagByIndex (
  IN UINT32   ProcessorIndex,
  IN BOOLEAN  BreakFlag
  )
{
  UINT8  Value;
  UINTN  Index;
 
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 
  Value = mDebugMpContext.CpuBreakMask[ProcessorIndex / 8];
  Index = ProcessorIndex % 8;
  if (BreakFlag) {
    Value = BitFieldWrite8 (Value, Index, Index, 1);
  } else {
    Value = BitFieldWrite8 (Value, Index, Index, 0);
  }
 
  mDebugMpContext.CpuBreakMask[ProcessorIndex / 8] = Value;
 
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
}
 
BOOLEAN
IsCpuStopped (
  IN UINT32  ProcessorIndex
  )
{
  UINT8  CpuMask;
 
  CpuMask = (UINT8)(1 << (ProcessorIndex % 8));
 
  if ((mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] & CpuMask) != 0) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
VOID
SetCpuRunningFlag (
  IN BOOLEAN  RunningFlag
  )
{
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
  mDebugMpContext.RunCommandSet = RunningFlag;
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
}
 
VOID
SetDebugViewPoint (
  IN UINT32  ProcessorIndex
  )
{
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
  mDebugMpContext.ViewPointIndex = ProcessorIndex;
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
}
 
VOID
SetIpiSentByApFlag (
  IN BOOLEAN  IpiSentByApFlag
  )
{
  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
  mDebugMpContext.IpiSentByAp = IpiSentByApFlag;
  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
}
 
UINT32
FindNextPendingBreakCpu (
  VOID
  )
{
  UINT32  Index;
 
  for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index++) {
    if (mDebugMpContext.CpuBreakMask[Index] != 0) {
      return (UINT32)LowBitSet32 (mDebugMpContext.CpuBreakMask[Index]) + Index * 8;
    }
  }
 
  return (UINT32)-1;
}
 
BOOLEAN
IsAllCpuRunning (
  VOID
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index++) {
    if (mDebugMpContext.CpuStopStatusMask[Index] != 0) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
IsFirstBreakProcessor (
  IN UINT32  ProcessorIndex
  )
{
  if (MultiProcessorDebugSupport ()) {
    if (mDebugMpContext.BreakAtCpuIndex != (UINT32)-1) {
      //
      // The current processor is not the first breaking one.
      //
      SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);
      return FALSE;
    } else {
      //
      // If no any processor breaks, try to halt other processors
      //
      HaltOtherProcessors (ProcessorIndex);
      return TRUE;
    }
  }
 
  return TRUE;
}