1 /** @file 2 Multi-Processor support functions implementation. 3 4 Copyright (c) 2010 - 2016, 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 MSR_IA32_APIC_BASE_REGISTER MsrApicBase; 145 146 // 147 // If there are less than 2 CPUs detected, then the currently executing CPU 148 // must be the BSP. This avoids an access to an MSR that may not be supported 149 // on single core CPUs. 150 // 151 if (mDebugCpuData.CpuCount < 2) { 152 return TRUE; 153 } 154 155 MsrApicBase.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE); 156 if (MsrApicBase.Bits.BSP == 1) { 157 if (mDebugMpContext.BspIndex != ProcessorIndex) { 158 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 159 mDebugMpContext.BspIndex = ProcessorIndex; 160 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 161 } 162 return TRUE; 163 } else { 164 return FALSE; 165 } 166 } 167 168 /** 169 Set processor stop flag bitmask in MP context. 170 171 @param[in] ProcessorIndex Processor index value. 172 @param[in] StopFlag TRUE means set stop flag. 173 FALSE means clean break flag. 174 175 **/ 176 VOID 177 SetCpuStopFlagByIndex ( 178 IN UINT32 ProcessorIndex, 179 IN BOOLEAN StopFlag 180 ) 181 { 182 UINT8 Value; 183 UINTN Index; 184 185 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 186 187 Value = mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8]; 188 Index = ProcessorIndex % 8; 189 if (StopFlag) { 190 Value = BitFieldWrite8 (Value, Index, Index, 1); 191 } else { 192 Value = BitFieldWrite8 (Value, Index, Index, 0); 193 } 194 mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] = Value; 195 196 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 197 } 198 199 /** 200 Set processor break flag bitmask in MP context. 201 202 @param[in] ProcessorIndex Processor index value. 203 @param[in] BreakFlag TRUE means set break flag. 204 FALSE means clean break flag. 205 206 **/ 207 VOID 208 SetCpuBreakFlagByIndex ( 209 IN UINT32 ProcessorIndex, 210 IN BOOLEAN BreakFlag 211 ) 212 { 213 UINT8 Value; 214 UINTN Index; 215 216 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 217 218 Value = mDebugMpContext.CpuBreakMask[ProcessorIndex / 8]; 219 Index = ProcessorIndex % 8; 220 if (BreakFlag) { 221 Value = BitFieldWrite8 (Value, Index, Index, 1); 222 } else { 223 Value = BitFieldWrite8 (Value, Index, Index, 0); 224 } 225 mDebugMpContext.CpuBreakMask[ProcessorIndex / 8] = Value; 226 227 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 228 } 229 230 /** 231 Check if processor is stopped already. 232 233 @param[in] ProcessorIndex Processor index value. 234 235 @retval TRUE Processor is stopped already. 236 @retval TRUE Processor isn't stopped. 237 238 **/ 239 BOOLEAN 240 IsCpuStopped ( 241 IN UINT32 ProcessorIndex 242 ) 243 { 244 UINT8 CpuMask; 245 246 CpuMask = (UINT8) (1 << (ProcessorIndex % 8)); 247 248 if ((mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] & CpuMask) != 0) { 249 return TRUE; 250 } else { 251 return FALSE; 252 } 253 } 254 255 /** 256 Set the run command flag. 257 258 @param[in] RunningFlag TRUE means run command flag is set. 259 FALSE means run command flag is cleared. 260 261 **/ 262 VOID 263 SetCpuRunningFlag ( 264 IN BOOLEAN RunningFlag 265 ) 266 { 267 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 268 mDebugMpContext.RunCommandSet = RunningFlag; 269 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 270 } 271 272 /** 273 Set the current view point to be debugged. 274 275 @param[in] ProcessorIndex Processor index value. 276 277 **/ 278 VOID 279 SetDebugViewPoint ( 280 IN UINT32 ProcessorIndex 281 ) 282 { 283 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 284 mDebugMpContext.ViewPointIndex = ProcessorIndex; 285 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 286 } 287 288 /** 289 Set the IPI send by BPS/AP flag. 290 291 @param[in] IpiSentByApFlag TRUE means this IPI is sent by AP. 292 FALSE means this IPI is sent by BSP. 293 294 **/ 295 VOID 296 SetIpiSentByApFlag ( 297 IN BOOLEAN IpiSentByApFlag 298 ) 299 { 300 AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock); 301 mDebugMpContext.IpiSentByAp = IpiSentByApFlag; 302 ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock); 303 } 304 305 /** 306 Check the next pending breaking CPU. 307 308 @retval others There is at least one processor broken, the minimum 309 index number of Processor returned. 310 @retval -1 No any processor broken. 311 312 **/ 313 UINT32 314 FindNextPendingBreakCpu ( 315 VOID 316 ) 317 { 318 UINT32 Index; 319 320 for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index ++) { 321 if (mDebugMpContext.CpuBreakMask[Index] != 0) { 322 return (UINT32) LowBitSet32 (mDebugMpContext.CpuBreakMask[Index]) + Index * 8; 323 } 324 } 325 return (UINT32)-1; 326 } 327 328 /** 329 Check if all processors are in running status. 330 331 @retval TRUE All processors run. 332 @retval FALSE At least one processor does not run. 333 334 **/ 335 BOOLEAN 336 IsAllCpuRunning ( 337 VOID 338 ) 339 { 340 UINTN Index; 341 342 for (Index = 0; Index < DEBUG_CPU_MAX_COUNT / 8; Index ++) { 343 if (mDebugMpContext.CpuStopStatusMask[Index] != 0) { 344 return FALSE; 345 } 346 } 347 return TRUE; 348 } 349 350 /** 351 Check if the current processor is the first breaking processor. 352 353 If yes, halt other processors. 354 355 @param[in] ProcessorIndex Processor index value. 356 357 @return TRUE This processor is the first breaking processor. 358 @return FALSE This processor is not the first breaking processor. 359 360 **/ 361 BOOLEAN 362 IsFirstBreakProcessor ( 363 IN UINT32 ProcessorIndex 364 ) 365 { 366 if (MultiProcessorDebugSupport()) { 367 if (mDebugMpContext.BreakAtCpuIndex != (UINT32) -1) { 368 // 369 // The current processor is not the first breaking one. 370 // 371 SetCpuBreakFlagByIndex (ProcessorIndex, TRUE); 372 return FALSE; 373 } else { 374 // 375 // If no any processor breaks, try to halt other processors 376 // 377 HaltOtherProcessors (ProcessorIndex); 378 return TRUE; 379 } 380 } 381 return TRUE; 382 } 383 384
