options.c revision e99af270a60891e68d465c4cd97dbe29cd1a05e4 
1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2012 Petr Machata, Red Hat Inc.
4 * Copyright (C) 2009,2010 Joe Damato
5 * Copyright (C) 1998,1999,2002,2003,2004,2007,2008,2009 Juan Cespedes
6 * Copyright (C) 2006 Ian Wienand
7 * Copyright (C) 2006 Steve Fink
8 * Copyright (C) 2006 Paul Gilliam, IBM Corporation
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 * 02110-1301 USA
24 */
25
26#include "config.h"
27
28#include <sys/ioctl.h>
29#include <assert.h>
30#include <errno.h>
31#include <fcntl.h>
32#include <getopt.h>
33#include <limits.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <unistd.h>
38
39#include "common.h"
40#include "filter.h"
41#include "glob.h"
42
43#ifndef SYSCONFDIR
44#define SYSCONFDIR "/etc"
45#endif
46
47#define SYSTEM_CONFIG_FILE SYSCONFDIR "/ltrace.conf"
48#define USER_CONFIG_FILE "~/.ltrace.conf"
49
50struct options_t options = {
51	.align    = DEFAULT_ALIGN,    /* alignment column for results */
52	.user     = NULL,             /* username to run command as */
53	.syscalls = 0,                /* display syscalls */
54#ifdef USE_DEMANGLE
55	.demangle = 0,                /* Demangle low-level symbol names */
56#endif
57	.indent = 0,                  /* indent output according to program flow */
58	.output = NULL,               /* output to a specific file */
59	.summary = 0,                 /* Report a summary on program exit */
60	.debug = 0,                   /* debug */
61	.arraylen = DEFAULT_ARRAYLEN, /* maximum # array elements to print */
62	.strlen = DEFAULT_STRLEN,     /* maximum # of bytes printed in strings */
63	.follow = 0,                  /* trace child processes */
64};
65
66static char *progname;		/* Program name (`ltrace') */
67int opt_i = 0;			/* instruction pointer */
68int opt_r = 0;			/* print relative timestamp */
69int opt_t = 0;			/* print absolute timestamp */
70int opt_T = 0;			/* show the time spent inside each call */
71
72/* List of pids given to option -p: */
73struct opt_p_t *opt_p = NULL;	/* attach to process with a given pid */
74
75/* List of filenames give to option -F: */
76struct opt_F_t *opt_F = NULL;	/* alternate configuration file(s) */
77
78static void
79err_usage(void) {
80	fprintf(stderr, "Try `%s --help' for more information.\n", progname);
81	exit(1);
82}
83
84static void
85usage(void) {
86	fprintf(stdout, "Usage: %s [option ...] [command [arg ...]]\n"
87		"Trace library calls of a given program.\n\n"
88		"  -a, --align=COLUMN  align return values in a secific column.\n"
89		"  -A ARRAYLEN         maximum number of array elements to print.\n"
90		"  -b, --no-signals    don't print signals.\n"
91		"  -c                  count time and calls, and report a summary on exit.\n"
92# ifdef USE_DEMANGLE
93		"  -C, --demangle      decode low-level symbol names into user-level names.\n"
94# endif
95		"  -D, --debug=LEVEL   enable debugging (see -Dh or --debug=help).\n"
96		"  -Dh, --debug=help   show help on debugging.\n"
97		"  -e expr             modify which events to trace.\n"
98		"  -f                  trace children (fork() and clone()).\n"
99		"  -F, --config=FILE   load alternate configuration file (may be repeated).\n"
100		"  -h, --help          display this help and exit.\n"
101		"  -i                  print instruction pointer at time of library call.\n"
102		"  -l, --library=FILE  only trace symbols implemented by this library.\n"
103		"  -L                  do NOT display library calls.\n"
104		"  -n, --indent=NR     indent output by NR spaces for each call level nesting.\n"
105		"  -o, --output=FILE   write the trace output to that file.\n"
106		"  -p PID              attach to the process with the process ID pid.\n"
107		"  -r                  print relative timestamps.\n"
108		"  -s STRLEN           specify the maximum string size to print.\n"
109		"  -S                  display system calls.\n"
110		"  -t, -tt, -ttt       print absolute timestamps.\n"
111		"  -T                  show the time spent inside each call.\n"
112		"  -u USERNAME         run command with the userid, groupid of username.\n"
113		"  -V, --version       output version information and exit.\n"
114#if defined(HAVE_LIBUNWIND)
115		"  -w=NR, --where=NR   print backtrace showing NR stack frames at most.\n"
116#endif /* defined(HAVE_LIBUNWIND) */
117		"  -x NAME             treat the global NAME like a library subroutine.\n"
118		"\nReport bugs to ltrace-devel@lists.alioth.debian.org\n",
119		progname);
120}
121
122static void
123usage_debug(void) {
124	fprintf(stdout, "%s debugging option, --debug=<octal> or -D<octal>:\n", progname);
125	fprintf(stdout,
126			"\n"
127			" number  ref. in source   description\n"
128			"      1   general           Generally helpful progress information\n"
129			"     10   event             Shows every event received by a traced process\n"
130			"     20   process           Shows actions carried upon a traced processes\n"
131			"     40   function          Shows every entry to internal functions\n"
132			"\n"
133			"Debugging options are mixed using bitwise-or.\n"
134			"Note that the meanings and values are subject to change.\n"
135		   );
136}
137
138static char *
139search_for_command(char *filename) {
140	static char pathname[PATH_MAX];
141	char *path;
142	int m, n;
143
144	if (strchr(filename, '/')) {
145		return filename;
146	}
147	for (path = getenv("PATH"); path && *path; path += m) {
148		if (strchr(path, ':')) {
149			n = strchr(path, ':') - path;
150			m = n + 1;
151		} else {
152			m = n = strlen(path);
153		}
154		if (n + strlen(filename) + 1 >= PATH_MAX) {
155			fprintf(stderr, "Error: filename too long.\n");
156			exit(1);
157		}
158		strncpy(pathname, path, n);
159		if (n && pathname[n - 1] != '/') {
160			pathname[n++] = '/';
161		}
162		strcpy(pathname + n, filename);
163		if (!access(pathname, X_OK)) {
164			return pathname;
165		}
166	}
167	return filename;
168}
169
170static void
171guess_cols(void) {
172	struct winsize ws;
173	char *c;
174
175	options.align = DEFAULT_ALIGN;
176	c = getenv("COLUMNS");
177	if (c && *c) {
178		char *endptr;
179		int cols;
180		cols = strtol(c, &endptr, 0);
181		if (cols > 0 && !*endptr) {
182			options.align = cols * 5 / 8;
183		}
184	} else if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col > 0) {
185		options.align = ws.ws_col * 5 / 8;
186	} else if (ioctl(2, TIOCGWINSZ, &ws) != -1 && ws.ws_col > 0) {
187		options.align = ws.ws_col * 5 / 8;
188	}
189}
190
191static int
192compile_libname(const char *expr, const char *a_lib, int lib_re_p,
193		struct filter_lib_matcher *matcher)
194{
195	if (strcmp(a_lib, "MAIN") == 0) {
196		filter_lib_matcher_main_init(matcher);
197	} else {
198		/* Add ^ and $ to the library expression as well.  */
199		char lib[strlen(a_lib) + 3];
200		sprintf(lib, "^%s$", a_lib);
201
202		enum filter_lib_matcher_type type
203			= lib[0] == '/' ? FLM_PATHNAME : FLM_SONAME;
204
205		regex_t lib_re;
206		int status = (lib_re_p ? regcomp : globcomp)(&lib_re, lib, 0);
207		if (status != 0) {
208			char buf[100];
209			regerror(status, &lib_re, buf, sizeof buf);
210			fprintf(stderr, "Rule near '%s' will be ignored: %s.\n",
211				expr, buf);
212			return -1;
213		}
214		filter_lib_matcher_name_init(matcher, type, lib_re);
215	}
216	return 0;
217}
218
219static void
220add_filter_rule(struct filter *filt, const char *expr,
221		enum filter_rule_type type,
222		const char *a_sym, int sym_re_p,
223		const char *a_lib, int lib_re_p)
224{
225	struct filter_rule *rule = malloc(sizeof(*rule));
226	struct filter_lib_matcher *matcher = malloc(sizeof(*matcher));
227
228	if (rule == NULL || matcher == NULL) {
229		fprintf(stderr, "Rule near '%s' will be ignored: %s.\n",
230			expr, strerror(errno));
231	fail:
232		free(rule);
233		free(matcher);
234		return;
235	}
236
237	regex_t symbol_re;
238	{
239		/* Add ^ to the start of expression and $ to the end, so that
240		 * we match the whole symbol name.  Let the user write the "*"
241		 * explicitly if they wish.  */
242		char sym[strlen(a_sym) + 3];
243		sprintf(sym, "^%s$", a_sym);
244		int status = (sym_re_p ? regcomp : globcomp)
245			(&symbol_re, sym, 0);
246		if (status != 0) {
247			char buf[100];
248			regerror(status, &symbol_re, buf, sizeof buf);
249			fprintf(stderr, "Rule near '%s' will be ignored: %s.\n",
250				expr, buf);
251			goto fail;
252		}
253	}
254
255	if (compile_libname(expr, a_lib, lib_re_p, matcher) < 0) {
256		regfree(&symbol_re);
257		goto fail;
258	}
259
260	filter_rule_init(rule, type, matcher, symbol_re);
261	filter_add_rule(filt, rule);
262}
263
264static int
265grok_libname_pattern(char **libnamep, char **libendp)
266{
267	char *libname = *libnamep;
268	char *libend = *libendp;
269
270	if (libend[0] != '/')
271		return 0;
272
273	*libend-- = 0;
274	if (libname != libend && libname[0] == '/')
275		++libname;
276	else
277		fprintf(stderr, "Unmatched '/' in library name.\n");
278
279	*libendp = libend;
280	*libnamep = libname;
281	return 1;
282}
283
284static int
285parse_filter(struct filter *filt, char *expr, int operators)
286{
287	/* Filter is a chain of sym@lib rules separated by '-' or '+'.
288	 * If the filter expression starts with '-', the missing
289	 * initial rule is implicitly *@*.  */
290
291	enum filter_rule_type type = FR_ADD;
292
293	while (*expr != 0) {
294		size_t s = strcspn(expr, "-+@" + (operators ? 0 : 2));
295		char *symname = expr;
296		char *libname;
297		char *next = expr + s + 1;
298		enum filter_rule_type this_type = type;
299
300		if (expr[s] == 0) {
301			libname = "*";
302			expr = next - 1;
303
304		} else if (expr[s] == '-' || expr[s] == '+') {
305			type = expr[s] == '-' ? FR_SUBTRACT : FR_ADD;
306			expr[s] = 0;
307			libname = "*";
308			expr = next;
309
310		} else {
311			assert(expr[s] == '@');
312			expr[s] = 0;
313			s = strcspn(next, "-+" + (operators ? 0 : 2));
314			if (s == 0) {
315				libname = "*";
316				expr = next;
317			} else if (next[s] == 0) {
318				expr = next + s;
319				libname = next;
320			} else {
321				assert(next[s] == '-' || next[s] == '+');
322				type = next[s] == '-' ? FR_SUBTRACT : FR_ADD;
323				next[s] = 0;
324				expr = next + s + 1;
325				libname = next;
326			}
327		}
328
329		assert(*libname != 0);
330		char *symend = symname + strlen(symname) - 1;
331		char *libend = libname + strlen(libname) - 1;
332		int sym_is_re = 0;
333		int lib_is_re = 0;
334
335		/*
336		 * /xxx/@... and ...@/xxx/ means that xxx are regular
337		 * expressions.  They are globs otherwise.
338		 *
339		 * /xxx@yyy/ is the same as /xxx/@/yyy/
340		 *
341		 * @/xxx matches library path name
342		 * @.xxx matches library relative path name
343		 */
344		if (symname[0] == '/') {
345			if (symname != symend && symend[0] == '/') {
346				++symname;
347				*symend-- = 0;
348				sym_is_re = 1;
349
350			} else {
351				sym_is_re = 1;
352				lib_is_re = 1;
353				++symname;
354
355				/* /XXX@YYY/ is the same as
356				 * /XXX/@/YYY/.  */
357				if (libend[0] != '/')
358					fprintf(stderr, "Unmatched '/'"
359						" in symbol name.\n");
360				else
361					*libend-- = 0;
362			}
363		}
364
365		/* If libname ends in '/', then we expect '/' in the
366		 * beginning too.  Otherwise the initial '/' is part
367		 * of absolute file name.  */
368		if (!lib_is_re)
369			lib_is_re = grok_libname_pattern(&libname, &libend);
370
371		if (*symname == 0) /* /@AA/ */
372			symname = "*";
373		if (*libname == 0) /* /aa@/ */
374			libname = "*";
375
376		add_filter_rule(filt, expr, this_type,
377				symname, sym_is_re,
378				libname, lib_is_re);
379	}
380
381	return 0;
382}
383
384static struct filter *
385recursive_parse_chain(char *expr, int operators)
386{
387	struct filter *filt = malloc(sizeof(*filt));
388	if (filt == NULL) {
389		fprintf(stderr, "(Part of) filter will be ignored: '%s': %s.\n",
390			expr, strerror(errno));
391		return NULL;
392	}
393
394	filter_init(filt);
395	if (parse_filter(filt, expr, operators) < 0) {
396		fprintf(stderr, "Filter '%s' will be ignored.\n", expr);
397		free(filt);
398		filt = NULL;
399	}
400
401	return filt;
402}
403
404static struct filter **
405slist_chase_end(struct filter **begin)
406{
407	for (; *begin != NULL; begin = &(*begin)->next)
408		;
409	return begin;
410}
411
412static void
413parse_filter_chain(const char *expr, struct filter **retp)
414{
415	char *str = strdup(expr);
416	if (str == NULL) {
417		fprintf(stderr, "Filter '%s' will be ignored: %s.\n",
418			expr, strerror(errno));
419		return;
420	}
421	/* Support initial '!' for backward compatibility.  */
422	if (str[0] == '!')
423		str[0] = '-';
424
425	*slist_chase_end(retp) = recursive_parse_chain(str, 1);
426}
427
428char **
429process_options(int argc, char **argv)
430{
431	progname = argv[0];
432	options.output = stderr;
433	options.no_signals = 0;
434#if defined(HAVE_LIBUNWIND)
435	options.bt_depth = -1;
436#endif /* defined(HAVE_LIBUNWIND) */
437
438	guess_cols();
439
440	int libcalls = 1;
441
442	while (1) {
443		int c;
444		char *p;
445		int option_index = 0;
446		static struct option long_options[] = {
447			{"align", 1, 0, 'a'},
448			{"config", 1, 0, 'F'},
449			{"debug", 1, 0, 'D'},
450# ifdef USE_DEMANGLE
451			{"demangle", 0, 0, 'C'},
452#endif
453			{"indent", 1, 0, 'n'},
454			{"help", 0, 0, 'h'},
455			{"library", 1, 0, 'l'},
456			{"output", 1, 0, 'o'},
457			{"version", 0, 0, 'V'},
458			{"no-signals", 0, 0, 'b'},
459#if defined(HAVE_LIBUNWIND)
460			{"where", 1, 0, 'w'},
461#endif /* defined(HAVE_LIBUNWIND) */
462			{0, 0, 0, 0}
463		};
464		c = getopt_long(argc, argv, "+cfhiLrStTVb"
465# ifdef USE_DEMANGLE
466				"C"
467# endif
468#if defined(HAVE_LIBUNWIND)
469				"a:A:D:e:F:l:n:o:p:s:u:x:X:w:", long_options,
470#else /* !defined(HAVE_LIBUNWIND) */
471				"a:A:D:e:F:l:n:o:p:s:u:x:X:", long_options,
472#endif
473				&option_index);
474		if (c == -1) {
475			break;
476		}
477		switch (c) {
478		case 'a':
479			options.align = atoi(optarg);
480			break;
481		case 'A':
482			options.arraylen = atoi(optarg);
483			break;
484		case 'b':
485			options.no_signals = 1;
486			break;
487		case 'c':
488			options.summary++;
489			break;
490#ifdef USE_DEMANGLE
491		case 'C':
492			options.demangle++;
493			break;
494#endif
495		case 'D':
496			if (optarg[0]=='h') {
497				usage_debug();
498				exit(0);
499			}
500			options.debug = strtoul(optarg,&p,8);
501			if (*p) {
502				fprintf(stderr, "%s: --debug requires an octal argument\n", progname);
503				err_usage();
504			}
505			break;
506
507		case 'e':
508			parse_filter_chain(optarg, &options.plt_filter);
509			break;
510
511		case 'f':
512			options.follow = 1;
513			break;
514		case 'F':
515			{
516				struct opt_F_t *tmp = malloc(sizeof(struct opt_F_t));
517				if (!tmp) {
518					perror("ltrace: malloc");
519					exit(1);
520				}
521				tmp->filename = strdup(optarg);
522				tmp->next = opt_F;
523				opt_F = tmp;
524				break;
525			}
526		case 'h':
527			usage();
528			exit(0);
529		case 'i':
530			opt_i++;
531			break;
532
533		case 'l': {
534			size_t patlen = strlen(optarg);
535			char buf[patlen + 2];
536			sprintf(buf, "@%s", optarg);
537			*slist_chase_end(&options.export_filter)
538				= recursive_parse_chain(buf, 0);
539			break;
540		}
541
542		case 'L':
543			libcalls = 0;
544			break;
545		case 'n': {
546			char *endptr;
547			long int l = strtol(optarg, &endptr, 0);
548			/* Arbitrary cut-off.  Nobody needs to indent
549			 * more than, say, 8, anyway.  */
550			if (l < 0 || l > 20 || *optarg == 0 || *endptr != 0) {
551				fprintf(stderr, "Invalid argument to -n: '%s'."
552					"  Use integer 0..20.\n", optarg);
553				exit(1);
554			}
555			options.indent = (int)l;
556			break;
557		}
558		case 'o':
559			options.output = fopen(optarg, "w");
560			if (!options.output) {
561				fprintf(stderr,
562					"can't open %s for writing: %s\n",
563					optarg, strerror(errno));
564				exit(1);
565			}
566			setvbuf(options.output, (char *)NULL, _IOLBF, 0);
567			fcntl(fileno(options.output), F_SETFD, FD_CLOEXEC);
568			break;
569		case 'p':
570			{
571				struct opt_p_t *tmp = malloc(sizeof(struct opt_p_t));
572				if (!tmp) {
573					perror("ltrace: malloc");
574					exit(1);
575				}
576				tmp->pid = atoi(optarg);
577				tmp->next = opt_p;
578				opt_p = tmp;
579				break;
580			}
581		case 'r':
582			opt_r++;
583			break;
584		case 's':
585			options.strlen = atoi(optarg);
586			break;
587		case 'S':
588			options.syscalls = 1;
589			break;
590		case 't':
591			opt_t++;
592			break;
593		case 'T':
594			opt_T++;
595			break;
596		case 'u':
597			options.user = optarg;
598			break;
599		case 'V':
600			printf("ltrace version " PACKAGE_VERSION ".\n"
601					"Copyright (C) 1997-2009 Juan Cespedes <cespedes@debian.org>.\n"
602					"This is free software; see the GNU General Public Licence\n"
603					"version 2 or later for copying conditions.  There is NO warranty.\n");
604			exit(0);
605			break;
606#if defined(HAVE_LIBUNWIND)
607		case 'w':
608			options.bt_depth = atoi(optarg);
609			break;
610#endif /* defined(HAVE_LIBUNWIND) */
611
612		case 'x':
613			parse_filter_chain(optarg, &options.static_filter);
614			break;
615
616		default:
617			err_usage();
618		}
619	}
620	argc -= optind;
621	argv += optind;
622
623	if (!opt_F) {
624		opt_F = malloc(sizeof(struct opt_F_t));
625		opt_F->next = malloc(sizeof(struct opt_F_t));
626		opt_F->next->next = NULL;
627		opt_F->filename = USER_CONFIG_FILE;
628		opt_F->next->filename = SYSTEM_CONFIG_FILE;
629	}
630	/* Reverse the config file list since it was built by
631	 * prepending, and it would make more sense to process the
632	 * files in the order they were given. Probably it would make
633	 * more sense to keep a tail pointer instead? */
634	{
635		struct opt_F_t *egg = NULL;
636		struct opt_F_t *chicken;
637		while (opt_F) {
638			chicken = opt_F->next;
639			opt_F->next = egg;
640			egg = opt_F;
641			opt_F = chicken;
642		}
643		opt_F = egg;
644	}
645
646	/* If neither -e, nor -l, nor -L are used, set default -e.
647	 * Use @MAIN for now, as that's what ltrace used to have in
648	 * the past.  XXX Maybe we should make this "*" instead.  */
649	if (libcalls
650	    && options.plt_filter == NULL
651	    && options.export_filter == NULL) {
652		parse_filter_chain("@MAIN", &options.plt_filter);
653		options.hide_caller = 1;
654	}
655	if (!libcalls && options.plt_filter != NULL) {
656		fprintf(stderr,
657			"%s: Option -L can't be used with -e or -l.\n",
658			progname);
659		err_usage();
660	}
661
662	if (!opt_p && argc < 1) {
663		fprintf(stderr, "%s: too few arguments\n", progname);
664		err_usage();
665	}
666	if (opt_r && opt_t) {
667		fprintf(stderr,
668			"%s: Options -r and -t can't be used together\n",
669			progname);
670		err_usage();
671	}
672	if (argc > 0) {
673		command = search_for_command(argv[0]);
674	}
675	return &argv[0];
676}
677