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 * $FreeBSD: src/gnu/usr.bin/gdb/kgdb/main.c,v 1.16 2008/04/29 20:32:45 jhb Exp $ 27 */ 28 29 #include <sys/cdefs.h> 30 31 #include <sys/param.h> 32 #include <sys/stat.h> 33 #include <sys/types.h> 34 #include <sys/ioctl.h> 35 #include <sys/resource.h> 36 #include <sys/select.h> 37 #include <sys/time.h> 38 #include <sys/wait.h> 39 #include <errno.h> 40 #include <err.h> 41 #include <inttypes.h> 42 #include <kvm.h> 43 #include <limits.h> 44 #include <paths.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 50 /* libgdb stuff. */ 51 #include <defs.h> 52 #include <frame.h> 53 #include <frame-unwind.h> 54 #include <inferior.h> 55 #include <interps.h> 56 #include <cli-out.h> 57 #include <main.h> 58 #include <gdbcmd.h> 59 #include <objfiles.h> 60 #include <target.h> 61 #include <top.h> 62 #include <ui-file.h> 63 #include <bfd.h> 64 #include <gdbcore.h> 65 #include <exceptions.h> 66 #include <observer.h> 67 #include <arch-utils.h> 68 69 #include "kgdb.h" 70 71 static int dumpnr; 72 static int quiet; 73 static int verbose; 74 75 static char crashdir[PATH_MAX]; 76 static char *kernel; 77 static char *remote; 78 static char *vmcore; 79 static struct ui_file *parse_gdberr; 80 81 static void 82 usage(void) 83 { 84 85 fprintf(stderr, 86 "usage: %s [-afqtvw] [-d crashdir] [-c core | -n dumpnr | -r device]\n" 87 "\t[kernel [core]]\n", getprogname()); 88 exit(1); 89 } 90 91 static void 92 kernel_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 kern.<nr> or is in a 103 * subdirectory kern.<nr> and called kernel. The latter allows us 104 * to collect the modules in the same place. 105 */ 106 snprintf(path, sizeof(path), "%s/kern.%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/kern.%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 156 static void 157 kgdb_new_objfile(struct objfile *objfile) 158 { 159 static int once = 1; 160 161 if (once && objfile != NULL && objfile == symfile_objfile) { 162 char *buf; 163 164 /* 165 * The initial kernel has just been loaded. Start the 166 * remote target if we have one or attach to the core. 167 */ 168 once = 0; 169 170 if (remote != NULL) 171 asprintf(&buf, "target remote %s", remote); 172 else if (vmcore != NULL) 173 asprintf(&buf, "target kernel %s", vmcore); 174 175 if (buf != NULL) { 176 execute_command(buf, 0); 177 free(buf); 178 } 179 } 180 } 181 182 int 183 gdb_parse_exp_1 (const char **stringptr, struct block *block, int comma, 184 struct expression **expression) 185 { 186 volatile struct gdb_exception except; 187 CORE_ADDR pc = 0; 188 189 TRY_CATCH (except, RETURN_MASK_ERROR) 190 { 191 *expression = parse_exp_1 (stringptr, pc ,block, comma); 192 } 193 194 if (except.reason < 0) 195 return 0; 196 return 1; 197 } 198 199 int 200 gdb_evaluate_expression (struct expression *exp, struct value **value) 201 { 202 volatile struct gdb_exception except; 203 204 TRY_CATCH (except, RETURN_MASK_ERROR) 205 { 206 *value = evaluate_expression(exp); 207 } 208 209 if (except.reason < 0) 210 return 0; 211 return 1; 212 } 213 214 /* 215 * Parse an expression and return its value. If 'quiet' is true, then 216 * any error messages from the parser are masked. 217 */ 218 CORE_ADDR 219 kgdb_parse_1(const char *exp, int quiet) 220 { 221 struct ui_file *old_stderr; 222 struct cleanup *old_chain; 223 struct expression *expr; 224 struct value *val; 225 const char *s; 226 CORE_ADDR n; 227 228 old_stderr = gdb_stderr; 229 if (quiet) 230 gdb_stderr = parse_gdberr; 231 n = 0; 232 s = xstrdup(exp); 233 old_chain = make_cleanup(xfree, (char*)s); 234 if (gdb_parse_exp_1(&s, NULL, 0, &expr) && *s == '\0') { 235 make_cleanup(free_current_contents, &expr); 236 if (gdb_evaluate_expression(expr, &val)) 237 n = value_as_address(val); 238 } 239 do_cleanups(old_chain); 240 gdb_stderr = old_stderr; 241 return (n); 242 } 243 244 #define MSGBUF_SEQ_TO_POS(size, seq) ((seq) % (size)) 245 246 void 247 kgdb_dmesg(void) 248 { 249 CORE_ADDR bufp; 250 int size, rseq, wseq; 251 char c; 252 253 /* 254 * Display the unread portion of the message buffer. This gives the 255 * user a some initial data to work from. 256 */ 257 if (quiet) 258 return; 259 bufp = kgdb_parse("msgbufp->msg_ptr"); 260 size = (int)kgdb_parse("msgbufp->msg_size"); 261 if (bufp == 0 || size == 0) 262 return; 263 rseq = (int)kgdb_parse("msgbufp->msg_bufr"); 264 wseq = (int)kgdb_parse("msgbufp->msg_bufx"); 265 rseq = MSGBUF_SEQ_TO_POS(size, rseq); 266 wseq = MSGBUF_SEQ_TO_POS(size, wseq); 267 if (rseq == wseq) 268 return; 269 270 printf("\nUnread portion of the kernel message buffer:\n"); 271 while (rseq < wseq) { 272 read_memory(bufp + rseq, &c, 1); 273 putchar(c); 274 rseq++; 275 if (rseq == size) 276 rseq = 0; 277 } 278 if (c != '\n') 279 putchar('\n'); 280 putchar('\n'); 281 } 282 283 static void 284 kgdb_init(char *argv0 __unused) 285 { 286 287 parse_gdberr = mem_fileopen(); 288 set_prompt("(kgdb) "); 289 initialize_kgdb_target(); 290 initialize_kld_target(); 291 observer_attach_new_objfile(kgdb_new_objfile); 292 } 293 294 /* 295 * Remote targets can support any number of syntaxes and we want to 296 * support them all with one addition: we support specifying a device 297 * node for a serial device without the "/dev/" prefix. 298 * 299 * What we do is to stat(2) the existing remote target first. If that 300 * fails, we try it with "/dev/" prepended. If that succeeds we use 301 * the resulting path, otherwise we use the original target. If 302 * either stat(2) succeeds make sure the file is either a character 303 * device or a FIFO. 304 */ 305 static void 306 verify_remote(void) 307 { 308 char path[PATH_MAX]; 309 struct stat st; 310 311 if (stat(remote, &st) != 0) { 312 snprintf(path, sizeof(path), "/dev/%s", remote); 313 if (stat(path, &st) != 0) 314 return; 315 free(remote); 316 remote = strdup(path); 317 } 318 if (!S_ISCHR(st.st_mode) && !S_ISFIFO(st.st_mode)) 319 errx(1, "%s: not a special file, FIFO or socket", remote); 320 } 321 322 static void 323 add_arg(struct captured_main_args *args, char *arg) 324 { 325 326 args->argc++; 327 args->argv = reallocf(args->argv, (args->argc + 1) * sizeof(char *)); 328 if (args->argv == NULL) 329 err(1, "Out of memory building argument list"); 330 args->argv[args->argc] = arg; 331 } 332 333 int 334 main(int argc, char *argv[]) 335 { 336 char path[PATH_MAX]; 337 struct stat st; 338 struct captured_main_args args; 339 char *s; 340 int a, ch; 341 342 dumpnr = -1; 343 344 strlcpy(crashdir, "/var/crash", sizeof(crashdir)); 345 s = getenv("KGDB_CRASH_DIR"); 346 if (s != NULL) 347 strlcpy(crashdir, s, sizeof(crashdir)); 348 349 /* Convert long options into short options. */ 350 for (a = 1; a < argc; a++) { 351 s = argv[a]; 352 if (s[0] == '-') { 353 s++; 354 /* Long options take either 1 or 2 dashes. */ 355 if (s[0] == '-') 356 s++; 357 if (strcmp(s, "quiet") == 0) 358 argv[a] = "-q"; 359 else if (strcmp(s, "fullname") == 0) 360 argv[a] = "-f"; 361 else if (strcmp(s, "tui-mode") == 0) 362 argv[a] = "-t"; 363 } 364 } 365 366 quiet = 0; 367 memset (&args, 0, sizeof args); 368 args.use_windows = 0; 369 args.interpreter_p = INTERP_CONSOLE; 370 args.argv = malloc(sizeof(char *)); 371 args.argv[0] = argv[0]; 372 add_arg(&args, "--kernel"); 373 374 while ((ch = getopt(argc, argv, "ac:d:fn:qr:tvw")) != -1) { 375 switch (ch) { 376 case 'a': 377 annotation_level++; 378 break; 379 case 'c': /* use given core file. */ 380 if (vmcore != NULL) { 381 warnx("option %c: can only be specified once", 382 optopt); 383 usage(); 384 /* NOTREACHED */ 385 } 386 vmcore = strdup(optarg); 387 break; 388 case 'd': /* lookup dumps in given directory. */ 389 strlcpy(crashdir, optarg, sizeof(crashdir)); 390 break; 391 case 'f': 392 annotation_level = 1; 393 break; 394 case 'n': /* use dump with given number. */ 395 dumpnr = strtol(optarg, &s, 0); 396 if (dumpnr < 0 || *s != '\0') { 397 warnx("option %c: invalid kernel dump number", 398 optopt); 399 usage(); 400 /* NOTREACHED */ 401 } 402 break; 403 case 'q': 404 quiet = 1; 405 add_arg(&args, "-q"); 406 break; 407 case 'r': /* use given device for remote session. */ 408 if (remote != NULL) { 409 warnx("option %c: can only be specified once", 410 optopt); 411 usage(); 412 /* NOTREACHED */ 413 } 414 remote = strdup(optarg); 415 break; 416 case 't': 417 args.interpreter_p = INTERP_TUI; 418 add_arg(&args, "-tui"); 419 quiet = 1; 420 add_arg(&args, "-q"); 421 break; 422 case 'v': /* increase verbosity. */ 423 verbose++; 424 break; 425 case 'w': /* core file is writeable. */ 426 add_arg(&args, "--write"); 427 break; 428 case '?': 429 default: 430 usage(); 431 } 432 } 433 434 if (((vmcore != NULL) ? 1 : 0) + ((dumpnr >= 0) ? 1 : 0) + 435 ((remote != NULL) ? 1 : 0) > 1) { 436 warnx("options -c, -n and -r are mutually exclusive"); 437 usage(); 438 /* NOTREACHED */ 439 } 440 441 if (verbose > 1) 442 warnx("using %s as the crash directory", crashdir); 443 444 if (argc > optind) 445 kernel = strdup(argv[optind++]); 446 447 if (argc > optind && (dumpnr >= 0 || remote != NULL)) { 448 warnx("options -n and -r do not take a core file. Ignored"); 449 optind = argc; 450 } 451 452 if (dumpnr >= 0) { 453 snprintf(path, sizeof(path), "%s/vmcore.%d", crashdir, dumpnr); 454 if (stat(path, &st) == -1) 455 err(1, "%s", path); 456 if (!S_ISREG(st.st_mode)) 457 errx(1, "%s: not a regular file", path); 458 vmcore = strdup(path); 459 } else if (remote != NULL) { 460 verify_remote(); 461 } else if (argc > optind) { 462 if (vmcore == NULL) 463 vmcore = strdup(argv[optind++]); 464 if (argc > optind) 465 warnx("multiple core files specified. Ignored"); 466 } else if (vmcore == NULL && kernel == NULL) { 467 vmcore = strdup(_PATH_MEM); 468 kernel = strdup(getbootfile()); 469 } 470 471 if (verbose) { 472 if (vmcore != NULL) 473 warnx("core file: %s", vmcore); 474 if (remote != NULL) 475 warnx("device file: %s", remote); 476 if (kernel != NULL) 477 warnx("kernel image: %s", kernel); 478 } 479 480 /* A remote target requires an explicit kernel argument. */ 481 if (remote != NULL && kernel == NULL) { 482 warnx("remote debugging requires a kernel"); 483 usage(); 484 /* NOTREACHED */ 485 } 486 487 /* If we don't have a kernel image yet, try to find one. */ 488 if (kernel == NULL) { 489 if (dumpnr >= 0) 490 kernel_from_dumpnr(dumpnr); 491 492 if (kernel == NULL) 493 errx(1, "couldn't find a suitable kernel image"); 494 if (verbose) 495 warnx("kernel image: %s", kernel); 496 } 497 add_arg(&args, kernel); 498 499 /* 500 if (vmcore != NULL) 501 add_arg(&args, vmcore); 502 */ 503 504 /* The libgdb code uses optind too. Reset it... */ 505 optind = 0; 506 507 /* Terminate argv list. */ 508 add_arg(&args, NULL); 509 510 deprecated_init_ui_hook = kgdb_init; 511 512 return (gdb_main(&args)); 513 } 514