+/*
+ * This file is part of ltrace.
+ * Copyright (C) 2012, 2013 Petr Machata, Red Hat Inc.
+ * Copyright (C) 2009,2010 Joe Damato
+ * Copyright (C) 1998,1999,2002,2003,2004,2007,2008,2009 Juan Cespedes
+ * Copyright (C) 2006 Ian Wienand
+ * Copyright (C) 2006 Steve Fink
+ * Copyright (C) 2006 Paul Gilliam, IBM Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
#include "config.h"
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <limits.h>
#include <sys/ioctl.h>
-
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
#include <getopt.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
#include "common.h"
-
-#ifndef SYSCONFDIR
-#define SYSCONFDIR "/etc"
-#endif
-
-#define SYSTEM_CONFIG_FILE SYSCONFDIR "/ltrace.conf"
-#define USER_CONFIG_FILE "~/.ltrace.conf"
+#include "filter.h"
+#include "glob.h"
+#include "demangle.h"
struct options_t options = {
.align = DEFAULT_ALIGN, /* alignment column for results */
.user = NULL, /* username to run command as */
.syscalls = 0, /* display syscalls */
- .libcalls = 1, /* display library calls */
#ifdef USE_DEMANGLE
.demangle = 0, /* Demangle low-level symbol names */
#endif
.follow = 0, /* trace child processes */
};
-char *library[MAX_LIBRARIES];
-int library_num = 0;
static char *progname; /* Program name (`ltrace') */
int opt_i = 0; /* instruction pointer */
int opt_r = 0; /* print relative timestamp */
/* List of pids given to option -p: */
struct opt_p_t *opt_p = NULL; /* attach to process with a given pid */
-/* List of function names given to option -e: */
-struct opt_e_t *opt_e = NULL;
-int opt_e_enable = 1;
-
-/* List of global function names given to -x: */
-struct opt_x_t *opt_x = NULL;
-
-/* List of filenames give to option -F: */
-struct opt_F_t *opt_F = NULL; /* alternate configuration file(s) */
-
-#ifdef PLT_REINITALISATION_BP
-/* Set a break on the routine named here in order to re-initialize breakpoints
- after all the PLTs have been initialzed */
-char *PLTs_initialized_by_here = PLT_REINITALISATION_BP;
-#endif
+/* Vector of struct opt_F_t. */
+struct vect opt_F;
static void
err_usage(void) {
- fprintf(stderr, "Try `%s --help' for more information\n", progname);
+ fprintf(stderr, "Try `%s --help' for more information.\n", progname);
exit(1);
}
fprintf(stdout, "Usage: %s [option ...] [command [arg ...]]\n"
"Trace library calls of a given program.\n\n"
" -a, --align=COLUMN align return values in a secific column.\n"
- " -A ARRAYLEN maximum number of array elements to print.\n"
+ " -A MAXELTS maximum number of array elements to print.\n"
+ " -b, --no-signals don't print signals.\n"
" -c count time and calls, and report a summary on exit.\n"
# ifdef USE_DEMANGLE
" -C, --demangle decode low-level symbol names into user-level names.\n"
# endif
- " -D, --debug=LEVEL enable debugging (see -Dh or --debug=help).\n"
+ " -D, --debug=MASK enable debugging (see -Dh or --debug=help).\n"
" -Dh, --debug=help show help on debugging.\n"
- " -e expr modify which events to trace.\n"
+ " -e FILTER modify which library calls to trace.\n"
" -f trace children (fork() and clone()).\n"
" -F, --config=FILE load alternate configuration file (may be repeated).\n"
" -h, --help display this help and exit.\n"
" -i print instruction pointer at time of library call.\n"
- " -l, --library=FILE print library calls from this library only.\n"
+ " -l, --library=LIBRARY_PATTERN only trace symbols implemented by this library.\n"
" -L do NOT display library calls.\n"
" -n, --indent=NR indent output by NR spaces for each call level nesting.\n"
- " -o, --output=FILE write the trace output to that file.\n"
+ " -o, --output=FILENAME write the trace output to file with given name.\n"
" -p PID attach to the process with the process ID pid.\n"
" -r print relative timestamps.\n"
- " -s STRLEN specify the maximum string size to print.\n"
- " -S display system calls.\n"
+ " -s STRSIZE specify the maximum string size to print.\n"
+ " -S trace system calls as well as library calls.\n"
" -t, -tt, -ttt print absolute timestamps.\n"
" -T show the time spent inside each call.\n"
" -u USERNAME run command with the userid, groupid of username.\n"
" -V, --version output version information and exit.\n"
- " -x NAME treat the global NAME like a library subroutine.\n"
-#ifdef PLT_REINITALISATION_BP
- " -X NAME same as -x; and PLT's will be initialized by here.\n"
-#endif
+#if defined(HAVE_LIBUNWIND)
+ " -w, --where=NR print backtrace showing NR stack frames at most.\n"
+#endif /* defined(HAVE_LIBUNWIND) */
+ " -x FILTER modify which static functions to trace.\n"
"\nReport bugs to ltrace-devel@lists.alioth.debian.org\n",
progname);
}
m = n = strlen(path);
}
if (n + strlen(filename) + 1 >= PATH_MAX) {
- fprintf(stderr, "Error: filename too long\n");
+ fprintf(stderr, "Error: filename too long.\n");
exit(1);
}
strncpy(pathname, path, n);
}
}
+static int
+compile_libname(const char *expr, const char *a_lib, int lib_re_p,
+ struct filter_lib_matcher *matcher)
+{
+ if (strcmp(a_lib, "MAIN") == 0) {
+ filter_lib_matcher_main_init(matcher);
+ } else {
+ /* Add ^ and $ to the library expression as well. */
+ char lib[strlen(a_lib) + 3];
+ sprintf(lib, "^%s$", a_lib);
+
+ enum filter_lib_matcher_type type
+ = lib[0] == '/' ? FLM_PATHNAME : FLM_SONAME;
+
+ regex_t lib_re;
+ int status = (lib_re_p ? regcomp : globcomp)(&lib_re, lib, 0);
+ if (status != 0) {
+ char buf[100];
+ regerror(status, &lib_re, buf, sizeof buf);
+ fprintf(stderr, "Couldn't compile '%s': %s.\n",
+ expr, buf);
+ return -1;
+ }
+ filter_lib_matcher_name_init(matcher, type, lib_re);
+ }
+ return 0;
+}
+
+static int
+add_filter_rule(struct filter *filt, const char *expr,
+ enum filter_rule_type type,
+ const char *a_sym, int sym_re_p,
+ const char *a_lib, int lib_re_p)
+{
+ struct filter_rule *rule = malloc(sizeof(*rule));
+ struct filter_lib_matcher *matcher = malloc(sizeof(*matcher));
+
+ if (rule == NULL || matcher == NULL) {
+ fail:
+ free(rule);
+ free(matcher);
+ return -1;
+ }
+
+ regex_t symbol_re;
+ {
+ /* Add ^ to the start of expression and $ to the end, so that
+ * we match the whole symbol name. Let the user write the "*"
+ * explicitly if they wish. */
+ char sym[strlen(a_sym) + 3];
+ sprintf(sym, "^%s$", a_sym);
+ int status = (sym_re_p ? regcomp : globcomp)
+ (&symbol_re, sym, 0);
+ if (status != 0) {
+ char buf[100];
+ regerror(status, &symbol_re, buf, sizeof buf);
+ fprintf(stderr, "Couldn't compile '%s': %s.\n",
+ expr, buf);
+ goto fail;
+ }
+ }
+
+ if (compile_libname(expr, a_lib, lib_re_p, matcher) < 0) {
+ regfree(&symbol_re);
+ goto fail;
+ }
+
+ filter_rule_init(rule, type, matcher, symbol_re);
+ filter_add_rule(filt, rule);
+ return 0;
+}
+
+static int
+grok_libname_pattern(char **libnamep, char **libendp)
+{
+ char *libname = *libnamep;
+ char *libend = *libendp;
+
+ if (libend[0] != '/')
+ return 0;
+
+ *libend-- = 0;
+ if (libname != libend && libname[0] == '/')
+ ++libname;
+ else
+ fprintf(stderr, "Unmatched '/' in library name.\n");
+
+ *libendp = libend;
+ *libnamep = libname;
+ return 1;
+}
+
+static int
+parse_filter(struct filter *filt, char *expr, int operators)
+{
+ /* Filter is a chain of sym@lib rules separated by '-' or '+'.
+ * If the filter expression starts with '-', the missing
+ * initial rule is implicitly *@*. */
+
+ enum filter_rule_type type = FR_ADD;
+
+ while (*expr != 0) {
+ size_t s = strcspn(expr, &"-+@"[operators ? 0 : 2]);
+ char *symname = expr;
+ char *libname;
+ char *next = expr + s + 1;
+ enum filter_rule_type this_type = type;
+
+ if (expr[s] == 0) {
+ libname = "*";
+ expr = next - 1;
+
+ } else if (expr[s] == '-' || expr[s] == '+') {
+ type = expr[s] == '-' ? FR_SUBTRACT : FR_ADD;
+ expr[s] = 0;
+ libname = "*";
+ expr = next;
+
+ } else {
+ assert(expr[s] == '@');
+ expr[s] = 0;
+ s = strcspn(next, &"-+"[operators ? 0 : 2]);
+ if (s == 0) {
+ libname = "*";
+ expr = next;
+ } else if (next[s] == 0) {
+ expr = next + s;
+ libname = next;
+ } else {
+ assert(next[s] == '-' || next[s] == '+');
+ type = next[s] == '-' ? FR_SUBTRACT : FR_ADD;
+ next[s] = 0;
+ expr = next + s + 1;
+ libname = next;
+ }
+ }
+
+ assert(*libname != 0);
+ char *symend = symname + strlen(symname) - 1;
+ char *libend = libname + strlen(libname) - 1;
+ int sym_is_re = 0;
+ int lib_is_re = 0;
+
+ /*
+ * /xxx/@... and ...@/xxx/ means that xxx are regular
+ * expressions. They are globs otherwise.
+ *
+ * /xxx@yyy/ is the same as /xxx/@/yyy/
+ *
+ * @/xxx matches library path name
+ * @.xxx matches library relative path name
+ */
+ if (symname[0] == '/') {
+ if (symname != symend && symend[0] == '/') {
+ ++symname;
+ *symend-- = 0;
+ sym_is_re = 1;
+
+ } else {
+ sym_is_re = 1;
+ lib_is_re = 1;
+ ++symname;
+
+ /* /XXX@YYY/ is the same as
+ * /XXX/@/YYY/. */
+ if (libend[0] != '/')
+ fprintf(stderr, "Unmatched '/'"
+ " in symbol name.\n");
+ else
+ *libend-- = 0;
+ }
+ }
+
+ /* If libname ends in '/', then we expect '/' in the
+ * beginning too. Otherwise the initial '/' is part
+ * of absolute file name. */
+ if (!lib_is_re)
+ lib_is_re = grok_libname_pattern(&libname, &libend);
+
+ if (*symname == 0) /* /@AA/ */
+ symname = "*";
+ if (*libname == 0) /* /aa@/ */
+ libname = "*";
+
+ add_filter_rule(filt, expr, this_type,
+ symname, sym_is_re,
+ libname, lib_is_re);
+ }
+
+ return 0;
+}
+
+static struct filter *
+recursive_parse_chain(const char *orig, char *expr, int operators)
+{
+ struct filter *filt = malloc(sizeof(*filt));
+ if (filt == NULL) {
+ fprintf(stderr, "(Part of) filter will be ignored: '%s': %s.\n",
+ expr, strerror(errno));
+ return NULL;
+ }
+
+ filter_init(filt);
+ if (parse_filter(filt, expr, operators) < 0) {
+ fprintf(stderr, "Filter '%s' will be ignored.\n", orig);
+ free(filt);
+ filt = NULL;
+ }
+
+ return filt;
+}
+
+static struct filter **
+slist_chase_end(struct filter **begin)
+{
+ for (; *begin != NULL; begin = &(*begin)->next)
+ ;
+ return begin;
+}
+
+static void
+parse_filter_chain(const char *expr, struct filter **retp)
+{
+ char *str = strdup(expr);
+ if (str == NULL) {
+ fprintf(stderr, "Filter '%s' will be ignored: %s.\n",
+ expr, strerror(errno));
+ return;
+ }
+ /* Support initial '!' for backward compatibility. */
+ if (str[0] == '!')
+ str[0] = '-';
+
+ *slist_chase_end(retp) = recursive_parse_chain(expr, str, 1);
+ free(str);
+}
+
+static int
+parse_int(const char *optarg, char opt, int min, int max)
+{
+ char *endptr;
+ long int l = strtol(optarg, &endptr, 0);
+ if (l < min || (max != 0 && l > max)
+ || *optarg == 0 || *endptr != 0) {
+ const char *fmt = max != 0
+ ? "Invalid argument to -%c: '%s'. Use integer %d..%d.\n"
+ : "Invalid argument to -%c: '%s'. Use integer >=%d.\n";
+ fprintf(stderr, fmt, opt, optarg, min, max);
+ exit(1);
+ }
+ return (int)l;
+}
+
+int
+parse_colon_separated_list(const char *paths, struct vect *vec)
+{
+ /* PATHS contains a colon-separated list of directories and
+ * files to load. It's modeled after shell PATH variable,
+ * which doesn't allow escapes. PYTHONPATH in CPython behaves
+ * the same way. So let's follow suit, it makes things easier
+ * to us. */
+
+ char *clone = strdup(paths);
+ if (clone == NULL) {
+ fprintf(stderr, "Couldn't parse argument %s: %s.\n",
+ paths, strerror(errno));
+ return -1;
+ }
+
+ /* It's undesirable to use strtok, because we want the string
+ * "a::b" to have three elements. */
+ char *tok = clone - 1;
+ char *end = clone + strlen(clone);
+ while (tok < end) {
+ ++tok;
+ size_t len = strcspn(tok, ":");
+ tok[len] = 0;
+
+ struct opt_F_t arg = {
+ .pathname = tok,
+ .own_pathname = tok == clone,
+ };
+ if (VECT_PUSHBACK(vec, &arg) < 0)
+ /* Presumably this is not a deal-breaker. */
+ fprintf(stderr, "Couldn't store component of %s: %s.\n",
+ paths, strerror(errno));
+
+ tok += len;
+ }
+
+ return 0;
+}
+
+void
+opt_F_destroy(struct opt_F_t *entry)
+{
+ if (entry == NULL)
+ return;
+ if (entry->own_pathname)
+ free(entry->pathname);
+}
+
+enum opt_F_kind
+opt_F_get_kind(struct opt_F_t *entry)
+{
+ if (entry->kind == OPT_F_UNKNOWN) {
+ struct stat st;
+ if (lstat(entry->pathname, &st) < 0) {
+ fprintf(stderr, "Couldn't stat %s: %s\n",
+ entry->pathname, strerror(errno));
+ entry->kind = OPT_F_BROKEN;
+ } else if (S_ISDIR(st.st_mode)) {
+ entry->kind = OPT_F_DIR;
+ } else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
+ entry->kind = OPT_F_FILE;
+ } else {
+ fprintf(stderr, "%s is neither a regular file, "
+ "nor a directory.\n", entry->pathname);
+ entry->kind = OPT_F_BROKEN;
+ }
+ }
+ assert(entry->kind != OPT_F_UNKNOWN);
+ return entry->kind;
+}
+
char **
-process_options(int argc, char **argv) {
+process_options(int argc, char **argv)
+{
+ VECT_INIT(&opt_F, struct opt_F_t);
+
progname = argv[0];
options.output = stderr;
+ options.no_signals = 0;
+#if defined(HAVE_LIBUNWIND)
+ options.bt_depth = -1;
+#endif /* defined(HAVE_LIBUNWIND) */
guess_cols();
+ int libcalls = 1;
+
while (1) {
int c;
char *p;
+#ifdef HAVE_GETOPT_LONG
int option_index = 0;
static struct option long_options[] = {
{"align", 1, 0, 'a'},
{"debug", 1, 0, 'D'},
# ifdef USE_DEMANGLE
{"demangle", 0, 0, 'C'},
-#endif
+# endif
{"indent", 1, 0, 'n'},
{"help", 0, 0, 'h'},
{"library", 1, 0, 'l'},
{"output", 1, 0, 'o'},
{"version", 0, 0, 'V'},
+ {"no-signals", 0, 0, 'b'},
+# if defined(HAVE_LIBUNWIND)
+ {"where", 1, 0, 'w'},
+# endif /* defined(HAVE_LIBUNWIND) */
{0, 0, 0, 0}
};
- c = getopt_long(argc, argv, "+cfhiLrStTV"
-# ifdef USE_DEMANGLE
- "C"
-# endif
- "a:A:D:e:F:l:n:o:p:s:u:x:X:", long_options,
- &option_index);
+#endif
+
+ const char *opts = "+"
+#ifdef USE_DEMANGLE
+ "C"
+#endif
+#if defined(HAVE_LIBUNWIND)
+ "w:"
+#endif
+ "cfhiLrStTVba:A:D:e:F:l:n:o:p:s:u:x:X:";
+
+#ifdef HAVE_GETOPT_LONG
+ c = getopt_long(argc, argv, opts, long_options, &option_index);
+#else
+ c = getopt(argc, argv, opts);
+#endif
if (c == -1) {
break;
}
switch (c) {
case 'a':
- options.align = atoi(optarg);
+ options.align = parse_int(optarg, 'a', 0, 0);
break;
case 'A':
- options.arraylen = atoi(optarg);
+ options.arraylen = parse_int(optarg, 'A', 0, 0);
+ break;
+ case 'b':
+ options.no_signals = 1;
break;
case 'c':
options.summary++;
err_usage();
}
break;
+
case 'e':
- {
- char *str_e = strdup(optarg);
- if (!str_e) {
- perror("ltrace: strdup");
- exit(1);
- }
- if (str_e[0] == '!') {
- opt_e_enable = 0;
- str_e++;
- }
- while (*str_e) {
- struct opt_e_t *tmp;
- char *str2 = strchr(str_e, ',');
- if (str2) {
- *str2 = '\0';
- }
- tmp = malloc(sizeof(struct opt_e_t));
- if (!tmp) {
- perror("ltrace: malloc");
- exit(1);
- }
- tmp->name = str_e;
- tmp->next = opt_e;
- opt_e = tmp;
- if (str2) {
- str_e = str2 + 1;
- } else {
- break;
- }
- }
- break;
- }
+ parse_filter_chain(optarg, &options.plt_filter);
+ break;
+
case 'f':
options.follow = 1;
break;
case 'F':
- {
- struct opt_F_t *tmp = malloc(sizeof(struct opt_F_t));
- if (!tmp) {
- perror("ltrace: malloc");
- exit(1);
- }
- tmp->filename = strdup(optarg);
- tmp->next = opt_F;
- opt_F = tmp;
- break;
- }
+ parse_colon_separated_list(optarg, &opt_F);
+ break;
case 'h':
usage();
exit(0);
case 'i':
opt_i++;
break;
- case 'l':
- if (library_num == MAX_LIBRARIES) {
- fprintf(stderr,
- "Too many libraries. Maximum is %i.\n",
- MAX_LIBRARIES);
- exit(1);
- }
- library[library_num++] = optarg;
+
+ case 'l': {
+ size_t patlen = strlen(optarg);
+ char buf[patlen + 2];
+ sprintf(buf, "@%s", optarg);
+ *slist_chase_end(&options.export_filter)
+ = recursive_parse_chain(buf, buf, 0);
break;
+ }
+
case 'L':
- options.libcalls = 0;
+ libcalls = 0;
break;
case 'n':
- options.indent = atoi(optarg);
+ options.indent = parse_int(optarg, 'n', 0, 20);
break;
case 'o':
options.output = fopen(optarg, "w");
if (!options.output) {
fprintf(stderr,
- "Can't open %s for output: %s\n",
+ "can't open %s for writing: %s\n",
optarg, strerror(errno));
exit(1);
}
perror("ltrace: malloc");
exit(1);
}
- tmp->pid = atoi(optarg);
+ tmp->pid = parse_int(optarg, 'p', 1, 0);
tmp->next = opt_p;
opt_p = tmp;
break;
opt_r++;
break;
case 's':
- options.strlen = atoi(optarg);
+ options.strlen = parse_int(optarg, 's', 0, 0);
break;
case 'S':
options.syscalls = 1;
options.user = optarg;
break;
case 'V':
- printf("ltrace version " PACKAGE_VERSION ".\n"
- "Copyright (C) 1997-2009 Juan Cespedes <cespedes@debian.org>.\n"
- "This is free software; see the GNU General Public Licence\n"
- "version 2 or later for copying conditions. There is NO warranty.\n");
+ printf("ltrace " PACKAGE_VERSION "\n"
+ "Copyright (C) 2010-2013 Petr Machata, Red Hat Inc.\n"
+ "Copyright (C) 1997-2009 Juan Cespedes <cespedes@debian.org>.\n"
+ "License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>\n"
+ "This is free software: you are free to change and redistribute it.\n"
+ "There is NO WARRANTY, to the extent permitted by law.\n");
exit(0);
- case 'X':
-#ifdef PLT_REINITALISATION_BP
- PLTs_initialized_by_here = optarg;
-#else
- fprintf(stderr, "WARNING: \"-X\" not used for this "
- "architecture: assuming you meant \"-x\"\n");
-#endif
- /* Fall Thru */
+ break;
+#if defined(HAVE_LIBUNWIND)
+ case 'w':
+ options.bt_depth = parse_int(optarg, 'w', 1, 0);
+ break;
+#endif /* defined(HAVE_LIBUNWIND) */
case 'x':
- {
- struct opt_x_t *p = opt_x;
-
- /* First, check for duplicate. */
- while (p && strcmp(p->name, optarg)) {
- p = p->next;
- }
- if (p) {
- break;
- }
-
- /* If not duplicate, add to list. */
- p = malloc(sizeof(struct opt_x_t));
- if (!p) {
- perror("ltrace: malloc");
- exit(1);
- }
- p->name = optarg;
- p->found = 0;
- p->next = opt_x;
- opt_x = p;
- break;
- }
+ parse_filter_chain(optarg, &options.static_filter);
+ break;
default:
err_usage();
argc -= optind;
argv += optind;
- if (!opt_F) {
- opt_F = malloc(sizeof(struct opt_F_t));
- opt_F->next = malloc(sizeof(struct opt_F_t));
- opt_F->next->next = NULL;
- opt_F->filename = USER_CONFIG_FILE;
- opt_F->next->filename = SYSTEM_CONFIG_FILE;
+ /* If neither -e, nor -l, nor -L are used, set default -e.
+ * Use @MAIN for now, as that's what ltrace used to have in
+ * the past. XXX Maybe we should make this "*" instead. */
+ if (libcalls
+ && options.plt_filter == NULL
+ && options.export_filter == NULL) {
+ parse_filter_chain("@MAIN", &options.plt_filter);
+ options.hide_caller = 1;
}
- /* Reverse the config file list since it was built by
- * prepending, and it would make more sense to process the
- * files in the order they were given. Probably it would make
- * more sense to keep a tail pointer instead? */
- {
- struct opt_F_t *egg = NULL;
- struct opt_F_t *chicken;
- while (opt_F) {
- chicken = opt_F->next;
- opt_F->next = egg;
- egg = opt_F;
- opt_F = chicken;
- }
- opt_F = egg;
+ if (!libcalls && options.plt_filter != NULL) {
+ fprintf(stderr,
+ "%s: Option -L can't be used with -e or -l.\n",
+ progname);
+ err_usage();
}
if (!opt_p && argc < 1) {
err_usage();
}
if (opt_r && opt_t) {
- fprintf(stderr, "%s: Incompatible options -r and -t\n",
+ fprintf(stderr,
+ "%s: Options -r and -t can't be used together\n",
progname);
err_usage();
}
projects / platform / upstream / ltrace.git / blobdiff