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 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 49 int kdb_active = 0; 50 void *kdb_jmpbufp = NULL; 51 struct kdb_dbbe *kdb_dbbe = NULL; 52 struct pcb kdb_pcb; 53 struct pcb *kdb_thrctx = NULL; 54 struct thread *kdb_thread = NULL; 55 struct trapframe *kdb_frame = NULL; 56 57 KDB_BACKEND(null, NULL, NULL, NULL); 58 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe); 59 60 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS); 61 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS); 62 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS); 63 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS); 64 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS); 65 static int kdb_sysctl_trap_code(SYSCTL_HANDLER_ARGS); 66 67 SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes"); 68 69 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, 0, 0, 70 kdb_sysctl_available, "A", "list of available KDB backends"); 71 72 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, 0, 0, 73 kdb_sysctl_current, "A", "currently selected KDB backend"); 74 75 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 76 kdb_sysctl_enter, "I", "set to enter the debugger"); 77 78 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 79 kdb_sysctl_panic, "I", "set to panic the kernel"); 80 81 SYSCTL_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 84 SYSCTL_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 94 static int kdb_stop_cpus = 1; 95 SYSCTL_INT(_debug_kdb, OID_AUTO, stop_cpus, CTLTYPE_INT | CTLFLAG_RW, 96 &kdb_stop_cpus, 0, "stop other CPUs when entering the debugger"); 97 TUNABLE_INT("debug.kdb.stop_cpus", &kdb_stop_cpus); 98 #endif 99 100 /* 101 * Flag to indicate to debuggers why the debugger was entered. 102 */ 103 const char * volatile kdb_why = KDB_WHY_UNSET; 104 105 static int 106 kdb_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 138 static int 139 kdb_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 157 static int 158 kdb_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 175 static int 176 kdb_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 191 static int 192 kdb_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 207 static int 208 kdb_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 224 void 225 kdb_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 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 int 261 kdb_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 294 void 295 kdb_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 308 int 309 kdb_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 */ 331 void 332 kdb_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 348 void 349 kdb_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 383 void * 384 kdb_jmpbuf(jmp_buf new) 385 { 386 void *old; 387 388 old = kdb_jmpbufp; 389 kdb_jmpbufp = new; 390 return (old); 391 } 392 393 void 394 kdb_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 408 struct pcb * 409 kdb_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 427 struct thread * 428 kdb_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 445 struct thread * 446 kdb_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 459 struct thread * 460 kdb_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 470 struct thread * 471 kdb_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 487 int 488 kdb_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 501 int 502 kdb_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