subr_kdb.c revision 178766
1/*- 2 * Copyright (c) 2004 The FreeBSD Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD: head/sys/kern/subr_kdb.c 178766 2008-05-04 23:29:38Z peter $"); 29 30#include "opt_kdb.h" 31 32#include <sys/param.h> 33#include <sys/systm.h> 34#include <sys/kdb.h> 35#include <sys/kernel.h> 36#include <sys/malloc.h> 37#include <sys/pcpu.h> 38#include <sys/proc.h> 39#include <sys/smp.h> 40#include <sys/sysctl.h> 41 42#include <machine/kdb.h> 43#include <machine/pcb.h> 44 45#ifdef SMP 46#include <machine/smp.h> 47#endif 48 49int kdb_active = 0; 50void *kdb_jmpbufp = NULL; 51struct kdb_dbbe *kdb_dbbe = NULL; 52struct pcb kdb_pcb; 53struct pcb *kdb_thrctx = NULL; 54struct thread *kdb_thread = NULL; 55struct trapframe *kdb_frame = NULL; 56 57KDB_BACKEND(null, NULL, NULL, NULL); 58SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe); 59 60static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS); 61static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS); 62static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS); 63static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS); 64static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS); 65static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS); 66 67SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes"); 68 69SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, 0, 0, 70 kdb_sysctl_available, "A", "list of available KDB backends"); 71 72SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, 0, 0, 73 kdb_sysctl_current, "A", "currently selected KDB backend"); 74 75SYSCTL_PROC(_debug_kdb, OID_AUTO, enter, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 76 kdb_sysctl_enter, "I", "set to enter the debugger"); 77 78SYSCTL_PROC(_debug_kdb, OID_AUTO, panic, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 79 kdb_sysctl_panic, "I", "set to panic the kernel"); 80 81SYSCTL_PROC(_debug_kdb, OID_AUTO, trap, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 82 kdb_sysctl_trap, "I", "set to cause a page fault via data access"); 83 84SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 85 kdb_sysctl_trap_code, "I", "set to cause a page fault via code access"); 86 87/* 88 * Flag indicating whether or not to IPI the other CPUs to stop them on 89 * entering the debugger. Sometimes, this will result in a deadlock as 90 * stop_cpus() waits for the other cpus to stop, so we allow it to be 91 * disabled. 92 */ 93#ifdef SMP 94static int kdb_stop_cpus = 1; 95SYSCTL_INT(_debug_kdb, OID_AUTO, stop_cpus, CTLTYPE_INT | CTLFLAG_RW, 96 &kdb_stop_cpus, 0, "stop other CPUs when entering the debugger"); 97TUNABLE_INT("debug.kdb.stop_cpus", &kdb_stop_cpus); 98#endif 99 100/* 101 * Flag to indicate to debuggers why the debugger was entered. 102 */ 103const char * volatile kdb_why = KDB_WHY_UNSET; 104 105static int 106kdb_sysctl_available(SYSCTL_HANDLER_ARGS) 107{ 108 struct kdb_dbbe *be, **iter; 109 char *avail, *p; 110 ssize_t len, sz; 111 int error; 112 113 sz = 0; 114 SET_FOREACH(iter, kdb_dbbe_set) { 115 be = *iter; 116 if (be->dbbe_active == 0) 117 sz += strlen(be->dbbe_name) + 1; 118 } 119 sz++; 120 avail = malloc(sz, M_TEMP, M_WAITOK); 121 p = avail; 122 *p = '\0'; 123 124 SET_FOREACH(iter, kdb_dbbe_set) { 125 be = *iter; 126 if (be->dbbe_active == 0) { 127 len = snprintf(p, sz, "%s ", be->dbbe_name); 128 p += len; 129 sz -= len; 130 } 131 } 132 KASSERT(sz >= 0, ("%s", __func__)); 133 error = sysctl_handle_string(oidp, avail, 0, req); 134 free(avail, M_TEMP); 135 return (error); 136} 137 138static int 139kdb_sysctl_current(SYSCTL_HANDLER_ARGS) 140{ 141 char buf[16]; 142 int error; 143 144 if (kdb_dbbe != NULL) { 145 strncpy(buf, kdb_dbbe->dbbe_name, sizeof(buf)); 146 buf[sizeof(buf) - 1] = '\0'; 147 } else 148 *buf = '\0'; 149 error = sysctl_handle_string(oidp, buf, sizeof(buf), req); 150 if (error != 0 || req->newptr == NULL) 151 return (error); 152 if (kdb_active) 153 return (EBUSY); 154 return (kdb_dbbe_select(buf)); 155} 156 157static int 158kdb_sysctl_enter(SYSCTL_HANDLER_ARGS) 159{ 160 int error, i; 161 162 error = sysctl_wire_old_buffer(req, sizeof(int)); 163 if (error == 0) { 164 i = 0; 165 error = sysctl_handle_int(oidp, &i, 0, req); 166 } 167 if (error != 0 || req->newptr == NULL) 168 return (error); 169 if (kdb_active) 170 return (EBUSY); 171 kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter"); 172 return (0); 173} 174 175static int 176kdb_sysctl_panic(SYSCTL_HANDLER_ARGS) 177{ 178 int error, i; 179 180 error = sysctl_wire_old_buffer(req, sizeof(int)); 181 if (error == 0) { 182 i = 0; 183 error = sysctl_handle_int(oidp, &i, 0, req); 184 } 185 if (error != 0 || req->newptr == NULL) 186 return (error); 187 panic("kdb_sysctl_panic"); 188 return (0); 189} 190 191static int 192kdb_sysctl_trap(SYSCTL_HANDLER_ARGS) 193{ 194 int error, i; 195 int *addr = (int *)0x10; 196 197 error = sysctl_wire_old_buffer(req, sizeof(int)); 198 if (error == 0) { 199 i = 0; 200 error = sysctl_handle_int(oidp, &i, 0, req); 201 } 202 if (error != 0 || req->newptr == NULL) 203 return (error); 204 return (*addr); 205} 206 207static int 208kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS) 209{ 210 int error, i; 211 void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de; 212 213 error = sysctl_wire_old_buffer(req, sizeof(int)); 214 if (error == 0) { 215 i = 0; 216 error = sysctl_handle_int(oidp, &i, 0, req); 217 } 218 if (error != 0 || req->newptr == NULL) 219 return (error); 220 (*fp)(0x11111111, 0x22222222, 0x33333333); 221 return (0); 222} 223 224void 225kdb_panic(const char *msg) 226{ 227 228#ifdef SMP 229 stop_cpus(PCPU_GET(other_cpus)); 230#endif 231 printf("KDB: panic\n"); 232 panic(msg); 233} 234 235void 236kdb_reboot(void) 237{ 238 239 printf("KDB: reboot requested\n"); 240 shutdown_nice(0); 241} 242 243/* 244 * Solaris implements a new BREAK which is initiated by a character sequence 245 * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the 246 * Remote Console. 247 * 248 * Note that this function may be called from almost anywhere, with interrupts 249 * disabled and with unknown locks held, so it must not access data other than 250 * its arguments. Its up to the caller to ensure that the state variable is 251 * consistent. 252 */ 253 254#define KEY_CR 13 /* CR '\r' */ 255#define KEY_TILDE 126 /* ~ */ 256#define KEY_CRTLB 2 /* ^B */ 257#define KEY_CRTLP 16 /* ^P */ 258#define KEY_CRTLR 18 /* ^R */ 259 260int 261kdb_alt_break(int key, int *state) 262{ 263 int brk; 264 265 brk = 0; 266 switch (*state) { 267 case 0: 268 if (key == KEY_CR) 269 *state = 1; 270 break; 271 case 1: 272 if (key == KEY_TILDE) 273 *state = 2; 274 break; 275 case 2: 276 if (key == KEY_CRTLB) 277 brk = KDB_REQ_DEBUGGER; 278 else if (key == KEY_CRTLP) 279 brk = KDB_REQ_PANIC; 280 else if (key == KEY_CRTLR) 281 brk = KDB_REQ_REBOOT; 282 *state = 0; 283 } 284 return (brk); 285} 286 287/* 288 * Print a backtrace of the calling thread. The backtrace is generated by 289 * the selected debugger, provided it supports backtraces. If no debugger 290 * is selected or the current debugger does not support backtraces, this 291 * function silently returns. 292 */ 293 294void 295kdb_backtrace() 296{ 297 298 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) { 299 printf("KDB: stack backtrace:\n"); 300 kdb_dbbe->dbbe_trace(); 301 } 302} 303 304/* 305 * Set/change the current backend. 306 */ 307 308int 309kdb_dbbe_select(const char *name) 310{ 311 struct kdb_dbbe *be, **iter; 312 313 SET_FOREACH(iter, kdb_dbbe_set) { 314 be = *iter; 315 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) { 316 kdb_dbbe = be; 317 return (0); 318 } 319 } 320 return (EINVAL); 321} 322 323/* 324 * Enter the currently selected debugger. If a message has been provided, 325 * it is printed first. If the debugger does not support the enter method, 326 * it is entered by using breakpoint(), which enters the debugger through 327 * kdb_trap(). The 'why' argument will contain a more mechanically usable 328 * string than 'msg', and is relied upon by DDB scripting to identify the 329 * reason for entering the debugger so that the right script can be run. 330 */ 331void 332kdb_enter(const char *why, const char *msg) 333{ 334 335 if (kdb_dbbe != NULL && kdb_active == 0) { 336 if (msg != NULL) 337 printf("KDB: enter: %s\n", msg); 338 kdb_why = why; 339 breakpoint(); 340 kdb_why = KDB_WHY_UNSET; 341 } 342} 343 344/* 345 * Initialize the kernel debugger interface. 346 */ 347 348void 349kdb_init() 350{ 351 struct kdb_dbbe *be, **iter; 352 int cur_pri, pri; 353 354 kdb_active = 0; 355 kdb_dbbe = NULL; 356 cur_pri = -1; 357 SET_FOREACH(iter, kdb_dbbe_set) { 358 be = *iter; 359 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1; 360 be->dbbe_active = (pri >= 0) ? 0 : -1; 361 if (pri > cur_pri) { 362 cur_pri = pri; 363 kdb_dbbe = be; 364 } 365 } 366 if (kdb_dbbe != NULL) { 367 printf("KDB: debugger backends:"); 368 SET_FOREACH(iter, kdb_dbbe_set) { 369 be = *iter; 370 if (be->dbbe_active == 0) 371 printf(" %s", be->dbbe_name); 372 } 373 printf("\n"); 374 printf("KDB: current backend: %s\n", 375 kdb_dbbe->dbbe_name); 376 } 377} 378 379/* 380 * Handle contexts. 381 */ 382 383void * 384kdb_jmpbuf(jmp_buf new) 385{ 386 void *old; 387 388 old = kdb_jmpbufp; 389 kdb_jmpbufp = new; 390 return (old); 391} 392 393void 394kdb_reenter(void) 395{ 396 397 if (!kdb_active || kdb_jmpbufp == NULL) 398 return; 399 400 longjmp(kdb_jmpbufp, 1); 401 /* NOTREACHED */ 402} 403 404/* 405 * Thread related support functions. 406 */ 407 408struct pcb * 409kdb_thr_ctx(struct thread *thr) 410{ 411#if defined(SMP) && defined(KDB_STOPPEDPCB) 412 struct pcpu *pc; 413#endif 414 415 if (thr == curthread) 416 return (&kdb_pcb); 417 418#if defined(SMP) && defined(KDB_STOPPEDPCB) 419 SLIST_FOREACH(pc, &cpuhead, pc_allcpu) { 420 if (pc->pc_curthread == thr && (stopped_cpus & pc->pc_cpumask)) 421 return (KDB_STOPPEDPCB(pc)); 422 } 423#endif 424 return (thr->td_pcb); 425} 426 427struct thread * 428kdb_thr_first(void) 429{ 430 struct proc *p; 431 struct thread *thr; 432 433 p = LIST_FIRST(&allproc); 434 while (p != NULL) { 435 if (p->p_flag & P_INMEM) { 436 thr = FIRST_THREAD_IN_PROC(p); 437 if (thr != NULL) 438 return (thr); 439 } 440 p = LIST_NEXT(p, p_list); 441 } 442 return (NULL); 443} 444 445struct thread * 446kdb_thr_from_pid(pid_t pid) 447{ 448 struct proc *p; 449 450 p = LIST_FIRST(&allproc); 451 while (p != NULL) { 452 if (p->p_flag & P_INMEM && p->p_pid == pid) 453 return (FIRST_THREAD_IN_PROC(p)); 454 p = LIST_NEXT(p, p_list); 455 } 456 return (NULL); 457} 458 459struct thread * 460kdb_thr_lookup(lwpid_t tid) 461{ 462 struct thread *thr; 463 464 thr = kdb_thr_first(); 465 while (thr != NULL && thr->td_tid != tid) 466 thr = kdb_thr_next(thr); 467 return (thr); 468} 469 470struct thread * 471kdb_thr_next(struct thread *thr) 472{ 473 struct proc *p; 474 475 p = thr->td_proc; 476 thr = TAILQ_NEXT(thr, td_plist); 477 do { 478 if (thr != NULL) 479 return (thr); 480 p = LIST_NEXT(p, p_list); 481 if (p != NULL && (p->p_flag & P_INMEM)) 482 thr = FIRST_THREAD_IN_PROC(p); 483 } while (p != NULL); 484 return (NULL); 485} 486 487int 488kdb_thr_select(struct thread *thr) 489{ 490 if (thr == NULL) 491 return (EINVAL); 492 kdb_thread = thr; 493 kdb_thrctx = kdb_thr_ctx(thr); 494 return (0); 495} 496 497/* 498 * Enter the debugger due to a trap. 499 */ 500 501int 502kdb_trap(int type, int code, struct trapframe *tf) 503{ 504 register_t intr; 505#ifdef SMP 506 int did_stop_cpus; 507#endif 508 int handled; 509 510 if (kdb_dbbe == NULL || kdb_dbbe->dbbe_trap == NULL) 511 return (0); 512 513 /* We reenter the debugger through kdb_reenter(). */ 514 if (kdb_active) 515 return (0); 516 517 intr = intr_disable(); 518 519#ifdef SMP 520 if ((did_stop_cpus = kdb_stop_cpus) != 0) 521 stop_cpus(PCPU_GET(other_cpus)); 522#endif 523 524 kdb_active++; 525 526 kdb_frame = tf; 527 528 /* Let MD code do its thing first... */ 529 kdb_cpu_trap(type, code); 530 531 makectx(tf, &kdb_pcb); 532 kdb_thr_select(curthread); 533 534 handled = kdb_dbbe->dbbe_trap(type, code); 535 536 kdb_active--; 537 538#ifdef SMP 539 if (did_stop_cpus) 540 restart_cpus(stopped_cpus); 541#endif 542 543 intr_restore(intr); 544 545 return (handled); 546} 547