177ab61ea581f643909380c9cd217137cdc94200
[dragonfly.git] / 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 <wrapper.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 [-afqv] [-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 /*
183  * Parse an expression and return its value.  If 'quiet' is true, then
184  * any error messages from the parser are masked.
185  */
186 CORE_ADDR
187 kgdb_parse_1(const char *exp, int quiet)
188 {
189         struct ui_file *old_stderr;
190         struct cleanup *old_chain;
191         struct expression *expr;
192         struct value *val;
193         char *s;
194         CORE_ADDR n;
195
196         old_stderr = gdb_stderr;
197         if (quiet)
198                 gdb_stderr = parse_gdberr;
199         n = 0;
200         s = xstrdup(exp);
201         old_chain = make_cleanup(xfree, s);
202         if (gdb_parse_exp_1(&s, NULL, 0, &expr) && *s == '\0') {
203                 make_cleanup(free_current_contents, &expr);
204                 if (gdb_evaluate_expression(expr, &val))
205                     n = value_as_address(val);
206         }
207         do_cleanups(old_chain);
208         gdb_stderr = old_stderr;
209         return (n);
210 }
211
212 #define MSGBUF_SEQ_TO_POS(size, seq)    ((seq) % (size))
213
214 void
215 kgdb_dmesg(void)
216 {
217         CORE_ADDR bufp;
218         int size, rseq, wseq;
219         char c;
220
221         /*
222          * Display the unread portion of the message buffer. This gives the
223          * user a some initial data to work from.
224          */
225         if (quiet)
226                 return;
227         bufp = kgdb_parse("msgbufp->msg_ptr");
228         size = (int)kgdb_parse("msgbufp->msg_size");
229         if (bufp == 0 || size == 0)
230                 return;
231         rseq = (int)kgdb_parse("msgbufp->msg_bufr");
232         wseq = (int)kgdb_parse("msgbufp->msg_bufx");
233         rseq = MSGBUF_SEQ_TO_POS(size, rseq);
234         wseq = MSGBUF_SEQ_TO_POS(size, wseq);
235         if (rseq == wseq)
236                 return;
237
238         printf("\nUnread portion of the kernel message buffer:\n");
239         while (rseq < wseq) {
240                 read_memory(bufp + rseq, &c, 1);
241                 putchar(c);
242                 rseq++;
243                 if (rseq == size)
244                         rseq = 0;
245         }
246         if (c != '\n')
247                 putchar('\n');
248         putchar('\n');
249 }
250
251 static void
252 kgdb_init(char *argv0 __unused)
253 {
254
255         parse_gdberr = mem_fileopen();
256         set_prompt("(kgdb) ");
257         initialize_kgdb_target();
258         initialize_kld_target();
259         observer_attach_new_objfile(kgdb_new_objfile);
260 }
261
262 /*
263  * Remote targets can support any number of syntaxes and we want to
264  * support them all with one addition: we support specifying a device
265  * node for a serial device without the "/dev/" prefix.
266  *
267  * What we do is to stat(2) the existing remote target first.  If that
268  * fails, we try it with "/dev/" prepended.  If that succeeds we use
269  * the resulting path, otherwise we use the original target.  If
270  * either stat(2) succeeds make sure the file is either a character
271  * device or a FIFO.
272  */
273 static void
274 verify_remote(void)
275 {
276         char path[PATH_MAX];
277         struct stat st;
278
279         if (stat(remote, &st) != 0) {
280                 snprintf(path, sizeof(path), "/dev/%s", remote);
281                 if (stat(path, &st) != 0)
282                         return;
283                 free(remote);
284                 remote = strdup(path);
285         }
286         if (!S_ISCHR(st.st_mode) && !S_ISFIFO(st.st_mode))
287                 errx(1, "%s: not a special file, FIFO or socket", remote);
288 }
289
290 static void
291 add_arg(struct captured_main_args *args, char *arg)
292 {
293
294         args->argc++;
295         args->argv = reallocf(args->argv, (args->argc + 1) * sizeof(char *));
296         if (args->argv == NULL)
297                 err(1, "Out of memory building argument list");
298         args->argv[args->argc] = arg;
299 }
300
301 int
302 main(int argc, char *argv[])
303 {
304         char path[PATH_MAX];
305         struct stat st;
306         struct captured_main_args args;
307         char *s;
308         int a, ch;
309
310         dumpnr = -1;
311
312         strlcpy(crashdir, "/var/crash", sizeof(crashdir));
313         s = getenv("KGDB_CRASH_DIR");
314         if (s != NULL)
315                 strlcpy(crashdir, s, sizeof(crashdir));
316
317         /* Convert long options into short options. */
318         for (a = 1; a < argc; a++) {
319                 s = argv[a];
320                 if (s[0] == '-') {
321                         s++;
322                         /* Long options take either 1 or 2 dashes. */
323                         if (s[0] == '-')
324                                 s++;
325                         if (strcmp(s, "quiet") == 0)
326                                 argv[a] = "-q";
327                         else if (strcmp(s, "fullname") == 0)
328                                 argv[a] = "-f";
329                 }
330         }
331
332         quiet = 0;
333         memset (&args, 0, sizeof args);
334         args.use_windows = 0;
335         args.interpreter_p = INTERP_CONSOLE;
336         args.argv = malloc(sizeof(char *));
337         args.argv[0] = argv[0];
338         add_arg(&args, "--kernel");
339
340         while ((ch = getopt(argc, argv, "ac:d:fn:qr:vw")) != -1) {
341                 switch (ch) {
342                 case 'a':
343                         annotation_level++;
344                         break;
345                 case 'c':       /* use given core file. */
346                         if (vmcore != NULL) {
347                                 warnx("option %c: can only be specified once",
348                                     optopt);
349                                 usage();
350                                 /* NOTREACHED */
351                         }
352                         vmcore = strdup(optarg);
353                         break;
354                 case 'd':       /* lookup dumps in given directory. */
355                         strlcpy(crashdir, optarg, sizeof(crashdir));
356                         break;
357                 case 'f':
358                         annotation_level = 1;
359                         break;
360                 case 'n':       /* use dump with given number. */
361                         dumpnr = strtol(optarg, &s, 0);
362                         if (dumpnr < 0 || *s != '\0') {
363                                 warnx("option %c: invalid kernel dump number",
364                                     optopt);
365                                 usage();
366                                 /* NOTREACHED */
367                         }
368                         break;
369                 case 'q':
370                         quiet = 1;
371                         add_arg(&args, "-q");
372                         break;
373                 case 'r':       /* use given device for remote session. */
374                         if (remote != NULL) {
375                                 warnx("option %c: can only be specified once",
376                                     optopt);
377                                 usage();
378                                 /* NOTREACHED */
379                         }
380                         remote = strdup(optarg);
381                         break;
382                 case 'v':       /* increase verbosity. */
383                         verbose++;
384                         break;
385                 case 'w':       /* core file is writeable. */
386                         add_arg(&args, "--write");
387                         break;
388                 case '?':
389                 default:
390                         usage();
391                 }
392         }
393
394         if (((vmcore != NULL) ? 1 : 0) + ((dumpnr >= 0) ? 1 : 0) +
395             ((remote != NULL) ? 1 : 0) > 1) {
396                 warnx("options -c, -n and -r are mutually exclusive");
397                 usage();
398                 /* NOTREACHED */
399         }
400
401         if (verbose > 1)
402                 warnx("using %s as the crash directory", crashdir);
403
404         if (argc > optind)
405                 kernel = strdup(argv[optind++]);
406
407         if (argc > optind && (dumpnr >= 0 || remote != NULL)) {
408                 warnx("options -n and -r do not take a core file. Ignored");
409                 optind = argc;
410         }
411
412         if (dumpnr >= 0) {
413                 snprintf(path, sizeof(path), "%s/vmcore.%d", crashdir, dumpnr);
414                 if (stat(path, &st) == -1)
415                         err(1, "%s", path);
416                 if (!S_ISREG(st.st_mode))
417                         errx(1, "%s: not a regular file", path);
418                 vmcore = strdup(path);
419         } else if (remote != NULL) {
420                 verify_remote();
421         } else if (argc > optind) {
422                 if (vmcore == NULL)
423                         vmcore = strdup(argv[optind++]);
424                 if (argc > optind)
425                         warnx("multiple core files specified. Ignored");
426         } else if (vmcore == NULL && kernel == NULL) {
427                 vmcore = strdup(_PATH_MEM);
428                 kernel = strdup(getbootfile());
429         }
430
431         if (verbose) {
432                 if (vmcore != NULL)
433                         warnx("core file: %s", vmcore);
434                 if (remote != NULL)
435                         warnx("device file: %s", remote);
436                 if (kernel != NULL)
437                         warnx("kernel image: %s", kernel);
438         }
439
440         /* A remote target requires an explicit kernel argument. */
441         if (remote != NULL && kernel == NULL) {
442                 warnx("remote debugging requires a kernel");
443                 usage();
444                 /* NOTREACHED */
445         }
446
447         /* If we don't have a kernel image yet, try to find one. */
448         if (kernel == NULL) {
449                 if (dumpnr >= 0)
450                         kernel_from_dumpnr(dumpnr);
451
452                 if (kernel == NULL)
453                         errx(1, "couldn't find a suitable kernel image");
454                 if (verbose)
455                         warnx("kernel image: %s", kernel);
456         }
457         add_arg(&args, kernel);
458
459         /*
460         if (vmcore != NULL)
461                 add_arg(&args, vmcore);
462                 */
463
464         /* The libgdb code uses optind too. Reset it... */
465         optind = 0;
466
467         /* Terminate argv list. */
468         add_arg(&args, NULL);
469
470         deprecated_init_ui_hook = kgdb_init;
471
472         return (gdb_main(&args));
473 }