SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.c

   1 /** @file
   2   Multi-Processor support functions implementation.
   3
   4   Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "DebugAgent.h"
  16
  17 GLOBAL_REMOVE_IF_UNREFERENCED DEBUG_MP_CONTEXT volatile  mDebugMpContext = {0,0,0,{0},{0},0,0,0,0,FALSE,FALSE};
  18
  19 GLOBAL_REMOVE_IF_UNREFERENCED DEBUG_CPU_DATA volatile  mDebugCpuData = {0};
  20
  21 /**
  22   Acquire a spin lock when Multi-processor supported.
  23
  24   It will block in the function if cannot get the access control.
  25   If Multi-processor is not supported, return directly.
  26
  27   @param[in, out] MpSpinLock      A pointer to the spin lock.
  28
  29 **/
  30 VOID
  31 AcquireMpSpinLock (
  32   IN OUT SPIN_LOCK           *MpSpinLock
  33   )
  34 {
  35   if (!MultiProcessorDebugSupport()) {
  36     return;
  37   }
  38
  39   while (TRUE) {
  40     if (AcquireSpinLockOrFail (MpSpinLock)) {
  41       break;
  42     }
  43     CpuPause ();
  44     continue;
  45   }
  46 }
  47
  48 /**
  49   Release a spin lock when Multi-processor supported.
  50
  51   @param[in, out] MpSpinLock      A pointer to the spin lock.
  52
  53 **/
  54 VOID
  55 ReleaseMpSpinLock (
  56   IN OUT SPIN_LOCK           *MpSpinLock
  57   )
  58 {
  59   if (!MultiProcessorDebugSupport()) {
  60     return;
  61   }
  62
  63   ReleaseSpinLock (MpSpinLock);
  64 }
  65
  66 /**
  67   Break the other processor by send IPI.
  68
  69   @param[in] CurrentProcessorIndex  Current processor index value.
  70
  71 **/
  72 VOID
  73 HaltOtherProcessors (
  74   IN UINT32             CurrentProcessorIndex
  75   )
  76 {
  77   DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Try to halt other processors.\n", CurrentProcessorIndex);
  78   if (!IsBsp (CurrentProcessorIndex)) {
  79     SetIpiSentByApFlag (TRUE);;
  80   }
  81
  82   mDebugMpContext.BreakAtCpuIndex = CurrentProcessorIndex;
  83
  84   //
  85   // Set the debug viewpoint to the current breaking CPU.
  86   //
  87   SetDebugViewPoint (CurrentProcessorIndex);
  88
  89   //
  90   // Send fixed IPI to other processors.
  91   //
  92   SendFixedIpiAllExcludingSelf (DEBUG_TIMER_VECTOR);
  93
  94 }
  95
  96 /**
  97   Get the current processor's index.
  98
  99   @return Processor index value.
 100
 101 **/
 102 UINT32
 103 GetProcessorIndex (
 104   VOID
 105   )
 106 {
 107   UINT32                Index;
 108   UINT16                LocalApicID;
 109
 110   LocalApicID = (UINT16) GetApicId ();
 111
 112   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 113
 114   for (Index = 0; Index < mDebugCpuData.CpuCount; Index ++) {
 115     if (mDebugCpuData.ApicID[Index] == LocalApicID) {
 116       break;
 117     }
 118   }
 119
 120   if (Index == mDebugCpuData.CpuCount) {
 121     mDebugCpuData.ApicID[Index] = LocalApicID;
 122     mDebugCpuData.CpuCount ++ ;
 123   }
 124
 125   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 126
 127   return Index;
 128 }
 129
 130 /**
 131   Check if the specified processor is BSP or not.
 132
 133   @param[in] ProcessorIndex Processor index value.
 134
 135   @retval TRUE    It is BSP.
 136   @retval FALSE   It isn't BSP.
 137
 138 **/
 139 BOOLEAN
 140 IsBsp (
 141   IN UINT32  ProcessorIndex
 142   )
 143 {
 144   //
 145   // If there are less than 2 CPUs detected, then the currently executing CPU
 146   // must be the BSP.  This avoids an access to an MSR that may not be supported
 147   // on single core CPUs.
 148   //
 149   if (mDebugCpuData.CpuCount < 2) {
 150     return TRUE;
 151   }
 152
 153   if (AsmMsrBitFieldRead64 (MSR_IA32_APIC_BASE_ADDRESS, 8, 8) == 1) {
 154     if (mDebugMpContext.BspIndex != ProcessorIndex) {
 155       AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 156       mDebugMpContext.BspIndex = ProcessorIndex;
 157       ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 158     }
 159     return TRUE;
 160   } else {
 161     return FALSE;
 162   }
 163 }
 164
 165 /**
 166   Set processor stop flag bitmask in MP context.
 167
 168   @param[in] ProcessorIndex Processor index value.
 169   @param[in] StopFlag       TRUE means set stop flag.
 170                             FALSE means clean break flag.
 171
 172 **/
 173 VOID
 174 SetCpuStopFlagByIndex (
 175   IN UINT32             ProcessorIndex,
 176   IN BOOLEAN            StopFlag
 177   )
 178 {
 179   UINT8                 Value;
 180   UINTN                 Index;
 181
 182   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 183
 184   Value = mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8];
 185   Index = ProcessorIndex % 8;
 186   if (StopFlag) {
 187     Value = BitFieldWrite8 (Value, Index, Index, 1);
 188   } else {
 189     Value = BitFieldWrite8 (Value, Index, Index, 0);
 190   }
 191   mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] = Value;
 192
 193   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 194 }
 195
 196 /**
 197   Set processor break flag bitmask in MP context.
 198
 199   @param[in] ProcessorIndex Processor index value.
 200   @param[in] BreakFlag      TRUE means set break flag.
 201                             FALSE means clean break flag.
 202
 203 **/
 204 VOID
 205 SetCpuBreakFlagByIndex (
 206   IN UINT32             ProcessorIndex,
 207   IN BOOLEAN            BreakFlag
 208   )
 209 {
 210   UINT8                 Value;
 211   UINTN                 Index;
 212
 213   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 214
 215   Value = mDebugMpContext.CpuBreakMask[ProcessorIndex / 8];
 216   Index = ProcessorIndex % 8;
 217   if (BreakFlag) {
 218     Value = BitFieldWrite8 (Value, Index, Index, 1);
 219   } else {
 220     Value = BitFieldWrite8 (Value, Index, Index, 0);
 221   }
 222   mDebugMpContext.CpuBreakMask[ProcessorIndex / 8] = Value;
 223
 224   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 225 }
 226
 227 /**
 228   Check if processor is stopped already.
 229
 230   @param[in] ProcessorIndex   Processor index value.
 231
 232   @retval TRUE        Processor is stopped already.
 233   @retval TRUE        Processor isn't stopped.
 234
 235 **/
 236 BOOLEAN
 237 IsCpuStopped (
 238   IN UINT32              ProcessorIndex
 239   )
 240 {
 241   UINT8                 CpuMask;
 242
 243   CpuMask = (UINT8) (1 << (ProcessorIndex % 8));
 244
 245   if ((mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] & CpuMask) != 0) {
 246     return TRUE;
 247   } else {
 248     return FALSE;
 249   }
 250 }
 251
 252 /**
 253   Set the run command flag.
 254
 255   @param[in] RunningFlag   TRUE means run command flag is set.
 256                            FALSE means run command flag is cleared.
 257
 258 **/
 259 VOID
 260 SetCpuRunningFlag (
 261   IN BOOLEAN            RunningFlag
 262   )
 263 {
 264   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 265   mDebugMpContext.RunCommandSet = RunningFlag;
 266   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 267 }
 268
 269 /**
 270   Set the current view point to be debugged.
 271
 272   @param[in] ProcessorIndex   Processor index value.
 273
 274 **/
 275 VOID
 276 SetDebugViewPoint (
 277   IN UINT32             ProcessorIndex
 278   )
 279 {
 280   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 281   mDebugMpContext.ViewPointIndex = ProcessorIndex;
 282   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 283 }
 284
 285 /**
 286   Set the IPI send by BPS/AP flag.
 287
 288   @param[in] IpiSentByApFlag   TRUE means this IPI is sent by AP.
 289                                FALSE means this IPI is sent by BSP.
 290
 291 **/
 292 VOID
 293 SetIpiSentByApFlag (
 294   IN BOOLEAN            IpiSentByApFlag
 295   )
 296 {
 297   AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 298   mDebugMpContext.IpiSentByAp = IpiSentByApFlag;
 299   ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);
 300 }
 301
 302 /**
 303   Check the next pending breaking CPU.
 304
 305   @retval others      There is at least one processor broken, the minimum
 306                       index number of Processor returned.
 307   @retval -1          No any processor broken.
 308
 309 **/
 310 UINT32
 311 FindNextPendingBreakCpu (
 312   VOID
 313   )
 314 {
 315   UINT32               Index;
 316
 317   for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index ++) {
 318     if (mDebugMpContext.CpuBreakMask[Index] != 0) {
 319       return  (UINT32) LowBitSet32 (mDebugMpContext.CpuBreakMask[Index]) + Index * 8;
 320     }
 321   }
 322   return (UINT32)-1;
 323 }
 324
 325 /**
 326   Check if all processors are in running status.
 327
 328   @retval TRUE        All processors run.
 329   @retval FALSE       At least one processor does not run.
 330
 331 **/
 332 BOOLEAN
 333 IsAllCpuRunning (
 334   VOID
 335   )
 336 {
 337   UINTN              Index;
 338
 339   for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index ++) {
 340     if (mDebugMpContext.CpuStopStatusMask[Index] != 0) {
 341       return FALSE;
 342     }
 343   }
 344   return TRUE;
 345 }
 346
 347 /**
 348   Check if the current processor is the first breaking processor.
 349
 350   If yes, halt other processors.
 351
 352   @param[in] ProcessorIndex   Processor index value.
 353
 354   @return TRUE       This processor is the first breaking processor.
 355   @return FALSE      This processor is not the first breaking processor.
 356
 357 **/
 358 BOOLEAN
 359 IsFirstBreakProcessor (
 360   IN UINT32              ProcessorIndex
 361   )
 362 {
 363   if (MultiProcessorDebugSupport()) {
 364     if (mDebugMpContext.BreakAtCpuIndex != (UINT32) -1) {
 365       //
 366       // The current processor is not the first breaking one.
 367       //
 368       SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);
 369       return FALSE;
 370     } else {
 371       //
 372       // If no any processor breaks, try to halt other processors
 373       //
 374       HaltOtherProcessors (ProcessorIndex);
 375       return TRUE;
 376     }
 377   }
 378   return TRUE;
 379 }
 380