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