sys/kern/subr_kdb.c

   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 #if defined (__i386__) || defined(__amd64__) || defined(__sparc64__) || defined(__alpha__)
  47 #define HAVE_STOPPEDPCBS
  48 #include <machine/smp.h>
  49 #endif
  50 #endif
  51
  52 int kdb_active = 0;
  53 void *kdb_jmpbufp = NULL;
  54 struct kdb_dbbe *kdb_dbbe = NULL;
  55 struct pcb kdb_pcb;
  56 struct pcb *kdb_thrctx = NULL;
  57 struct thread *kdb_thread = NULL;
  58 struct trapframe *kdb_frame = NULL;
  59
  60 KDB_BACKEND(null, NULL, NULL, NULL);
  61 SET_DECLARE(kdb_dbbe_set, struct kdb_dbbe);
  62
  63 static int kdb_sysctl_available(SYSCTL_HANDLER_ARGS);
  64 static int kdb_sysctl_current(SYSCTL_HANDLER_ARGS);
  65 static int kdb_sysctl_enter(SYSCTL_HANDLER_ARGS);
  66 static int kdb_sysctl_panic(SYSCTL_HANDLER_ARGS);
  67 static int kdb_sysctl_trap(SYSCTL_HANDLER_ARGS);
  68
  69 SYSCTL_NODE(_debug, OID_AUTO, kdb, CTLFLAG_RW, NULL, "KDB nodes");
  70
  71 SYSCTL_PROC(_debug_kdb, OID_AUTO, available, CTLTYPE_STRING | CTLFLAG_RD, 0, 0,
  72     kdb_sysctl_available, "A", "list of available KDB backends");
  73
  74 SYSCTL_PROC(_debug_kdb, OID_AUTO, current, CTLTYPE_STRING | CTLFLAG_RW, 0, 0,
  75     kdb_sysctl_current, "A", "currently selected KDB backend");
  76
  77 SYSCTL_PROC(_debug_kdb, OID_AUTO, enter, CTLTYPE_INT | CTLFLAG_RW, 0, 0,
  78     kdb_sysctl_enter, "I", "set to enter the debugger");
  79
  80 SYSCTL_PROC(_debug_kdb, OID_AUTO, panic, CTLTYPE_INT | CTLFLAG_RW, 0, 0,
  81     kdb_sysctl_panic, "I", "set to panic the kernel");
  82
  83 SYSCTL_PROC(_debug_kdb, OID_AUTO, trap, CTLTYPE_INT | CTLFLAG_RW, 0, 0,
  84     kdb_sysctl_trap, "I", "set cause a page fault");
  85
  86 /*
  87  * Flag indicating whether or not to IPI the other CPUs to stop them on
  88  * entering the debugger.  Sometimes, this will result in a deadlock as
  89  * stop_cpus() waits for the other cpus to stop, so we allow it to be
  90  * disabled.
  91  */
  92 #ifdef SMP
  93 static int kdb_stop_cpus = 1;
  94 SYSCTL_INT(_debug_kdb, OID_AUTO, stop_cpus, CTLTYPE_INT | CTLFLAG_RW,
  95     &kdb_stop_cpus, 0, "");
  96 TUNABLE_INT("debug.kdb.stop_cpus", &kdb_stop_cpus);
  97 #endif
  98
  99 static int
 100 kdb_sysctl_available(SYSCTL_HANDLER_ARGS)
 101 {
 102         struct kdb_dbbe *be, **iter;
 103         char *avail, *p;
 104         ssize_t len, sz;
 105         int error;
 106
 107         sz = 0;
 108         SET_FOREACH(iter, kdb_dbbe_set) {
 109                 be = *iter;
 110                 if (be->dbbe_active == 0)
 111                         sz += strlen(be->dbbe_name) + 1;
 112         }
 113         sz++;
 114         avail = malloc(sz, M_TEMP, M_WAITOK);
 115         p = avail;
 116         *p = '\0';
 117
 118         SET_FOREACH(iter, kdb_dbbe_set) {
 119                 be = *iter;
 120                 if (be->dbbe_active == 0) {
 121                         len = snprintf(p, sz, "%s ", be->dbbe_name);
 122                         p += len;
 123                         sz -= len;
 124                 }
 125         }
 126         KASSERT(sz >= 0, ("%s", __func__));
 127         error = sysctl_handle_string(oidp, avail, 0, req);
 128         free(avail, M_TEMP);
 129         return (error);
 130 }
 131
 132 static int
 133 kdb_sysctl_current(SYSCTL_HANDLER_ARGS)
 134 {
 135         char buf[16];
 136         int error;
 137
 138         if (kdb_dbbe != NULL) {
 139                 strncpy(buf, kdb_dbbe->dbbe_name, sizeof(buf));
 140                 buf[sizeof(buf) - 1] = '\0';
 141         } else
 142                 *buf = '\0';
 143         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 144         if (error != 0 || req->newptr == NULL)
 145                 return (error);
 146         if (kdb_active)
 147                 return (EBUSY);
 148         return (kdb_dbbe_select(buf));
 149 }
 150
 151 static int
 152 kdb_sysctl_enter(SYSCTL_HANDLER_ARGS)
 153 {
 154         int error, i;
 155
 156         error = sysctl_wire_old_buffer(req, sizeof(int));
 157         if (error == 0) {
 158                 i = 0;
 159                 error = sysctl_handle_int(oidp, &i, 0, req);
 160         }
 161         if (error != 0 || req->newptr == NULL)
 162                 return (error);
 163         if (kdb_active)
 164                 return (EBUSY);
 165         kdb_enter("sysctl debug.kdb.enter");
 166         return (0);
 167 }
 168
 169 static int
 170 kdb_sysctl_panic(SYSCTL_HANDLER_ARGS)
 171 {
 172         int error, i;
 173
 174         error = sysctl_wire_old_buffer(req, sizeof(int));
 175         if (error == 0) {
 176                 i = 0;
 177                 error = sysctl_handle_int(oidp, &i, 0, req);
 178         }
 179         if (error != 0 || req->newptr == NULL)
 180                 return (error);
 181         panic("kdb_sysctl_panic");
 182         return (0);
 183 }
 184
 185 static int
 186 kdb_sysctl_trap(SYSCTL_HANDLER_ARGS)
 187 {
 188         int error, i;
 189         int *addr = (int *)0x10;
 190
 191         error = sysctl_wire_old_buffer(req, sizeof(int));
 192         if (error == 0) {
 193                 i = 0;
 194                 error = sysctl_handle_int(oidp, &i, 0, req);
 195         }
 196         if (error != 0 || req->newptr == NULL)
 197                 return (error);
 198         return (*addr);
 199 }
 200
 201 /*
 202  * Solaris implements a new BREAK which is initiated by a character sequence
 203  * CR ~ ^b which is similar to a familiar pattern used on Sun servers by the
 204  * Remote Console.
 205  *
 206  * Note that this function may be called from almost anywhere, with interrupts
 207  * disabled and with unknown locks held, so it must not access data other than
 208  * its arguments.  Its up to the caller to ensure that the state variable is
 209  * consistent.
 210  */
 211
 212 #define KEY_CR          13      /* CR '\r' */
 213 #define KEY_TILDE       126     /* ~ */
 214 #define KEY_CRTLB       2       /* ^B */
 215
 216 int
 217 kdb_alt_break(int key, int *state)
 218 {
 219         int brk;
 220
 221         brk = 0;
 222         switch (key) {
 223         case KEY_CR:
 224                 *state = KEY_TILDE;
 225                 break;
 226         case KEY_TILDE:
 227                 *state = (*state == KEY_TILDE) ? KEY_CRTLB : 0;
 228                 break;
 229         case KEY_CRTLB:
 230                 if (*state == KEY_CRTLB)
 231                         brk = 1;
 232                 /* FALLTHROUGH */
 233         default:
 234                 *state = 0;
 235                 break;
 236         }
 237         return (brk);
 238 }
 239
 240 /*
 241  * Print a backtrace of the calling thread. The backtrace is generated by
 242  * the selected debugger, provided it supports backtraces. If no debugger
 243  * is selected or the current debugger does not support backtraces, this
 244  * function silently returns.
 245  */
 246
 247 void
 248 kdb_backtrace()
 249 {
 250
 251         if (kdb_dbbe != NULL && kdb_dbbe->dbbe_trace != NULL) {
 252                 printf("KDB: stack backtrace:\n");
 253                 kdb_dbbe->dbbe_trace();
 254         }
 255 }
 256
 257 /*
 258  * Set/change the current backend.
 259  */
 260
 261 int
 262 kdb_dbbe_select(const char *name)
 263 {
 264         struct kdb_dbbe *be, **iter;
 265
 266         SET_FOREACH(iter, kdb_dbbe_set) {
 267                 be = *iter;
 268                 if (be->dbbe_active == 0 && strcmp(be->dbbe_name, name) == 0) {
 269                         kdb_dbbe = be;
 270                         return (0);
 271                 }
 272         }
 273         return (EINVAL);
 274 }
 275
 276 /*
 277  * Enter the currently selected debugger. If a message has been provided,
 278  * it is printed first. If the debugger does not support the enter method,
 279  * it is entered by using breakpoint(), which enters the debugger through
 280  * kdb_trap().
 281  */
 282
 283 void
 284 kdb_enter(const char *msg)
 285 {
 286
 287         if (kdb_dbbe != NULL && kdb_active == 0) {
 288                 if (msg != NULL)
 289                         printf("KDB: enter: %s\n", msg);
 290                 breakpoint();
 291         }
 292 }
 293
 294 /*
 295  * Initialize the kernel debugger interface.
 296  */
 297
 298 void
 299 kdb_init()
 300 {
 301         struct kdb_dbbe *be, **iter;
 302         int cur_pri, pri;
 303
 304         kdb_active = 0;
 305         kdb_dbbe = NULL;
 306         cur_pri = -1;
 307         SET_FOREACH(iter, kdb_dbbe_set) {
 308                 be = *iter;
 309                 pri = (be->dbbe_init != NULL) ? be->dbbe_init() : -1;
 310                 be->dbbe_active = (pri >= 0) ? 0 : -1;
 311                 if (pri > cur_pri) {
 312                         cur_pri = pri;
 313                         kdb_dbbe = be;
 314                 }
 315         }
 316         if (kdb_dbbe != NULL) {
 317                 printf("KDB: debugger backends:");
 318                 SET_FOREACH(iter, kdb_dbbe_set) {
 319                         be = *iter;
 320                         if (be->dbbe_active == 0)
 321                                 printf(" %s", be->dbbe_name);
 322                 }
 323                 printf("\n");
 324                 printf("KDB: current backend: %s\n",
 325                     kdb_dbbe->dbbe_name);
 326         }
 327 }
 328
 329 /*
 330  * Handle contexts.
 331  */
 332
 333 void *
 334 kdb_jmpbuf(jmp_buf new)
 335 {
 336         void *old;
 337
 338         old = kdb_jmpbufp;
 339         kdb_jmpbufp = new;
 340         return (old);
 341 }
 342
 343 void
 344 kdb_reenter(void)
 345 {
 346
 347         if (!kdb_active || kdb_jmpbufp == NULL)
 348                 return;
 349
 350         longjmp(kdb_jmpbufp, 1);
 351         /* NOTREACHED */
 352 }
 353
 354 /*
 355  * Thread related support functions.
 356  */
 357
 358 struct pcb *
 359 kdb_thr_ctx(struct thread *thr)
 360 {
 361 #ifdef HAVE_STOPPEDPCBS
 362         struct pcpu *pc;
 363         u_int cpuid;
 364 #endif
 365
 366         if (thr == curthread)
 367                 return (&kdb_pcb);
 368
 369 #ifdef HAVE_STOPPEDPCBS
 370         SLIST_FOREACH(pc, &cpuhead, pc_allcpu)  {
 371                 cpuid = pc->pc_cpuid;
 372                 if (pc->pc_curthread == thr && (stopped_cpus & (1 << cpuid)))
 373                         return (&stoppcbs[cpuid]);
 374         }
 375 #endif
 376         return (thr->td_pcb);
 377 }
 378
 379 struct thread *
 380 kdb_thr_first(void)
 381 {
 382         struct proc *p;
 383         struct thread *thr;
 384
 385         p = LIST_FIRST(&allproc);
 386         while (p != NULL) {
 387                 if (p->p_sflag & PS_INMEM) {
 388                         thr = FIRST_THREAD_IN_PROC(p);
 389                         if (thr != NULL)
 390                                 return (thr);
 391                 }
 392                 p = LIST_NEXT(p, p_list);
 393         }
 394         return (NULL);
 395 }
 396
 397 struct thread *
 398 kdb_thr_from_pid(pid_t pid)
 399 {
 400         struct proc *p;
 401
 402         p = LIST_FIRST(&allproc);
 403         while (p != NULL) {
 404                 if (p->p_sflag & PS_INMEM && p->p_pid == pid)
 405                         return (FIRST_THREAD_IN_PROC(p));
 406                 p = LIST_NEXT(p, p_list);
 407         }
 408         return (NULL);
 409 }
 410
 411 struct thread *
 412 kdb_thr_lookup(lwpid_t tid)
 413 {
 414         struct thread *thr;
 415
 416         thr = kdb_thr_first();
 417         while (thr != NULL && thr->td_tid != tid)
 418                 thr = kdb_thr_next(thr);
 419         return (thr);
 420 }
 421
 422 struct thread *
 423 kdb_thr_next(struct thread *thr)
 424 {
 425         struct proc *p;
 426
 427         p = thr->td_proc;
 428         thr = TAILQ_NEXT(thr, td_plist);
 429         do {
 430                 if (thr != NULL)
 431                         return (thr);
 432                 p = LIST_NEXT(p, p_list);
 433                 if (p != NULL && (p->p_sflag & PS_INMEM))
 434                         thr = FIRST_THREAD_IN_PROC(p);
 435         } while (p != NULL);
 436         return (NULL);
 437 }
 438
 439 int
 440 kdb_thr_select(struct thread *thr)
 441 {
 442         if (thr == NULL)
 443                 return (EINVAL);
 444         kdb_thread = thr;
 445         kdb_thrctx = kdb_thr_ctx(thr);
 446         return (0);
 447 }
 448
 449 /*
 450  * Enter the debugger due to a trap.
 451  */
 452
 453 int
 454 kdb_trap(int type, int code, struct trapframe *tf)
 455 {
 456 #ifdef SMP
 457         int did_stop_cpus;
 458 #endif
 459         int handled;
 460
 461         if (kdb_dbbe == NULL || kdb_dbbe->dbbe_trap == NULL)
 462                 return (0);
 463
 464         /* We reenter the debugger through kdb_reenter(). */
 465         if (kdb_active)
 466                 return (0);
 467
 468         critical_enter();
 469
 470         kdb_active++;
 471
 472 #ifdef SMP
 473         if ((did_stop_cpus = kdb_stop_cpus) != 0)
 474                 stop_cpus(PCPU_GET(other_cpus));
 475 #endif
 476
 477         kdb_frame = tf;
 478
 479         /* Let MD code do its thing first... */
 480         kdb_cpu_trap(type, code);
 481
 482         makectx(tf, &kdb_pcb);
 483         kdb_thr_select(curthread);
 484
 485         handled = kdb_dbbe->dbbe_trap(type, code);
 486
 487 #ifdef SMP
 488         if (did_stop_cpus)
 489                 restart_cpus(stopped_cpus);
 490 #endif
 491
 492         kdb_active--;
 493
 494         critical_exit();
 495
 496         return (handled);
 497 }