gnu/usr.bin/gdb/kgdb/kgdb.c

   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 }