1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * The main CPU-control loops, used to control masters and slaves. 30 */ 31 32 #include <sys/types.h> 33 34 #include <kmdb/kaif.h> 35 #include <kmdb/kaif_start.h> 36 #include <kmdb/kmdb_asmutil.h> 37 #include <kmdb/kmdb_dpi_impl.h> 38 #include <kmdb/kmdb_kdi.h> 39 40 #define KAIF_SLAVE_CMD_SPIN 0 41 #define KAIF_SLAVE_CMD_SWITCH 1 42 #define KAIF_SLAVE_CMD_RESUME 2 43 #define KAIF_SLAVE_CMD_FLUSH 3 44 #define KAIF_SLAVE_CMD_REBOOT 4 45 #if defined(__sparc) 46 #define KAIF_SLAVE_CMD_ACK 5 47 #endif 48 49 50 /* 51 * Used to synchronize attempts to set kaif_master_cpuid. kaif_master_cpuid may 52 * be read without kaif_master_lock, and may be written by the current master 53 * CPU. 54 */ 55 int kaif_master_cpuid = KAIF_MASTER_CPUID_UNSET; 56 static uintptr_t kaif_master_lock = 0; 57 58 /* 59 * Used to ensure that all CPUs leave the debugger together. kaif_loop_lock must 60 * be held to write kaif_looping, but need not be held to read it. 61 */ 62 static volatile uint_t kaif_looping; 63 static uintptr_t kaif_loop_lock; 64 65 static volatile int kaif_slave_cmd; 66 static volatile int kaif_slave_tgt; /* target cpuid for CMD_SWITCH */ 67 68 static void 69 kaif_lock_enter(uintptr_t *lock) 70 { 71 while (cas(lock, 0, 1) != 0) 72 continue; 73 membar_producer(); 74 } 75 76 static void 77 kaif_lock_exit(uintptr_t *lock) 78 { 79 *lock = 0; 80 membar_producer(); 81 } 82 83 static void 84 kaif_start_slaves(int cmd) 85 { 86 kaif_slave_cmd = cmd; 87 kmdb_kdi_start_slaves(); 88 } 89 90 static int 91 kaif_master_loop(kaif_cpusave_t *cpusave) 92 { 93 int notflushed, i; 94 95 #if defined(__sparc) 96 kaif_prom_rearm(); 97 #endif 98 kaif_trap_set_debugger(); 99 100 /* 101 * If we re-entered due to a ::switch, we need to tell the slave CPUs 102 * to sleep again. 103 */ 104 kmdb_kdi_stop_slaves(cpusave->krs_cpu_id, 0); 105 106 master_loop: 107 switch (kmdb_dpi_reenter()) { 108 case KMDB_DPI_CMD_SWITCH_CPU: 109 /* 110 * We assume that the target CPU is a valid slave. There's no 111 * easy way to complain here, so we'll assume that the caller 112 * has done the proper checking. 113 */ 114 if (kmdb_dpi_switch_target == cpusave->krs_cpu_id) 115 break; 116 117 kaif_slave_tgt = kaif_master_cpuid = kmdb_dpi_switch_target; 118 cpusave->krs_cpu_state = KAIF_CPU_STATE_SLAVE; 119 membar_producer(); 120 121 /* 122 * Switch back to the saved trap table before we switch CPUs -- 123 * we need to make sure that only one CPU is on the debugger's 124 * table at a time. 125 */ 126 kaif_trap_set_saved(cpusave); 127 128 kaif_start_slaves(KAIF_SLAVE_CMD_SWITCH); 129 130 /* The new master is now awake */ 131 return (KAIF_CPU_CMD_SWITCH); 132 133 case KMDB_DPI_CMD_RESUME_ALL: 134 case KMDB_DPI_CMD_RESUME_UNLOAD: 135 /* 136 * Resume everyone, clean up for next entry. 137 */ 138 kaif_master_cpuid = KAIF_MASTER_CPUID_UNSET; 139 membar_producer(); 140 kaif_start_slaves(KAIF_SLAVE_CMD_RESUME); 141 142 if (kmdb_dpi_work_required()) 143 kmdb_dpi_wrintr_fire(); 144 145 kaif_trap_set_saved(cpusave); 146 147 return (KAIF_CPU_CMD_RESUME); 148 149 case KMDB_DPI_CMD_RESUME_MASTER: 150 /* 151 * Single-CPU resume, which is performed on the debugger's 152 * trap table (so no need to switch back). 153 */ 154 return (KAIF_CPU_CMD_RESUME_MASTER); 155 156 case KMDB_DPI_CMD_FLUSH_CACHES: 157 kaif_start_slaves(KAIF_SLAVE_CMD_FLUSH); 158 159 /* 160 * Wait for the other cpus to finish flushing their caches. 161 */ 162 do { 163 notflushed = 0; 164 for (i = 0; i < kaif_ncpusave; i++) { 165 kaif_cpusave_t *save = &kaif_cpusave[i]; 166 167 if (save->krs_cpu_state == 168 KAIF_CPU_STATE_SLAVE && 169 !save->krs_cpu_flushed) { 170 notflushed++; 171 break; 172 } 173 } 174 } while (notflushed > 0); 175 176 kaif_slave_cmd = KAIF_SLAVE_CMD_SPIN; 177 break; 178 179 #if defined(__i386) || defined(__amd64) 180 case KMDB_DPI_CMD_REBOOT: 181 /* 182 * Reboot must be initiated by CPU 0. I could ask why, but I'm 183 * afraid that I don't want to know the answer. 184 */ 185 if (cpusave->krs_cpu_id == 0) 186 kmdb_kdi_reboot(); 187 188 kaif_start_slaves(KAIF_SLAVE_CMD_REBOOT); 189 190 /* 191 * Spin forever, waiting for CPU 0 (apparently a slave) to 192 * reboot the system. 193 */ 194 for (;;) 195 continue; 196 197 /*NOTREACHED*/ 198 break; 199 #endif 200 } 201 202 goto master_loop; 203 } 204 205 static int 206 kaif_slave_loop(kaif_cpusave_t *cpusave) 207 { 208 int slavecmd, rv; 209 210 #if defined(__sparc) 211 /* 212 * If the user elects to drop to OBP from the debugger, some OBP 213 * implementations will cross-call the slaves. We have to turn 214 * IE back on so we can receive the cross-calls. If we don't, 215 * some OBP implementations will wait forever. 216 */ 217 interrupts_on(); 218 #endif 219 220 /* Wait for duty to call */ 221 for (;;) { 222 slavecmd = kaif_slave_cmd; 223 224 if (slavecmd == KAIF_SLAVE_CMD_SWITCH && 225 kaif_slave_tgt == cpusave->krs_cpu_id) { 226 kaif_slave_cmd = KAIF_SLAVE_CMD_SPIN; 227 cpusave->krs_cpu_state = KAIF_CPU_STATE_MASTER; 228 rv = KAIF_CPU_CMD_SWITCH; 229 break; 230 231 } else if (slavecmd == KAIF_SLAVE_CMD_FLUSH) { 232 kmdb_kdi_flush_caches(); 233 cpusave->krs_cpu_flushed = 1; 234 continue; 235 236 #if defined(__i386) || defined(__amd64) 237 } else if (slavecmd == KAIF_SLAVE_CMD_REBOOT && 238 cpusave->krs_cpu_id == 0) { 239 rv = 0; 240 kmdb_kdi_reboot(); 241 break; 242 #endif 243 244 } else if (slavecmd == KAIF_SLAVE_CMD_RESUME) { 245 rv = KAIF_CPU_CMD_RESUME; 246 break; 247 #if defined(__sparc) 248 } else if (slavecmd == KAIF_SLAVE_CMD_ACK) { 249 cpusave->krs_cpu_acked = 1; 250 } else if (cpusave->krs_cpu_acked && 251 slavecmd == KAIF_SLAVE_CMD_SPIN) { 252 cpusave->krs_cpu_acked = 0; 253 #endif 254 } 255 256 kmdb_kdi_slave_wait(); 257 } 258 259 #if defined(__sparc) 260 interrupts_off(); 261 #endif 262 263 return (rv); 264 } 265 266 static void 267 kaif_select_master(kaif_cpusave_t *cpusave) 268 { 269 kaif_lock_enter(&kaif_master_lock); 270 271 if (kaif_master_cpuid == KAIF_MASTER_CPUID_UNSET) { 272 /* This is the master. */ 273 kaif_master_cpuid = cpusave->krs_cpu_id; 274 cpusave->krs_cpu_state = KAIF_CPU_STATE_MASTER; 275 kaif_slave_cmd = KAIF_SLAVE_CMD_SPIN; 276 277 membar_producer(); 278 279 kmdb_kdi_stop_slaves(cpusave->krs_cpu_id, 1); 280 } else { 281 /* The master was already chosen - go be a slave */ 282 cpusave->krs_cpu_state = KAIF_CPU_STATE_SLAVE; 283 membar_producer(); 284 } 285 286 kaif_lock_exit(&kaif_master_lock); 287 } 288 289 int 290 kaif_main_loop(kaif_cpusave_t *cpusave) 291 { 292 int cmd; 293 294 if (kaif_master_cpuid == KAIF_MASTER_CPUID_UNSET) { 295 if (!kmdb_dpi_resume_requested && 296 kmdb_kdi_get_unload_request()) { 297 /* 298 * Special case: Unload requested before first debugger 299 * entry. Don't stop the world, as there's nothing to 300 * clean up that can't be handled by the running kernel. 301 */ 302 cpusave->krs_cpu_state = KAIF_CPU_STATE_NONE; 303 return (KAIF_CPU_CMD_RESUME); 304 } 305 306 kaif_select_master(cpusave); 307 308 #ifdef __sparc 309 if (kaif_master_cpuid == cpusave->krs_cpu_id) { 310 /* 311 * Everyone has arrived, so we can disarm the post-PROM 312 * entry point. 313 */ 314 *kaif_promexitarmp = 0; 315 membar_producer(); 316 } 317 #endif 318 } else if (kaif_master_cpuid == cpusave->krs_cpu_id) { 319 cpusave->krs_cpu_state = KAIF_CPU_STATE_MASTER; 320 } else { 321 cpusave->krs_cpu_state = KAIF_CPU_STATE_SLAVE; 322 } 323 324 cpusave->krs_cpu_flushed = 0; 325 326 kaif_lock_enter(&kaif_loop_lock); 327 kaif_looping++; 328 kaif_lock_exit(&kaif_loop_lock); 329 330 /* 331 * We know who the master and slaves are, so now they can go off 332 * to their respective loops. 333 */ 334 do { 335 if (kaif_master_cpuid == cpusave->krs_cpu_id) 336 cmd = kaif_master_loop(cpusave); 337 else 338 cmd = kaif_slave_loop(cpusave); 339 } while (cmd == KAIF_CPU_CMD_SWITCH); 340 341 kaif_lock_enter(&kaif_loop_lock); 342 kaif_looping--; 343 kaif_lock_exit(&kaif_loop_lock); 344 345 cpusave->krs_cpu_state = KAIF_CPU_STATE_NONE; 346 347 if (cmd == KAIF_CPU_CMD_RESUME) { 348 /* 349 * By this point, the master has directed the slaves to resume, 350 * and everyone is making their way to this point. We're going 351 * to block here until all CPUs leave the master and slave 352 * loops. When all have arrived, we'll turn them all loose. 353 * This barrier is required for two reasons: 354 * 355 * 1. There exists a race condition whereby a CPU could reenter 356 * the debugger while another CPU is still in the slave loop 357 * from this debugger entry. This usually happens when the 358 * current master releases the slaves, and makes it back to 359 * the world before the slaves notice the release. The 360 * former master then triggers a debugger entry, and attempts 361 * to stop the slaves for this entry before they've even 362 * resumed from the last one. When the slaves arrive here, 363 * they'll have re-disabled interrupts, and will thus ignore 364 * cross-calls until they finish resuming. 365 * 366 * 2. At the time of this writing, there exists a SPARC bug that 367 * causes an apparently unsolicited interrupt vector trap 368 * from OBP to one of the slaves. This wouldn't normally be 369 * a problem but for the fact that the cross-called CPU 370 * encounters some sort of failure while in OBP. OBP 371 * recovers by executing the debugger-hook word, which sends 372 * the slave back into the debugger, triggering a debugger 373 * fault. This problem seems to only happen during resume, 374 * the result being that all CPUs save for the cross-called 375 * one make it back into the world, while the cross-called 376 * one is stuck at the debugger fault prompt. Leave the 377 * world in that state too long, and you'll get a mondo 378 * timeout panic. If we hold everyone here, we can give the 379 * the user a chance to trigger a panic for further analysis. 380 * To trigger the bug, "pool_unlock:b :c" and "while : ; do 381 * psrset -p ; done". 382 * 383 * When the second item is fixed, the barrier can move into 384 * kaif_select_master(), immediately prior to the setting of 385 * kaif_master_cpuid. 386 */ 387 while (kaif_looping != 0) 388 continue; 389 } 390 391 return (cmd); 392 } 393 394 395 #if defined(__sparc) 396 397 static int slave_loop_barrier_failures = 0; /* for debug */ 398 399 /* 400 * There exist a race condition observed by some 401 * platforms where the kmdb master cpu exits to OBP via 402 * prom_enter_mon (e.g. "$q" command) and then later re-enter 403 * kmdb (typing "go") while the slaves are still proceeding 404 * from the OBP idle-loop back to the kmdb slave loop. The 405 * problem arises when the master cpu now back in kmdb proceed 406 * to re-enter OBP (e.g. doing a prom_read() from the kmdb main 407 * loop) while the slaves are still trying to get out of (the 408 * previous trip in) OBP into the safety of the kmdb slave loop. 409 * This routine forces the slaves to explicitly acknowledge 410 * that they are back in the slave loop. The master cpu can 411 * call this routine to ensure that all slave cpus are back 412 * in the slave loop before proceeding. 413 */ 414 void 415 kaif_slave_loop_barrier(void) 416 { 417 extern void kdi_usecwait(clock_t); 418 int i; 419 int not_acked; 420 int timeout_count = 0; 421 422 kaif_start_slaves(KAIF_SLAVE_CMD_ACK); 423 424 /* 425 * Wait for slave cpus to explicitly acknowledge 426 * that they are spinning in the slave loop. 427 */ 428 do { 429 not_acked = 0; 430 for (i = 0; i < kaif_ncpusave; i++) { 431 kaif_cpusave_t *save = &kaif_cpusave[i]; 432 433 if (save->krs_cpu_state == 434 KAIF_CPU_STATE_SLAVE && 435 !save->krs_cpu_acked) { 436 not_acked++; 437 break; 438 } 439 } 440 441 if (not_acked == 0) 442 break; 443 444 /* 445 * Play it safe and do a timeout delay. 446 * We will do at most kaif_ncpusave delays before 447 * bailing out of this barrier. 448 */ 449 kdi_usecwait(200); 450 451 } while (++timeout_count < kaif_ncpusave); 452 453 if (not_acked > 0) 454 /* 455 * we cannot establish a barrier with all 456 * the slave cpus coming back from OBP 457 * Record this fact for future debugging 458 */ 459 slave_loop_barrier_failures++; 460 461 kaif_slave_cmd = KAIF_SLAVE_CMD_SPIN; 462 } 463 #endif 464