xref: /dragonfly/gnu/usr.bin/gdb/kgdb/kgdb.c (revision 0db87cb7) 
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