1/* 2 * Copyright (c) 2004 Marcel Moolenaar 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 AUTHOR ``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 AUTHOR 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 <sys/param.h> 31#include <sys/stat.h> 32#include <sys/types.h> 33#include <sys/ioctl.h> 34#include <sys/resource.h> 35#include <sys/select.h> 36#include <sys/time.h> 37#include <sys/wait.h> 38#include <errno.h> 39#include <err.h> 40#include <inttypes.h> 41#include <kvm.h> 42#include <limits.h> 43#include <paths.h> 44#include <stdio.h> 45#include <stdlib.h> 46#include <string.h> 47#include <unistd.h> 48 49/* libgdb stuff. */ 50#include <defs.h> 51#include <frame.h> 52#include <frame-unwind.h> 53#include <inferior.h> 54#include <interps.h> 55#include <cli-out.h> 56#include <main.h> 57#include <objfiles.h> 58#include <target.h> 59#include <top.h> 60#include <ui-file.h> 61#include <bfd.h> 62#include <gdbcore.h> 63#include <wrapper.h> 64 65extern frame_unwind_sniffer_ftype *kgdb_sniffer_kluge; 66 67#include "kgdb.h" 68 69static int dumpnr; 70static int quiet; 71static int verbose; 72 73static char crashdir[PATH_MAX]; 74static char *kernel; 75static char *remote; 76static char *vmcore; 77static struct ui_file *parse_gdberr; 78 79static void (*kgdb_new_objfile_chain)(struct objfile * objfile); 80 81static void 82usage(void) 83{ 84 85 fprintf(stderr, 86 "usage: %s [-afqvw] [-b rate] [-d crashdir] [-c core | -n dumpnr | -r device]\n" 87 "\t[kernel [core]]\n", getprogname()); 88 exit(1); 89} 90 91static void 92kernel_from_dumpnr(int nr) 93{ 94 char path[PATH_MAX]; 95 FILE *info; 96 char *s; 97 struct stat st; 98 int l; 99 100 /* 101 * If there's a kernel image right here in the crash directory, then 102 * use it. The kernel image is either called kernel.<nr> or is in a 103 * subdirectory kernel.<nr> and called kernel. The latter allows us 104 * to collect the modules in the same place. 105 */ 106 snprintf(path, sizeof(path), "%s/kernel.%d", crashdir, nr); 107 if (stat(path, &st) == 0) { 108 if (S_ISREG(st.st_mode)) { 109 kernel = strdup(path); 110 return; 111 } 112 if (S_ISDIR(st.st_mode)) { 113 snprintf(path, sizeof(path), "%s/kernel.%d/kernel", 114 crashdir, nr); 115 if (stat(path, &st) == 0 && S_ISREG(st.st_mode)) { 116 kernel = strdup(path); 117 return; 118 } 119 } 120 } 121 122 /* 123 * No kernel image here. Parse the dump header. The kernel object 124 * directory can be found there and we probably have the kernel 125 * image still in it. The object directory may also have a kernel 126 * with debugging info (called kernel.debug). If we have a debug 127 * kernel, use it. 128 */ 129 snprintf(path, sizeof(path), "%s/info.%d", crashdir, nr); 130 info = fopen(path, "r"); 131 if (info == NULL) { 132 warn("%s", path); 133 return; 134 } 135 while (fgets(path, sizeof(path), info) != NULL) { 136 l = strlen(path); 137 if (l > 0 && path[l - 1] == '\n') 138 path[--l] = '\0'; 139 if (strncmp(path, " ", 4) == 0) { 140 s = strchr(path, ':'); 141 s = (s == NULL) ? path + 4 : s + 1; 142 l = snprintf(path, sizeof(path), "%s/kernel.debug", s); 143 if (stat(path, &st) == -1 || !S_ISREG(st.st_mode)) { 144 path[l - 6] = '\0'; 145 if (stat(path, &st) == -1 || 146 !S_ISREG(st.st_mode)) 147 break; 148 } 149 kernel = strdup(path); 150 break; 151 } 152 } 153 fclose(info); 154} 155 156static void 157kgdb_new_objfile(struct objfile *objfile) 158{ 159 static int once = 1; 160 161 kld_new_objfile(objfile); 162 kgdb_trgt_new_objfile(objfile); 163 164 if (kgdb_new_objfile_chain != NULL) 165 kgdb_new_objfile_chain(objfile); 166 167 if (once && objfile != NULL && objfile == symfile_objfile) { 168 /* 169 * The initial kernel has just been loaded. Start the 170 * remote target if we have one. 171 */ 172 once = 0; 173 if (remote != NULL) 174 push_remote_target (remote, 0); 175 } 176} 177 178/* 179 * Parse an expression and return its value. If 'quiet' is true, then 180 * any error messages from the parser are masked. 181 */ 182CORE_ADDR 183kgdb_parse_1(const char *exp, int quiet) 184{ 185 struct ui_file *old_stderr; 186 struct cleanup *old_chain; 187 struct expression *expr; 188 struct value *val; 189 char *s; 190 CORE_ADDR n; 191 192 old_stderr = gdb_stderr; 193 if (quiet) 194 gdb_stderr = parse_gdberr; 195 n = 0; 196 s = xstrdup(exp); 197 old_chain = make_cleanup(xfree, s); 198 if (gdb_parse_exp_1(&s, NULL, 0, &expr) && *s == '\0') { 199 make_cleanup(free_current_contents, &expr); 200 if (gdb_evaluate_expression(expr, &val)) 201 n = value_as_address(val); 202 } 203 do_cleanups(old_chain); 204 gdb_stderr = old_stderr; 205 return (n); 206} 207 208#define MSGBUF_SEQ_TO_POS(size, seq) ((seq) % (size)) 209 210void 211kgdb_dmesg(void) 212{ 213 CORE_ADDR bufp; 214 int size, rseq, wseq; 215 char c; 216 217 /* 218 * Display the unread portion of the message buffer. This gives the 219 * user a some initial data to work from. 220 */ 221 if (quiet) 222 return; 223 bufp = kgdb_parse("msgbufp->msg_ptr"); 224 size = (int)kgdb_parse("msgbufp->msg_size"); 225 if (bufp == 0 || size == 0) 226 return; 227 rseq = (int)kgdb_parse("msgbufp->msg_rseq"); 228 wseq = (int)kgdb_parse("msgbufp->msg_wseq"); 229 rseq = MSGBUF_SEQ_TO_POS(size, rseq); 230 wseq = MSGBUF_SEQ_TO_POS(size, wseq); 231 if (rseq == wseq) 232 return; 233 234 printf("\nUnread portion of the kernel message buffer:\n"); 235 while (rseq < wseq) { 236 read_memory(bufp + rseq, &c, 1); 237 putchar(c); 238 rseq++; 239 if (rseq == size) 240 rseq = 0; 241 } 242 if (c != '\n') 243 putchar('\n'); 244 putchar('\n'); 245} 246 247static void 248kgdb_init(char *argv0 __unused) 249{ 250 251 parse_gdberr = mem_fileopen(); 252 set_prompt("(kgdb) "); 253 initialize_kgdb_target(); 254 initialize_kld_target(); 255 kgdb_new_objfile_chain = target_new_objfile_hook; 256 target_new_objfile_hook = kgdb_new_objfile; 257} 258 259/* 260 * Remote targets can support any number of syntaxes and we want to 261 * support them all with one addition: we support specifying a device 262 * node for a serial device without the "/dev/" prefix. 263 * 264 * What we do is to stat(2) the existing remote target first. If that 265 * fails, we try it with "/dev/" prepended. If that succeeds we use 266 * the resulting path, otherwise we use the original target. If 267 * either stat(2) succeeds make sure the file is either a character 268 * device or a FIFO. 269 */ 270static void 271verify_remote(void) 272{ 273 char path[PATH_MAX]; 274 struct stat st; 275 276 if (stat(remote, &st) != 0) { 277 snprintf(path, sizeof(path), "/dev/%s", remote); 278 if (stat(path, &st) != 0) 279 return; 280 free(remote); 281 remote = strdup(path); 282 } 283 if (!S_ISCHR(st.st_mode) && !S_ISFIFO(st.st_mode)) 284 errx(1, "%s: not a special file, FIFO or socket", remote); 285} 286 287static void 288add_arg(struct captured_main_args *args, char *arg) 289{ 290 291 args->argc++; 292 args->argv = reallocf(args->argv, (args->argc + 1) * sizeof(char *)); 293 if (args->argv == NULL) 294 err(1, "Out of memory building argument list"); 295 args->argv[args->argc] = arg; 296} 297 298int 299main(int argc, char *argv[]) 300{ 301 char path[PATH_MAX]; 302 struct stat st; 303 struct captured_main_args args; 304 char *s; 305 int a, ch; 306 307 dumpnr = -1; 308 309 strlcpy(crashdir, "/var/crash", sizeof(crashdir)); 310 s = getenv("KGDB_CRASH_DIR"); 311 if (s != NULL) 312 strlcpy(crashdir, s, sizeof(crashdir)); 313 314 /* Convert long options into short options. */ 315 for (a = 1; a < argc; a++) { 316 s = argv[a]; 317 if (s[0] == '-') { 318 s++; 319 /* Long options take either 1 or 2 dashes. */ 320 if (s[0] == '-') 321 s++; 322 if (strcmp(s, "quiet") == 0) 323 argv[a] = "-q"; 324 else if (strcmp(s, "fullname") == 0) 325 argv[a] = "-f"; 326 } 327 } 328 329 quiet = 0; 330 memset (&args, 0, sizeof args); 331 args.use_windows = 0; 332 args.interpreter_p = INTERP_CONSOLE; 333 args.argv = malloc(sizeof(char *)); 334 args.argv[0] = argv[0]; 335 336 while ((ch = getopt(argc, argv, "ab:c:d:fn:qr:vw")) != -1) { 337 switch (ch) { 338 case 'a': 339 annotation_level++; 340 break; 341 case 'b': { 342 int i; 343 char *p; 344 345 i = strtol(optarg, &p, 0); 346 if (*p != '\0' || p == optarg) 347 warnx("warning: could not set baud rate to `%s'.\n", 348 optarg); 349 else 350 baud_rate = i; 351 break; 352 } 353 case 'c': /* use given core file. */ 354 if (vmcore != NULL) { 355 warnx("option %c: can only be specified once", 356 optopt); 357 usage(); 358 /* NOTREACHED */ 359 } 360 vmcore = strdup(optarg); 361 break; 362 case 'd': /* lookup dumps in given directory. */ 363 strlcpy(crashdir, optarg, sizeof(crashdir)); 364 break; 365 case 'f': 366 annotation_level = 1; 367 break; 368 case 'n': /* use dump with given number. */ 369 dumpnr = strtol(optarg, &s, 0); 370 if (dumpnr < 0 || *s != '\0') { 371 warnx("option %c: invalid kernel dump number", 372 optopt); 373 usage(); 374 /* NOTREACHED */ 375 } 376 break; 377 case 'q': 378 quiet = 1; 379 add_arg(&args, "-q"); 380 break; 381 case 'r': /* use given device for remote session. */ 382 if (remote != NULL) { 383 warnx("option %c: can only be specified once", 384 optopt); 385 usage(); 386 /* NOTREACHED */ 387 } 388 remote = strdup(optarg); 389 break; 390 case 'v': /* increase verbosity. */ 391 verbose++; 392 break; 393 case 'w': /* core file is writeable. */ 394 add_arg(&args, "--write"); 395 break; 396 case '?': 397 default: 398 usage(); 399 } 400 } 401 402 if (((vmcore != NULL) ? 1 : 0) + ((dumpnr >= 0) ? 1 : 0) + 403 ((remote != NULL) ? 1 : 0) > 1) { 404 warnx("options -c, -n and -r are mutually exclusive"); 405 usage(); 406 /* NOTREACHED */ 407 } 408 409 if (verbose > 1) 410 warnx("using %s as the crash directory", crashdir); 411 412 if (argc > optind) 413 kernel = strdup(argv[optind++]); 414 415 if (argc > optind && (dumpnr >= 0 || remote != NULL)) { 416 warnx("options -n and -r do not take a core file. Ignored"); 417 optind = argc; 418 } 419 420 if (dumpnr >= 0) { 421 snprintf(path, sizeof(path), "%s/vmcore.%d", crashdir, dumpnr); 422 if (stat(path, &st) == -1) 423 err(1, "%s", path); 424 if (!S_ISREG(st.st_mode)) 425 errx(1, "%s: not a regular file", path); 426 vmcore = strdup(path); 427 } else if (remote != NULL) { 428 verify_remote(); 429 } else if (argc > optind) { 430 if (vmcore == NULL) 431 vmcore = strdup(argv[optind++]); 432 if (argc > optind) 433 warnx("multiple core files specified. Ignored"); 434 } else if (vmcore == NULL && kernel == NULL) { 435 vmcore = strdup(_PATH_MEM); 436 kernel = strdup(getbootfile()); 437 } 438 439 if (verbose) { 440 if (vmcore != NULL) 441 warnx("core file: %s", vmcore); 442 if (remote != NULL) 443 warnx("device file: %s", remote); 444 if (kernel != NULL) 445 warnx("kernel image: %s", kernel); 446 } 447 448 /* A remote target requires an explicit kernel argument. */ 449 if (remote != NULL && kernel == NULL) { 450 warnx("remote debugging requires a kernel"); 451 usage(); 452 /* NOTREACHED */ 453 } 454 455 /* If we don't have a kernel image yet, try to find one. */ 456 if (kernel == NULL) { 457 if (dumpnr >= 0) 458 kernel_from_dumpnr(dumpnr); 459 460 if (kernel == NULL) 461 errx(1, "couldn't find a suitable kernel image"); 462 if (verbose) 463 warnx("kernel image: %s", kernel); 464 } 465 add_arg(&args, kernel); 466 467 if (vmcore != NULL) 468 add_arg(&args, vmcore); 469 470 /* The libgdb code uses optind too. Reset it... */ 471 optind = 0; 472 473 /* Terminate argv list. */ 474 add_arg(&args, NULL); 475 476 init_ui_hook = kgdb_init; 477 478 kgdb_sniffer_kluge = kgdb_trgt_trapframe_sniffer; 479 480 return (gdb_main(&args)); 481} 482