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