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$"); 29 30 #include "opt_kdb.h" 31 #include "opt_stack.h" 32 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/cons.h> 36 #include <sys/kdb.h> 37 #include <sys/kernel.h> 38 #include <sys/malloc.h> 39 #include <sys/pcpu.h> 40 #include <sys/proc.h> 41 #include <sys/sbuf.h> 42 #include <sys/smp.h> 43 #include <sys/stack.h> 44 #include <sys/sysctl.h> 45 46 #include <machine/kdb.h> 47 #include <machine/pcb.h> 48 49 #ifdef SMP 50 #include <machine/smp.h> 51 #endif 52 53 int kdb_active = 0; 54 static void *kdb_jmpbufp = NULL; 55 struct kdb_dbbe *kdb_dbbe = NULL; 56 static struct pcb kdb_pcb; 57 struct pcb *kdb_thrctx = NULL; 58 struct thread *kdb_thread = NULL; 59 struct trapframe *kdb_frame = NULL; 60 61 #ifdef BREAK_TO_DEBUGGER 62 #define KDB_BREAK_TO_DEBUGGER 1 63 #else 64 #define KDB_BREAK_TO_DEBUGGER 0 65 #endif 66 67 #ifdef ALT_BREAK_TO_DEBUGGER 68 #define KDB_ALT_BREAK_TO_DEBUGGER 1 69 #else 70 #define KDB_ALT_BREAK_TO_DEBUGGER 0 71 #endif 72 73 static int kdb_break_to_debugger = KDB_BREAK_TO_DEBUGGER; 74 static int kdb_alt_break_to_debugger = KDB_ALT_BREAK_TO_DEBUGGER; 75 76 KDB_BACKEND(null, NULL, NULL, NULL, NULL); 77 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe); 78 79 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS); 80 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS); 81 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS); 82 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS); 83 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS); 84 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS); 85 86 static SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes"); 87 88 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, NULL, 89 0, kdb_sysctl_available, "A", "list of available KDB backends"); 90 91 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, NULL, 92 0, kdb_sysctl_current, "A", "currently selected KDB backend"); 93 94 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter, 95 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0, 96 kdb_sysctl_enter, "I", "set to enter the debugger"); 97 98 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic, 99 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0, 100 kdb_sysctl_panic, "I", "set to panic the kernel"); 101 102 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap, 103 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0, 104 kdb_sysctl_trap, "I", "set to cause a page fault via data access"); 105 106 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap_code, 107 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE, NULL, 0, 108 kdb_sysctl_trap_code, "I", "set to cause a page fault via code access"); 109 110 SYSCTL_INT(_debug_kdb, OID_AUTO, break_to_debugger, 111 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_TUN | CTLFLAG_SECURE, 112 &kdb_break_to_debugger, 0, "Enable break to debugger"); 113 TUNABLE_INT("debug.kdb.break_to_debugger", &kdb_break_to_debugger); 114 115 SYSCTL_INT(_debug_kdb, OID_AUTO, alt_break_to_debugger, 116 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_TUN | CTLFLAG_SECURE, 117 &kdb_alt_break_to_debugger, 0, "Enable alternative break to debugger"); 118 TUNABLE_INT("debug.kdb.alt_break_to_debugger", &kdb_alt_break_to_debugger); 119 120 /* 121 * Flag to indicate to debuggers why the debugger was entered. 122 */ 123 const char * volatile kdb_why = KDB_WHY_UNSET; 124 125 static int 126 kdb_sysctl_available(SYSCTL_HANDLER_ARGS) 127 { 128 struct kdb_dbbe **iter; 129 struct sbuf sbuf; 130 int error; 131 132 sbuf_new_for_sysctl(&sbuf, NULL, 64, req); 133 SET_FOREACH(iter, kdb_dbbe_set) { 134 if ((*iter)->dbbe_active == 0) 135 sbuf_printf(&sbuf, "%s ", (*iter)->dbbe_name); 136 } 137 error = sbuf_finish(&sbuf); 138 sbuf_delete(&sbuf); 139 return (error); 140 } 141 142 static int 143 kdb_sysctl_current(SYSCTL_HANDLER_ARGS) 144 { 145 char buf[16]; 146 int error; 147 148 if (kdb_dbbe != NULL) 149 strlcpy(buf, kdb_dbbe->dbbe_name, sizeof(buf)); 150 else 151 *buf = '\0'; 152 error = sysctl_handle_string(oidp, buf, sizeof(buf), req); 153 if (error != 0 || req->newptr == NULL) 154 return (error); 155 if (kdb_active) 156 return (EBUSY); 157 return (kdb_dbbe_select(buf)); 158 } 159 160 static int 161 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS) 162 { 163 int error, i; 164 165 error = sysctl_wire_old_buffer(req, sizeof(int)); 166 if (error == 0) { 167 i = 0; 168 error = sysctl_handle_int(oidp, &i, 0, req); 169 } 170 if (error != 0 || req->newptr == NULL) 171 return (error); 172 if (kdb_active) 173 return (EBUSY); 174 kdb_enter(KDB_WHY_SYSCTL, "sysctl debug.kdb.enter"); 175 return (0); 176 } 177 178 static int 179 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS) 180 { 181 int error, i; 182 183 error = sysctl_wire_old_buffer(req, sizeof(int)); 184 if (error == 0) { 185 i = 0; 186 error = sysctl_handle_int(oidp, &i, 0, req); 187 } 188 if (error != 0 || req->newptr == NULL) 189 return (error); 190 panic("kdb_sysctl_panic"); 191 return (0); 192 } 193 194 static int 195 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS) 196 { 197 int error, i; 198 int *addr = (int *)0x10; 199 200 error = sysctl_wire_old_buffer(req, sizeof(int)); 201 if (error == 0) { 202 i = 0; 203 error = sysctl_handle_int(oidp, &i, 0, req); 204 } 205 if (error != 0 || req->newptr == NULL) 206 return (error); 207 return (*addr); 208 } 209 210 static int 211 kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS) 212 { 213 int error, i; 214 void (*fp)(u_int, u_int, u_int) = (void *)0xdeadc0de; 215 216 error = sysctl_wire_old_buffer(req, sizeof(int)); 217 if (error == 0) { 218 i = 0; 219 error = sysctl_handle_int(oidp, &i, 0, req); 220 } 221 if (error != 0 || req->newptr == NULL) 222 return (error); 223 (*fp)(0x11111111, 0x22222222, 0x33333333); 224 return (0); 225 } 226 227 void 228 kdb_panic(const char *msg) 229 { 230 231 printf("KDB: panic\n"); 232 panic("%s", msg); 233 } 234 235 void 236 kdb_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 260 /* States of th KDB "alternate break sequence" detecting state machine. */ 261 enum { 262 KDB_ALT_BREAK_SEEN_NONE, 263 KDB_ALT_BREAK_SEEN_CR, 264 KDB_ALT_BREAK_SEEN_CR_TILDE, 265 }; 266 267 int 268 kdb_break(void) 269 { 270 271 if (!kdb_break_to_debugger) 272 return (0); 273 kdb_enter(KDB_WHY_BREAK, "Break to debugger"); 274 return (KDB_REQ_DEBUGGER); 275 } 276 277 static int 278 kdb_alt_break_state(int key, int *state) 279 { 280 int brk; 281 282 /* All states transition to KDB_ALT_BREAK_SEEN_CR on a CR. */ 283 if (key == KEY_CR) { 284 *state = KDB_ALT_BREAK_SEEN_CR; 285 return (0); 286 } 287 288 brk = 0; 289 switch (*state) { 290 case KDB_ALT_BREAK_SEEN_CR: 291 *state = KDB_ALT_BREAK_SEEN_NONE; 292 if (key == KEY_TILDE) 293 *state = KDB_ALT_BREAK_SEEN_CR_TILDE; 294 break; 295 case KDB_ALT_BREAK_SEEN_CR_TILDE: 296 *state = KDB_ALT_BREAK_SEEN_NONE; 297 if (key == KEY_CRTLB) 298 brk = KDB_REQ_DEBUGGER; 299 else if (key == KEY_CRTLP) 300 brk = KDB_REQ_PANIC; 301 else if (key == KEY_CRTLR) 302 brk = KDB_REQ_REBOOT; 303 break; 304 case KDB_ALT_BREAK_SEEN_NONE: 305 default: 306 *state = KDB_ALT_BREAK_SEEN_NONE; 307 break; 308 } 309 return (brk); 310 } 311 312 static int 313 kdb_alt_break_internal(int key, int *state, int force_gdb) 314 { 315 int brk; 316 317 if (!kdb_alt_break_to_debugger) 318 return (0); 319 brk = kdb_alt_break_state(key, state); 320 switch (brk) { 321 case KDB_REQ_DEBUGGER: 322 if (force_gdb) 323 kdb_dbbe_select("gdb"); 324 kdb_enter(KDB_WHY_BREAK, "Break to debugger"); 325 break; 326 327 case KDB_REQ_PANIC: 328 if (force_gdb) 329 kdb_dbbe_select("gdb"); 330 kdb_panic("Panic sequence on console"); 331 break; 332 333 case KDB_REQ_REBOOT: 334 kdb_reboot(); 335 break; 336 } 337 return (0); 338 } 339 340 int 341 kdb_alt_break(int key, int *state) 342 { 343 344 return (kdb_alt_break_internal(key, state, 0)); 345 } 346 347 /* 348 * This variation on kdb_alt_break() is used only by dcons, which has its own 349 * configuration flag to force GDB use regardless of the global KDB 350 * configuration. 351 */ 352 int 353 kdb_alt_break_gdb(int key, int *state) 354 { 355 356 return (kdb_alt_break_internal(key, state, 1)); 357 } 358 359 /* 360 * Print a backtrace of the calling thread. The backtrace is generated by 361 * the selected debugger, provided it supports backtraces. If no debugger 362 * is selected or the current debugger does not support backtraces, this 363 * function silently returns. 364 */ 365 366 void 367 kdb_backtrace(void) 368 { 369 370 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) { 371 printf("KDB: stack backtrace:\n"); 372 kdb_dbbe->dbbe_trace(); 373 } 374 #ifdef STACK 375 else { 376 struct stack st; 377 378 printf("KDB: stack backtrace:\n"); 379 stack_zero(&st); 380 stack_save(&st); 381 stack_print_ddb(&st); 382 } 383 #endif 384 } 385 386 /* 387 * Similar to kdb_backtrace() except that it prints a backtrace of an 388 * arbitrary thread rather than the calling thread. 389 */ 390 void 391 kdb_backtrace_thread(struct thread *td) 392 { 393 394 if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace_thread != NULL) { 395 printf("KDB: stack backtrace of thread %d:\n", td->td_tid); 396 kdb_dbbe->dbbe_trace_thread(td); 397 } 398 #ifdef STACK 399 else { 400 struct stack st; 401 402 printf("KDB: stack backtrace of thread %d:\n", td->td_tid); 403 stack_zero(&st); 404 stack_save_td(&st, td); 405 stack_print_ddb(&st); 406 } 407 #endif 408 } 409 410 /* 411 * Set/change the current backend. 412 */ 413 414 int 415 kdb_dbbe_select(const char *name) 416 { 417 struct kdb_dbbe *be, **iter; 418 419 SET_FOREACH(iter, kdb_dbbe_set) { 420 be = *iter; 421 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) { 422 kdb_dbbe = be; 423 return (0); 424 } 425 } 426 return (EINVAL); 427 } 428 429 /* 430 * Enter the currently selected debugger. If a message has been provided, 431 * it is printed first. If the debugger does not support the enter method, 432 * it is entered by using breakpoint(), which enters the debugger through 433 * kdb_trap(). The 'why' argument will contain a more mechanically usable 434 * string than 'msg', and is relied upon by DDB scripting to identify the 435 * reason for entering the debugger so that the right script can be run. 436 */ 437 void 438 kdb_enter(const char *why, const char *msg) 439 { 440 441 if (kdb_dbbe != NULL && kdb_active == 0) { 442 if (msg != NULL) 443 printf("KDB: enter: %s\n", msg); 444 kdb_why = why; 445 breakpoint(); 446 kdb_why = KDB_WHY_UNSET; 447 } 448 } 449 450 /* 451 * Initialize the kernel debugger interface. 452 */ 453 454 void 455 kdb_init(void) 456 { 457 struct kdb_dbbe *be, **iter; 458 int cur_pri, pri; 459 460 kdb_active = 0; 461 kdb_dbbe = NULL; 462 cur_pri = -1; 463 SET_FOREACH(iter, kdb_dbbe_set) { 464 be = *iter; 465 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1; 466 be->dbbe_active = (pri >= 0) ? 0 : -1; 467 if (pri > cur_pri) { 468 cur_pri = pri; 469 kdb_dbbe = be; 470 } 471 } 472 if (kdb_dbbe != NULL) { 473 printf("KDB: debugger backends:"); 474 SET_FOREACH(iter, kdb_dbbe_set) { 475 be = *iter; 476 if (be->dbbe_active == 0) 477 printf(" %s", be->dbbe_name); 478 } 479 printf("\n"); 480 printf("KDB: current backend: %s\n", 481 kdb_dbbe->dbbe_name); 482 } 483 } 484 485 /* 486 * Handle contexts. 487 */ 488 489 void * 490 kdb_jmpbuf(jmp_buf new) 491 { 492 void *old; 493 494 old = kdb_jmpbufp; 495 kdb_jmpbufp = new; 496 return (old); 497 } 498 499 void 500 kdb_reenter(void) 501 { 502 503 if (!kdb_active || kdb_jmpbufp == NULL) 504 return; 505 506 longjmp(kdb_jmpbufp, 1); 507 /* NOTREACHED */ 508 } 509 510 /* 511 * Thread related support functions. 512 */ 513 514 struct pcb * 515 kdb_thr_ctx(struct thread *thr) 516 { 517 #if defined(SMP) && defined(KDB_STOPPEDPCB) 518 struct pcpu *pc; 519 #endif 520 521 if (thr == curthread) 522 return (&kdb_pcb); 523 524 #if defined(SMP) && defined(KDB_STOPPEDPCB) 525 STAILQ_FOREACH(pc, &cpuhead, pc_allcpu) { 526 if (pc->pc_curthread == thr && 527 CPU_ISSET(pc->pc_cpuid, &stopped_cpus)) 528 return (KDB_STOPPEDPCB(pc)); 529 } 530 #endif 531 return (thr->td_pcb); 532 } 533 534 struct thread * 535 kdb_thr_first(void) 536 { 537 struct proc *p; 538 struct thread *thr; 539 540 p = LIST_FIRST(&allproc); 541 while (p != NULL) { 542 if (p->p_flag & P_INMEM) { 543 thr = FIRST_THREAD_IN_PROC(p); 544 if (thr != NULL) 545 return (thr); 546 } 547 p = LIST_NEXT(p, p_list); 548 } 549 return (NULL); 550 } 551 552 struct thread * 553 kdb_thr_from_pid(pid_t pid) 554 { 555 struct proc *p; 556 557 p = LIST_FIRST(&allproc); 558 while (p != NULL) { 559 if (p->p_flag & P_INMEM && p->p_pid == pid) 560 return (FIRST_THREAD_IN_PROC(p)); 561 p = LIST_NEXT(p, p_list); 562 } 563 return (NULL); 564 } 565 566 struct thread * 567 kdb_thr_lookup(lwpid_t tid) 568 { 569 struct thread *thr; 570 571 thr = kdb_thr_first(); 572 while (thr != NULL && thr->td_tid != tid) 573 thr = kdb_thr_next(thr); 574 return (thr); 575 } 576 577 struct thread * 578 kdb_thr_next(struct thread *thr) 579 { 580 struct proc *p; 581 582 p = thr->td_proc; 583 thr = TAILQ_NEXT(thr, td_plist); 584 do { 585 if (thr != NULL) 586 return (thr); 587 p = LIST_NEXT(p, p_list); 588 if (p != NULL && (p->p_flag & P_INMEM)) 589 thr = FIRST_THREAD_IN_PROC(p); 590 } while (p != NULL); 591 return (NULL); 592 } 593 594 int 595 kdb_thr_select(struct thread *thr) 596 { 597 if (thr == NULL) 598 return (EINVAL); 599 kdb_thread = thr; 600 kdb_thrctx = kdb_thr_ctx(thr); 601 return (0); 602 } 603 604 /* 605 * Enter the debugger due to a trap. 606 */ 607 608 int 609 kdb_trap(int type, int code, struct trapframe *tf) 610 { 611 #ifdef SMP 612 cpuset_t other_cpus; 613 #endif 614 struct kdb_dbbe *be; 615 register_t intr; 616 int handled; 617 #ifdef SMP 618 int did_stop_cpus; 619 #endif 620 621 be = kdb_dbbe; 622 if (be == NULL || be->dbbe_trap == NULL) 623 return (0); 624 625 /* We reenter the debugger through kdb_reenter(). */ 626 if (kdb_active) 627 return (0); 628 629 intr = intr_disable(); 630 631 #ifdef SMP 632 if (!SCHEDULER_STOPPED()) { 633 other_cpus = all_cpus; 634 CPU_CLR(PCPU_GET(cpuid), &other_cpus); 635 stop_cpus_hard(other_cpus); 636 did_stop_cpus = 1; 637 } else 638 did_stop_cpus = 0; 639 #endif 640 641 kdb_active++; 642 643 kdb_frame = tf; 644 645 /* Let MD code do its thing first... */ 646 kdb_cpu_trap(type, code); 647 648 makectx(tf, &kdb_pcb); 649 kdb_thr_select(curthread); 650 651 cngrab(); 652 653 for (;;) { 654 handled = be->dbbe_trap(type, code); 655 if (be == kdb_dbbe) 656 break; 657 be = kdb_dbbe; 658 if (be == NULL || be->dbbe_trap == NULL) 659 break; 660 printf("Switching to %s back-end\n", be->dbbe_name); 661 } 662 663 cnungrab(); 664 665 kdb_active--; 666 667 #ifdef SMP 668 if (did_stop_cpus) 669 restart_cpus(stopped_cpus); 670 #endif 671 672 intr_restore(intr); 673 674 return (handled); 675 } 676