17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 52b6e762cSahl * Common Development and Distribution License (the "License"). 62b6e762cSahl * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21e4586ebfSmws 227c478bd9Sstevel@tonic-gate /* 23e4586ebfSmws * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 26e5803b76SAdam H. Leventhal /* 27e5803b76SAdam H. Leventhal * Copyright (c) 2012 by Delphix. All rights reserved. 28*a386cc11SRobert Mustacchi * Copyright (c) 2013, Joyent, Inc. All rights reserved. 29e5803b76SAdam H. Leventhal */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #include <sys/types.h> 327c478bd9Sstevel@tonic-gate #include <sys/stat.h> 337c478bd9Sstevel@tonic-gate #include <sys/wait.h> 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #include <dtrace.h> 367c478bd9Sstevel@tonic-gate #include <stdlib.h> 377c478bd9Sstevel@tonic-gate #include <stdarg.h> 387c478bd9Sstevel@tonic-gate #include <stdio.h> 397c478bd9Sstevel@tonic-gate #include <strings.h> 407c478bd9Sstevel@tonic-gate #include <unistd.h> 417c478bd9Sstevel@tonic-gate #include <limits.h> 427c478bd9Sstevel@tonic-gate #include <fcntl.h> 437c478bd9Sstevel@tonic-gate #include <errno.h> 447c478bd9Sstevel@tonic-gate #include <signal.h> 457c478bd9Sstevel@tonic-gate #include <alloca.h> 467c478bd9Sstevel@tonic-gate #include <libgen.h> 477c478bd9Sstevel@tonic-gate #include <libproc.h> 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate typedef struct dtrace_cmd { 507c478bd9Sstevel@tonic-gate void (*dc_func)(struct dtrace_cmd *); /* function to compile arg */ 517c478bd9Sstevel@tonic-gate dtrace_probespec_t dc_spec; /* probe specifier context */ 527c478bd9Sstevel@tonic-gate char *dc_arg; /* argument from main argv */ 537c478bd9Sstevel@tonic-gate const char *dc_name; /* name for error messages */ 547c478bd9Sstevel@tonic-gate const char *dc_desc; /* desc for error messages */ 557c478bd9Sstevel@tonic-gate dtrace_prog_t *dc_prog; /* program compiled from arg */ 560b38a8bdSahl char dc_ofile[PATH_MAX]; /* derived output file name */ 577c478bd9Sstevel@tonic-gate } dtrace_cmd_t; 587c478bd9Sstevel@tonic-gate 597c478bd9Sstevel@tonic-gate #define DMODE_VERS 0 /* display version information and exit (-V) */ 607c478bd9Sstevel@tonic-gate #define DMODE_EXEC 1 /* compile program for enabling (-a/e/E) */ 617c478bd9Sstevel@tonic-gate #define DMODE_ANON 2 /* compile program for anonymous tracing (-A) */ 627c478bd9Sstevel@tonic-gate #define DMODE_LINK 3 /* compile program for linking with ELF (-G) */ 637c478bd9Sstevel@tonic-gate #define DMODE_LIST 4 /* compile program and list probes (-l) */ 64900524f3Sahl #define DMODE_HEADER 5 /* compile program for headergen (-h) */ 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate #define E_SUCCESS 0 677c478bd9Sstevel@tonic-gate #define E_ERROR 1 687c478bd9Sstevel@tonic-gate #define E_USAGE 2 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate static const char DTRACE_OPTSTR[] = 71900524f3Sahl "3:6:aAb:Bc:CD:ef:FGhHi:I:lL:m:n:o:p:P:qs:SU:vVwx:X:Z"; 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate static char **g_argv; 747c478bd9Sstevel@tonic-gate static int g_argc; 757c478bd9Sstevel@tonic-gate static char **g_objv; 767c478bd9Sstevel@tonic-gate static int g_objc; 777c478bd9Sstevel@tonic-gate static dtrace_cmd_t *g_cmdv; 787c478bd9Sstevel@tonic-gate static int g_cmdc; 797c478bd9Sstevel@tonic-gate static struct ps_prochandle **g_psv; 807c478bd9Sstevel@tonic-gate static int g_psc; 817c478bd9Sstevel@tonic-gate static int g_pslive; 827c478bd9Sstevel@tonic-gate static char *g_pname; 837c478bd9Sstevel@tonic-gate static int g_quiet; 847c478bd9Sstevel@tonic-gate static int g_flowindent; 857c478bd9Sstevel@tonic-gate static int g_intr; 867c478bd9Sstevel@tonic-gate static int g_impatient; 877c478bd9Sstevel@tonic-gate static int g_newline; 887c478bd9Sstevel@tonic-gate static int g_total; 897c478bd9Sstevel@tonic-gate static int g_cflags; 907c478bd9Sstevel@tonic-gate static int g_oflags; 917c478bd9Sstevel@tonic-gate static int g_verbose; 927c478bd9Sstevel@tonic-gate static int g_exec = 1; 937c478bd9Sstevel@tonic-gate static int g_mode = DMODE_EXEC; 947c478bd9Sstevel@tonic-gate static int g_status = E_SUCCESS; 957c478bd9Sstevel@tonic-gate static int g_grabanon = 0; 967c478bd9Sstevel@tonic-gate static const char *g_ofile = NULL; 977c478bd9Sstevel@tonic-gate static FILE *g_ofp = stdout; 987c478bd9Sstevel@tonic-gate static dtrace_hdl_t *g_dtp; 997c478bd9Sstevel@tonic-gate static char *g_etcfile = "/etc/system"; 1007c478bd9Sstevel@tonic-gate static const char *g_etcbegin = "* vvvv Added by DTrace"; 1017c478bd9Sstevel@tonic-gate static const char *g_etcend = "* ^^^^ Added by DTrace"; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate static const char *g_etc[] = { 1047c478bd9Sstevel@tonic-gate "*", 1057c478bd9Sstevel@tonic-gate "* The following forceload directives were added by dtrace(1M) to allow for", 1067c478bd9Sstevel@tonic-gate "* tracing during boot. If these directives are removed, the system will", 1077c478bd9Sstevel@tonic-gate "* continue to function, but tracing will not occur during boot as desired.", 1087c478bd9Sstevel@tonic-gate "* To remove these directives (and this block comment) automatically, run", 1097c478bd9Sstevel@tonic-gate "* \"dtrace -A\" without additional arguments. See the \"Anonymous Tracing\"", 1107c478bd9Sstevel@tonic-gate "* chapter of the Solaris Dynamic Tracing Guide for details.", 1117c478bd9Sstevel@tonic-gate "*", 1127c478bd9Sstevel@tonic-gate NULL }; 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate static int 1157c478bd9Sstevel@tonic-gate usage(FILE *fp) 1167c478bd9Sstevel@tonic-gate { 1177c478bd9Sstevel@tonic-gate static const char predact[] = "[[ predicate ] action ]"; 1187c478bd9Sstevel@tonic-gate 119900524f3Sahl (void) fprintf(fp, "Usage: %s [-32|-64] [-aACeFGhHlqSvVwZ] " 1207c478bd9Sstevel@tonic-gate "[-b bufsz] [-c cmd] [-D name[=def]]\n\t[-I path] [-L path] " 1217c478bd9Sstevel@tonic-gate "[-o output] [-p pid] [-s script] [-U name]\n\t" 1227c478bd9Sstevel@tonic-gate "[-x opt[=val]] [-X a|c|s|t]\n\n" 1237c478bd9Sstevel@tonic-gate "\t[-P provider %s]\n" 1247c478bd9Sstevel@tonic-gate "\t[-m [ provider: ] module %s]\n" 1257c478bd9Sstevel@tonic-gate "\t[-f [[ provider: ] module: ] func %s]\n" 1267c478bd9Sstevel@tonic-gate "\t[-n [[[ provider: ] module: ] func: ] name %s]\n" 1277c478bd9Sstevel@tonic-gate "\t[-i probe-id %s] [ args ... ]\n\n", g_pname, 1287c478bd9Sstevel@tonic-gate predact, predact, predact, predact, predact); 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tpredicate -> '/' D-expression '/'\n"); 1317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t action -> '{' D-statements '}'\n"); 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n" 1347c478bd9Sstevel@tonic-gate "\t-32 generate 32-bit D programs and ELF files\n" 1357c478bd9Sstevel@tonic-gate "\t-64 generate 64-bit D programs and ELF files\n\n" 1367c478bd9Sstevel@tonic-gate "\t-a claim anonymous tracing state\n" 1377c478bd9Sstevel@tonic-gate "\t-A generate driver.conf(4) directives for anonymous tracing\n" 1387c478bd9Sstevel@tonic-gate "\t-b set trace buffer size\n" 1397c478bd9Sstevel@tonic-gate "\t-c run specified command and exit upon its completion\n" 1407c478bd9Sstevel@tonic-gate "\t-C run cpp(1) preprocessor on script files\n" 1417c478bd9Sstevel@tonic-gate "\t-D define symbol when invoking preprocessor\n" 1427c478bd9Sstevel@tonic-gate "\t-e exit after compiling request but prior to enabling probes\n" 1437c478bd9Sstevel@tonic-gate "\t-f enable or list probes matching the specified function name\n" 1447c478bd9Sstevel@tonic-gate "\t-F coalesce trace output by function\n" 1457c478bd9Sstevel@tonic-gate "\t-G generate an ELF file containing embedded dtrace program\n" 146900524f3Sahl "\t-h generate a header file with definitions for static probes\n" 1477c478bd9Sstevel@tonic-gate "\t-H print included files when invoking preprocessor\n" 1487c478bd9Sstevel@tonic-gate "\t-i enable or list probes matching the specified probe id\n" 1497c478bd9Sstevel@tonic-gate "\t-I add include directory to preprocessor search path\n" 1507c478bd9Sstevel@tonic-gate "\t-l list probes matching specified criteria\n" 1517c478bd9Sstevel@tonic-gate "\t-L add library directory to library search path\n" 1527c478bd9Sstevel@tonic-gate "\t-m enable or list probes matching the specified module name\n" 1537c478bd9Sstevel@tonic-gate "\t-n enable or list probes matching the specified probe name\n" 1547c478bd9Sstevel@tonic-gate "\t-o set output file\n" 1557c478bd9Sstevel@tonic-gate "\t-p grab specified process-ID and cache its symbol tables\n" 1567c478bd9Sstevel@tonic-gate "\t-P enable or list probes matching the specified provider name\n" 1577c478bd9Sstevel@tonic-gate "\t-q set quiet mode (only output explicitly traced data)\n" 1587c478bd9Sstevel@tonic-gate "\t-s enable or list probes according to the specified D script\n" 1597c478bd9Sstevel@tonic-gate "\t-S print D compiler intermediate code\n" 1607c478bd9Sstevel@tonic-gate "\t-U undefine symbol when invoking preprocessor\n" 1617c478bd9Sstevel@tonic-gate "\t-v set verbose mode (report stability attributes, arguments)\n" 1627c478bd9Sstevel@tonic-gate "\t-V report DTrace API version\n" 1637c478bd9Sstevel@tonic-gate "\t-w permit destructive actions\n" 1647c478bd9Sstevel@tonic-gate "\t-x enable or modify compiler and tracing options\n" 1657c478bd9Sstevel@tonic-gate "\t-X specify ISO C conformance settings for preprocessor\n" 1667c478bd9Sstevel@tonic-gate "\t-Z permit probe descriptions that match zero probes\n"); 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate return (E_USAGE); 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate static void 1727c478bd9Sstevel@tonic-gate verror(const char *fmt, va_list ap) 1737c478bd9Sstevel@tonic-gate { 1747c478bd9Sstevel@tonic-gate int error = errno; 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", g_pname); 1777c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, ap); 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate if (fmt[strlen(fmt) - 1] != '\n') 1807c478bd9Sstevel@tonic-gate (void) fprintf(stderr, ": %s\n", strerror(error)); 1817c478bd9Sstevel@tonic-gate } 1827c478bd9Sstevel@tonic-gate 1837c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 1847c478bd9Sstevel@tonic-gate static void 1857c478bd9Sstevel@tonic-gate fatal(const char *fmt, ...) 1867c478bd9Sstevel@tonic-gate { 1877c478bd9Sstevel@tonic-gate va_list ap; 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate va_start(ap, fmt); 1907c478bd9Sstevel@tonic-gate verror(fmt, ap); 1917c478bd9Sstevel@tonic-gate va_end(ap); 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate exit(E_ERROR); 1947c478bd9Sstevel@tonic-gate } 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 1977c478bd9Sstevel@tonic-gate static void 1987c478bd9Sstevel@tonic-gate dfatal(const char *fmt, ...) 1997c478bd9Sstevel@tonic-gate { 2007c478bd9Sstevel@tonic-gate va_list ap; 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate va_start(ap, fmt); 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", g_pname); 2057c478bd9Sstevel@tonic-gate if (fmt != NULL) 2067c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, ap); 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate va_end(ap); 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate if (fmt != NULL && fmt[strlen(fmt) - 1] != '\n') { 2117c478bd9Sstevel@tonic-gate (void) fprintf(stderr, ": %s\n", 2127c478bd9Sstevel@tonic-gate dtrace_errmsg(g_dtp, dtrace_errno(g_dtp))); 2137c478bd9Sstevel@tonic-gate } else if (fmt == NULL) { 2147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s\n", 2157c478bd9Sstevel@tonic-gate dtrace_errmsg(g_dtp, dtrace_errno(g_dtp))); 2167c478bd9Sstevel@tonic-gate } 2177c478bd9Sstevel@tonic-gate 2182b6e762cSahl /* 2192b6e762cSahl * Close the DTrace handle to ensure that any controlled processes are 2202b6e762cSahl * correctly restored and continued. 2212b6e762cSahl */ 2222b6e762cSahl dtrace_close(g_dtp); 2232b6e762cSahl 2247c478bd9Sstevel@tonic-gate exit(E_ERROR); 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 2287c478bd9Sstevel@tonic-gate static void 2297c478bd9Sstevel@tonic-gate error(const char *fmt, ...) 2307c478bd9Sstevel@tonic-gate { 2317c478bd9Sstevel@tonic-gate va_list ap; 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate va_start(ap, fmt); 2347c478bd9Sstevel@tonic-gate verror(fmt, ap); 2357c478bd9Sstevel@tonic-gate va_end(ap); 2367c478bd9Sstevel@tonic-gate } 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 2397c478bd9Sstevel@tonic-gate static void 2407c478bd9Sstevel@tonic-gate notice(const char *fmt, ...) 2417c478bd9Sstevel@tonic-gate { 2427c478bd9Sstevel@tonic-gate va_list ap; 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate if (g_quiet) 2457c478bd9Sstevel@tonic-gate return; /* -q or quiet pragma suppresses notice()s */ 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate va_start(ap, fmt); 2487c478bd9Sstevel@tonic-gate verror(fmt, ap); 2497c478bd9Sstevel@tonic-gate va_end(ap); 2507c478bd9Sstevel@tonic-gate } 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 2537c478bd9Sstevel@tonic-gate static void 2547c478bd9Sstevel@tonic-gate oprintf(const char *fmt, ...) 2557c478bd9Sstevel@tonic-gate { 2567c478bd9Sstevel@tonic-gate va_list ap; 2577c478bd9Sstevel@tonic-gate int n; 2587c478bd9Sstevel@tonic-gate 25930ef842dSbmc if (g_ofp == NULL) 26030ef842dSbmc return; 26130ef842dSbmc 2627c478bd9Sstevel@tonic-gate va_start(ap, fmt); 2637c478bd9Sstevel@tonic-gate n = vfprintf(g_ofp, fmt, ap); 2647c478bd9Sstevel@tonic-gate va_end(ap); 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate if (n < 0) { 2677c478bd9Sstevel@tonic-gate if (errno != EINTR) { 2687c478bd9Sstevel@tonic-gate fatal("failed to write to %s", 2697c478bd9Sstevel@tonic-gate g_ofile ? g_ofile : "<stdout>"); 2707c478bd9Sstevel@tonic-gate } 2717c478bd9Sstevel@tonic-gate clearerr(g_ofp); 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate } 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate static char ** 2767c478bd9Sstevel@tonic-gate make_argv(char *s) 2777c478bd9Sstevel@tonic-gate { 2787c478bd9Sstevel@tonic-gate const char *ws = "\f\n\r\t\v "; 2797c478bd9Sstevel@tonic-gate char **argv = malloc(sizeof (char *) * (strlen(s) / 2 + 1)); 2807c478bd9Sstevel@tonic-gate int argc = 0; 2817c478bd9Sstevel@tonic-gate char *p = s; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate if (argv == NULL) 2847c478bd9Sstevel@tonic-gate return (NULL); 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate for (p = strtok(s, ws); p != NULL; p = strtok(NULL, ws)) 2877c478bd9Sstevel@tonic-gate argv[argc++] = p; 2887c478bd9Sstevel@tonic-gate 2897c478bd9Sstevel@tonic-gate if (argc == 0) 2907c478bd9Sstevel@tonic-gate argv[argc++] = s; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate argv[argc] = NULL; 2937c478bd9Sstevel@tonic-gate return (argv); 2947c478bd9Sstevel@tonic-gate } 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate static void 2977c478bd9Sstevel@tonic-gate dof_prune(const char *fname) 2987c478bd9Sstevel@tonic-gate { 2997c478bd9Sstevel@tonic-gate struct stat sbuf; 3007c478bd9Sstevel@tonic-gate size_t sz, i, j, mark, len; 3017c478bd9Sstevel@tonic-gate char *buf; 3027c478bd9Sstevel@tonic-gate int msg = 0, fd; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate if ((fd = open(fname, O_RDONLY)) == -1) { 3057c478bd9Sstevel@tonic-gate /* 3067c478bd9Sstevel@tonic-gate * This is okay only if the file doesn't exist at all. 3077c478bd9Sstevel@tonic-gate */ 3087c478bd9Sstevel@tonic-gate if (errno != ENOENT) 3097c478bd9Sstevel@tonic-gate fatal("failed to open %s", fname); 3107c478bd9Sstevel@tonic-gate return; 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate if (fstat(fd, &sbuf) == -1) 3147c478bd9Sstevel@tonic-gate fatal("failed to fstat %s", fname); 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate if ((buf = malloc((sz = sbuf.st_size) + 1)) == NULL) 3177c478bd9Sstevel@tonic-gate fatal("failed to allocate memory for %s", fname); 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate if (read(fd, buf, sz) != sz) 3207c478bd9Sstevel@tonic-gate fatal("failed to read %s", fname); 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate buf[sz] = '\0'; 3237c478bd9Sstevel@tonic-gate (void) close(fd); 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate if ((fd = open(fname, O_WRONLY | O_TRUNC)) == -1) 3267c478bd9Sstevel@tonic-gate fatal("failed to open %s for writing", fname); 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate len = strlen("dof-data-"); 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate for (mark = 0, i = 0; i < sz; i++) { 3317c478bd9Sstevel@tonic-gate if (strncmp(&buf[i], "dof-data-", len) != 0) 3327c478bd9Sstevel@tonic-gate continue; 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate /* 3357c478bd9Sstevel@tonic-gate * This is only a match if it's in the 0th column. 3367c478bd9Sstevel@tonic-gate */ 3377c478bd9Sstevel@tonic-gate if (i != 0 && buf[i - 1] != '\n') 3387c478bd9Sstevel@tonic-gate continue; 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate if (msg++ == 0) { 3417c478bd9Sstevel@tonic-gate error("cleaned up old anonymous " 3427c478bd9Sstevel@tonic-gate "enabling in %s\n", fname); 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate /* 3467c478bd9Sstevel@tonic-gate * We have a match. First write out our data up until now. 3477c478bd9Sstevel@tonic-gate */ 3487c478bd9Sstevel@tonic-gate if (i != mark) { 3497c478bd9Sstevel@tonic-gate if (write(fd, &buf[mark], i - mark) != i - mark) 3507c478bd9Sstevel@tonic-gate fatal("failed to write to %s", fname); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate /* 3547c478bd9Sstevel@tonic-gate * Now scan forward until we scan past a newline. 3557c478bd9Sstevel@tonic-gate */ 3567c478bd9Sstevel@tonic-gate for (j = i; j < sz && buf[j] != '\n'; j++) 3577c478bd9Sstevel@tonic-gate continue; 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate /* 3607c478bd9Sstevel@tonic-gate * Reset our mark. 3617c478bd9Sstevel@tonic-gate */ 3627c478bd9Sstevel@tonic-gate if ((mark = j + 1) >= sz) 3637c478bd9Sstevel@tonic-gate break; 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate i = j; 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate if (mark < sz) { 3697c478bd9Sstevel@tonic-gate if (write(fd, &buf[mark], sz - mark) != sz - mark) 3707c478bd9Sstevel@tonic-gate fatal("failed to write to %s", fname); 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate (void) close(fd); 3747c478bd9Sstevel@tonic-gate free(buf); 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate static void 3787c478bd9Sstevel@tonic-gate etcsystem_prune(void) 3797c478bd9Sstevel@tonic-gate { 3807c478bd9Sstevel@tonic-gate struct stat sbuf; 3817c478bd9Sstevel@tonic-gate size_t sz; 3827c478bd9Sstevel@tonic-gate char *buf, *start, *end; 3837c478bd9Sstevel@tonic-gate int fd; 3847c478bd9Sstevel@tonic-gate char *fname = g_etcfile, *tmpname; 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate if ((fd = open(fname, O_RDONLY)) == -1) 3877c478bd9Sstevel@tonic-gate fatal("failed to open %s", fname); 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate if (fstat(fd, &sbuf) == -1) 3907c478bd9Sstevel@tonic-gate fatal("failed to fstat %s", fname); 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate if ((buf = malloc((sz = sbuf.st_size) + 1)) == NULL) 3937c478bd9Sstevel@tonic-gate fatal("failed to allocate memory for %s", fname); 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate if (read(fd, buf, sz) != sz) 3967c478bd9Sstevel@tonic-gate fatal("failed to read %s", fname); 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate buf[sz] = '\0'; 3997c478bd9Sstevel@tonic-gate (void) close(fd); 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate if ((start = strstr(buf, g_etcbegin)) == NULL) 4027c478bd9Sstevel@tonic-gate goto out; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate if (strlen(buf) != sz) { 4057c478bd9Sstevel@tonic-gate fatal("embedded nul byte in %s; manual repair of %s " 4067c478bd9Sstevel@tonic-gate "required\n", fname, fname); 4077c478bd9Sstevel@tonic-gate } 4087c478bd9Sstevel@tonic-gate 4097c478bd9Sstevel@tonic-gate if (strstr(start + 1, g_etcbegin) != NULL) { 4107c478bd9Sstevel@tonic-gate fatal("multiple start sentinels in %s; manual repair of %s " 4117c478bd9Sstevel@tonic-gate "required\n", fname, fname); 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate if ((end = strstr(buf, g_etcend)) == NULL) { 4157c478bd9Sstevel@tonic-gate fatal("missing end sentinel in %s; manual repair of %s " 4167c478bd9Sstevel@tonic-gate "required\n", fname, fname); 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate if (start > end) { 4207c478bd9Sstevel@tonic-gate fatal("end sentinel preceeds start sentinel in %s; manual " 4217c478bd9Sstevel@tonic-gate "repair of %s required\n", fname, fname); 4227c478bd9Sstevel@tonic-gate } 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate end += strlen(g_etcend) + 1; 4257c478bd9Sstevel@tonic-gate bcopy(end, start, strlen(end) + 1); 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate tmpname = alloca(sz = strlen(fname) + 80); 4287c478bd9Sstevel@tonic-gate (void) snprintf(tmpname, sz, "%s.dtrace.%d", fname, getpid()); 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate if ((fd = open(tmpname, 4317c478bd9Sstevel@tonic-gate O_WRONLY | O_CREAT | O_EXCL, sbuf.st_mode)) == -1) 4327c478bd9Sstevel@tonic-gate fatal("failed to create %s", tmpname); 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate if (write(fd, buf, strlen(buf)) < strlen(buf)) { 4357c478bd9Sstevel@tonic-gate (void) unlink(tmpname); 4367c478bd9Sstevel@tonic-gate fatal("failed to write to %s", tmpname); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate (void) close(fd); 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if (chown(tmpname, sbuf.st_uid, sbuf.st_gid) != 0) { 4427c478bd9Sstevel@tonic-gate (void) unlink(tmpname); 4437c478bd9Sstevel@tonic-gate fatal("failed to chown(2) %s to uid %d, gid %d", tmpname, 4447c478bd9Sstevel@tonic-gate (int)sbuf.st_uid, (int)sbuf.st_gid); 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate if (rename(tmpname, fname) == -1) 4487c478bd9Sstevel@tonic-gate fatal("rename of %s to %s failed", tmpname, fname); 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate error("cleaned up forceload directives in %s\n", fname); 4517c478bd9Sstevel@tonic-gate out: 4527c478bd9Sstevel@tonic-gate free(buf); 4537c478bd9Sstevel@tonic-gate } 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate static void 4567c478bd9Sstevel@tonic-gate etcsystem_add(void) 4577c478bd9Sstevel@tonic-gate { 4587c478bd9Sstevel@tonic-gate const char *mods[20]; 4597c478bd9Sstevel@tonic-gate int nmods, line; 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate if ((g_ofp = fopen(g_ofile = g_etcfile, "a")) == NULL) 4627c478bd9Sstevel@tonic-gate fatal("failed to open output file '%s'", g_ofile); 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate oprintf("%s\n", g_etcbegin); 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate for (line = 0; g_etc[line] != NULL; line++) 4677c478bd9Sstevel@tonic-gate oprintf("%s\n", g_etc[line]); 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate nmods = dtrace_provider_modules(g_dtp, mods, 4707c478bd9Sstevel@tonic-gate sizeof (mods) / sizeof (char *) - 1); 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate if (nmods >= sizeof (mods) / sizeof (char *)) 4737c478bd9Sstevel@tonic-gate fatal("unexpectedly large number of modules!"); 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate mods[nmods++] = "dtrace"; 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate for (line = 0; line < nmods; line++) 4787c478bd9Sstevel@tonic-gate oprintf("forceload: drv/%s\n", mods[line]); 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate oprintf("%s\n", g_etcend); 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate if (fclose(g_ofp) == EOF) 4837c478bd9Sstevel@tonic-gate fatal("failed to close output file '%s'", g_ofile); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate error("added forceload directives to %s\n", g_ofile); 4867c478bd9Sstevel@tonic-gate } 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate static void 4897c478bd9Sstevel@tonic-gate print_probe_info(const dtrace_probeinfo_t *p) 4907c478bd9Sstevel@tonic-gate { 4917c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 492*a386cc11SRobert Mustacchi char *user; 4937c478bd9Sstevel@tonic-gate int i; 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate oprintf("\n\tProbe Description Attributes\n"); 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate oprintf("\t\tIdentifier Names: %s\n", 4987c478bd9Sstevel@tonic-gate dtrace_stability_name(p->dtp_attr.dtat_name)); 4997c478bd9Sstevel@tonic-gate oprintf("\t\tData Semantics: %s\n", 5007c478bd9Sstevel@tonic-gate dtrace_stability_name(p->dtp_attr.dtat_data)); 5017c478bd9Sstevel@tonic-gate oprintf("\t\tDependency Class: %s\n", 5027c478bd9Sstevel@tonic-gate dtrace_class_name(p->dtp_attr.dtat_class)); 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate oprintf("\n\tArgument Attributes\n"); 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate oprintf("\t\tIdentifier Names: %s\n", 5077c478bd9Sstevel@tonic-gate dtrace_stability_name(p->dtp_arga.dtat_name)); 5087c478bd9Sstevel@tonic-gate oprintf("\t\tData Semantics: %s\n", 5097c478bd9Sstevel@tonic-gate dtrace_stability_name(p->dtp_arga.dtat_data)); 5107c478bd9Sstevel@tonic-gate oprintf("\t\tDependency Class: %s\n", 5117c478bd9Sstevel@tonic-gate dtrace_class_name(p->dtp_arga.dtat_class)); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate oprintf("\n\tArgument Types\n"); 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate for (i = 0; i < p->dtp_argc; i++) { 516*a386cc11SRobert Mustacchi if (p->dtp_argv[i].dtt_flags & DTT_FL_USER) 517*a386cc11SRobert Mustacchi user = "userland "; 518*a386cc11SRobert Mustacchi else 519*a386cc11SRobert Mustacchi user = ""; 5207c478bd9Sstevel@tonic-gate if (ctf_type_name(p->dtp_argv[i].dtt_ctfp, 5217c478bd9Sstevel@tonic-gate p->dtp_argv[i].dtt_type, buf, sizeof (buf)) == NULL) 5227c478bd9Sstevel@tonic-gate (void) strlcpy(buf, "(unknown)", sizeof (buf)); 523*a386cc11SRobert Mustacchi oprintf("\t\targs[%d]: %s%s\n", i, user, buf); 5247c478bd9Sstevel@tonic-gate } 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate if (p->dtp_argc == 0) 5277c478bd9Sstevel@tonic-gate oprintf("\t\tNone\n"); 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate oprintf("\n"); 5307c478bd9Sstevel@tonic-gate } 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5337c478bd9Sstevel@tonic-gate static int 5347c478bd9Sstevel@tonic-gate info_stmt(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, 5357c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *stp, dtrace_ecbdesc_t **last) 5367c478bd9Sstevel@tonic-gate { 5377c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp = stp->dtsd_ecbdesc; 5387c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pdp = &edp->dted_probe; 5397c478bd9Sstevel@tonic-gate dtrace_probeinfo_t p; 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate if (edp == *last) 5427c478bd9Sstevel@tonic-gate return (0); 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate oprintf("\n%s:%s:%s:%s\n", 5457c478bd9Sstevel@tonic-gate pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate if (dtrace_probe_info(dtp, pdp, &p) == 0) 5487c478bd9Sstevel@tonic-gate print_probe_info(&p); 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate *last = edp; 5517c478bd9Sstevel@tonic-gate return (0); 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate /* 5557c478bd9Sstevel@tonic-gate * Execute the specified program by enabling the corresponding instrumentation. 5567c478bd9Sstevel@tonic-gate * If -e has been specified, we get the program info but do not enable it. If 5577c478bd9Sstevel@tonic-gate * -v has been specified, we print a stability report for the program. 5587c478bd9Sstevel@tonic-gate */ 5597c478bd9Sstevel@tonic-gate static void 5607c478bd9Sstevel@tonic-gate exec_prog(const dtrace_cmd_t *dcp) 5617c478bd9Sstevel@tonic-gate { 5627c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *last = NULL; 5637c478bd9Sstevel@tonic-gate dtrace_proginfo_t dpi; 5647c478bd9Sstevel@tonic-gate 5657c478bd9Sstevel@tonic-gate if (!g_exec) { 5667c478bd9Sstevel@tonic-gate dtrace_program_info(g_dtp, dcp->dc_prog, &dpi); 5677c478bd9Sstevel@tonic-gate } else if (dtrace_program_exec(g_dtp, dcp->dc_prog, &dpi) == -1) { 5687c478bd9Sstevel@tonic-gate dfatal("failed to enable '%s'", dcp->dc_name); 5697c478bd9Sstevel@tonic-gate } else { 5707c478bd9Sstevel@tonic-gate notice("%s '%s' matched %u probe%s\n", 5717c478bd9Sstevel@tonic-gate dcp->dc_desc, dcp->dc_name, 5727c478bd9Sstevel@tonic-gate dpi.dpi_matches, dpi.dpi_matches == 1 ? "" : "s"); 5737c478bd9Sstevel@tonic-gate } 5747c478bd9Sstevel@tonic-gate 5757c478bd9Sstevel@tonic-gate if (g_verbose) { 5767c478bd9Sstevel@tonic-gate oprintf("\nStability attributes for %s %s:\n", 5777c478bd9Sstevel@tonic-gate dcp->dc_desc, dcp->dc_name); 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate oprintf("\n\tMinimum Probe Description Attributes\n"); 5807c478bd9Sstevel@tonic-gate oprintf("\t\tIdentifier Names: %s\n", 5817c478bd9Sstevel@tonic-gate dtrace_stability_name(dpi.dpi_descattr.dtat_name)); 5827c478bd9Sstevel@tonic-gate oprintf("\t\tData Semantics: %s\n", 5837c478bd9Sstevel@tonic-gate dtrace_stability_name(dpi.dpi_descattr.dtat_data)); 5847c478bd9Sstevel@tonic-gate oprintf("\t\tDependency Class: %s\n", 5857c478bd9Sstevel@tonic-gate dtrace_class_name(dpi.dpi_descattr.dtat_class)); 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate oprintf("\n\tMinimum Statement Attributes\n"); 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate oprintf("\t\tIdentifier Names: %s\n", 5907c478bd9Sstevel@tonic-gate dtrace_stability_name(dpi.dpi_stmtattr.dtat_name)); 5917c478bd9Sstevel@tonic-gate oprintf("\t\tData Semantics: %s\n", 5927c478bd9Sstevel@tonic-gate dtrace_stability_name(dpi.dpi_stmtattr.dtat_data)); 5937c478bd9Sstevel@tonic-gate oprintf("\t\tDependency Class: %s\n", 5947c478bd9Sstevel@tonic-gate dtrace_class_name(dpi.dpi_stmtattr.dtat_class)); 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate if (!g_exec) { 5977c478bd9Sstevel@tonic-gate (void) dtrace_stmt_iter(g_dtp, dcp->dc_prog, 5987c478bd9Sstevel@tonic-gate (dtrace_stmt_f *)info_stmt, &last); 5997c478bd9Sstevel@tonic-gate } else 6007c478bd9Sstevel@tonic-gate oprintf("\n"); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate g_total += dpi.dpi_matches; 6047c478bd9Sstevel@tonic-gate } 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate /* 6077c478bd9Sstevel@tonic-gate * Print out the specified DOF buffer as a set of ASCII bytes appropriate for 6087c478bd9Sstevel@tonic-gate * storing in a driver.conf(4) file associated with the dtrace driver. 6097c478bd9Sstevel@tonic-gate */ 6107c478bd9Sstevel@tonic-gate static void 6117c478bd9Sstevel@tonic-gate anon_prog(const dtrace_cmd_t *dcp, dof_hdr_t *dof, int n) 6127c478bd9Sstevel@tonic-gate { 6137c478bd9Sstevel@tonic-gate const uchar_t *p, *q; 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate if (dof == NULL) 6167c478bd9Sstevel@tonic-gate dfatal("failed to create DOF image for '%s'", dcp->dc_name); 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate p = (uchar_t *)dof; 6197c478bd9Sstevel@tonic-gate q = p + dof->dofh_loadsz; 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate oprintf("dof-data-%d=0x%x", n, *p++); 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate while (p < q) 6247c478bd9Sstevel@tonic-gate oprintf(",0x%x", *p++); 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate oprintf(";\n"); 6277c478bd9Sstevel@tonic-gate dtrace_dof_destroy(g_dtp, dof); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate /* 6317c478bd9Sstevel@tonic-gate * Link the specified D program in DOF form into an ELF file for use in either 6327c478bd9Sstevel@tonic-gate * helpers, userland provider definitions, or both. If -o was specified, that 6337c478bd9Sstevel@tonic-gate * path is used as the output file name. If -o wasn't specified and the input 6347c478bd9Sstevel@tonic-gate * program is from a script whose name is %.d, use basename(%.o) as the output 6357c478bd9Sstevel@tonic-gate * file name. Otherwise we use "d.out" as the default output file name. 6367c478bd9Sstevel@tonic-gate */ 6377c478bd9Sstevel@tonic-gate static void 6380b38a8bdSahl link_prog(dtrace_cmd_t *dcp) 6397c478bd9Sstevel@tonic-gate { 6400b38a8bdSahl char *p; 6417c478bd9Sstevel@tonic-gate 6420b38a8bdSahl if (g_cmdc == 1 && g_ofile != NULL) { 6430b38a8bdSahl (void) strlcpy(dcp->dc_ofile, g_ofile, sizeof (dcp->dc_ofile)); 6447c478bd9Sstevel@tonic-gate } else if ((p = strrchr(dcp->dc_arg, '.')) != NULL && 6457c478bd9Sstevel@tonic-gate strcmp(p, ".d") == 0) { 6467c478bd9Sstevel@tonic-gate p[0] = '\0'; /* strip .d suffix */ 6470b38a8bdSahl (void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile), 6487c478bd9Sstevel@tonic-gate "%s.o", basename(dcp->dc_arg)); 6497c478bd9Sstevel@tonic-gate } else { 6500b38a8bdSahl (void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile), 6510b38a8bdSahl g_cmdc > 1 ? "%s.%d" : "%s", "d.out", (int)(dcp - g_cmdv)); 6527c478bd9Sstevel@tonic-gate } 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate if (dtrace_program_link(g_dtp, dcp->dc_prog, DTRACE_D_PROBES, 6552b6e762cSahl dcp->dc_ofile, g_objc, g_objv) != 0) 6567c478bd9Sstevel@tonic-gate dfatal("failed to link %s %s", dcp->dc_desc, dcp->dc_name); 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6607c478bd9Sstevel@tonic-gate static int 6617c478bd9Sstevel@tonic-gate list_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg) 6627c478bd9Sstevel@tonic-gate { 6637c478bd9Sstevel@tonic-gate dtrace_probeinfo_t p; 6647c478bd9Sstevel@tonic-gate 6657c478bd9Sstevel@tonic-gate oprintf("%5d %10s %17s %33s %s\n", pdp->dtpd_id, 6667c478bd9Sstevel@tonic-gate pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate if (g_verbose && dtrace_probe_info(dtp, pdp, &p) == 0) 6697c478bd9Sstevel@tonic-gate print_probe_info(&p); 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate return (0); 6727c478bd9Sstevel@tonic-gate } 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6757c478bd9Sstevel@tonic-gate static int 6767c478bd9Sstevel@tonic-gate list_stmt(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, 6777c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *stp, dtrace_ecbdesc_t **last) 6787c478bd9Sstevel@tonic-gate { 6797c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp = stp->dtsd_ecbdesc; 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate if (edp == *last) 6827c478bd9Sstevel@tonic-gate return (0); 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate if (dtrace_probe_iter(g_dtp, &edp->dted_probe, list_probe, NULL) != 0) { 6857c478bd9Sstevel@tonic-gate error("failed to match %s:%s:%s:%s: %s\n", 6867c478bd9Sstevel@tonic-gate edp->dted_probe.dtpd_provider, edp->dted_probe.dtpd_mod, 6877c478bd9Sstevel@tonic-gate edp->dted_probe.dtpd_func, edp->dted_probe.dtpd_name, 6887c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 6897c478bd9Sstevel@tonic-gate } 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate *last = edp; 6927c478bd9Sstevel@tonic-gate return (0); 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate /* 6967c478bd9Sstevel@tonic-gate * List the probes corresponding to the specified program by iterating over 6977c478bd9Sstevel@tonic-gate * each statement and then matching probes to the statement probe descriptions. 6987c478bd9Sstevel@tonic-gate */ 6997c478bd9Sstevel@tonic-gate static void 7007c478bd9Sstevel@tonic-gate list_prog(const dtrace_cmd_t *dcp) 7017c478bd9Sstevel@tonic-gate { 7027c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *last = NULL; 7037c478bd9Sstevel@tonic-gate 7047c478bd9Sstevel@tonic-gate (void) dtrace_stmt_iter(g_dtp, dcp->dc_prog, 7057c478bd9Sstevel@tonic-gate (dtrace_stmt_f *)list_stmt, &last); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate static void 7097c478bd9Sstevel@tonic-gate compile_file(dtrace_cmd_t *dcp) 7107c478bd9Sstevel@tonic-gate { 7117c478bd9Sstevel@tonic-gate char *arg0; 7127c478bd9Sstevel@tonic-gate FILE *fp; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate if ((fp = fopen(dcp->dc_arg, "r")) == NULL) 7157c478bd9Sstevel@tonic-gate fatal("failed to open %s", dcp->dc_arg); 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate arg0 = g_argv[0]; 7187c478bd9Sstevel@tonic-gate g_argv[0] = dcp->dc_arg; 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate if ((dcp->dc_prog = dtrace_program_fcompile(g_dtp, fp, 7217c478bd9Sstevel@tonic-gate g_cflags, g_argc, g_argv)) == NULL) 7227c478bd9Sstevel@tonic-gate dfatal("failed to compile script %s", dcp->dc_arg); 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate g_argv[0] = arg0; 7257c478bd9Sstevel@tonic-gate (void) fclose(fp); 7267c478bd9Sstevel@tonic-gate 7277c478bd9Sstevel@tonic-gate dcp->dc_desc = "script"; 7287c478bd9Sstevel@tonic-gate dcp->dc_name = dcp->dc_arg; 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate static void 7327c478bd9Sstevel@tonic-gate compile_str(dtrace_cmd_t *dcp) 7337c478bd9Sstevel@tonic-gate { 7347c478bd9Sstevel@tonic-gate char *p; 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate if ((dcp->dc_prog = dtrace_program_strcompile(g_dtp, dcp->dc_arg, 7377c478bd9Sstevel@tonic-gate dcp->dc_spec, g_cflags | DTRACE_C_PSPEC, g_argc, g_argv)) == NULL) 7387c478bd9Sstevel@tonic-gate dfatal("invalid probe specifier %s", dcp->dc_arg); 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate if ((p = strpbrk(dcp->dc_arg, "{/;")) != NULL) 7417c478bd9Sstevel@tonic-gate *p = '\0'; /* crop name for reporting */ 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate dcp->dc_desc = "description"; 7447c478bd9Sstevel@tonic-gate dcp->dc_name = dcp->dc_arg; 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7487c478bd9Sstevel@tonic-gate static void 749900524f3Sahl prochandler(struct ps_prochandle *P, const char *msg, void *arg) 7507c478bd9Sstevel@tonic-gate { 7517c478bd9Sstevel@tonic-gate const psinfo_t *prp = Ppsinfo(P); 7527c478bd9Sstevel@tonic-gate int pid = Pstatus(P)->pr_pid; 7537c478bd9Sstevel@tonic-gate char name[SIG2STR_MAX]; 7547c478bd9Sstevel@tonic-gate 755900524f3Sahl if (msg != NULL) { 756900524f3Sahl notice("pid %d: %s\n", pid, msg); 757900524f3Sahl return; 758900524f3Sahl } 759900524f3Sahl 7607c478bd9Sstevel@tonic-gate switch (Pstate(P)) { 7617c478bd9Sstevel@tonic-gate case PS_UNDEAD: 7627c478bd9Sstevel@tonic-gate /* 7637c478bd9Sstevel@tonic-gate * Ideally we would like to always report pr_wstat here, but it 7647c478bd9Sstevel@tonic-gate * isn't possible given current /proc semantics. If we grabbed 7657c478bd9Sstevel@tonic-gate * the process, Ppsinfo() will either fail or return a zeroed 7667c478bd9Sstevel@tonic-gate * psinfo_t depending on how far the parent is in reaping it. 7677c478bd9Sstevel@tonic-gate * When /proc provides a stable pr_wstat in the status file, 7687c478bd9Sstevel@tonic-gate * this code can be improved by examining this new pr_wstat. 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate if (prp != NULL && WIFSIGNALED(prp->pr_wstat)) { 7717c478bd9Sstevel@tonic-gate notice("pid %d terminated by %s\n", pid, 7727c478bd9Sstevel@tonic-gate proc_signame(WTERMSIG(prp->pr_wstat), 7737c478bd9Sstevel@tonic-gate name, sizeof (name))); 7747c478bd9Sstevel@tonic-gate } else if (prp != NULL && WEXITSTATUS(prp->pr_wstat) != 0) { 7757c478bd9Sstevel@tonic-gate notice("pid %d exited with status %d\n", 7767c478bd9Sstevel@tonic-gate pid, WEXITSTATUS(prp->pr_wstat)); 7777c478bd9Sstevel@tonic-gate } else { 7787c478bd9Sstevel@tonic-gate notice("pid %d has exited\n", pid); 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate g_pslive--; 7817c478bd9Sstevel@tonic-gate break; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate case PS_LOST: 7847c478bd9Sstevel@tonic-gate notice("pid %d exec'd a set-id or unobservable program\n", pid); 7857c478bd9Sstevel@tonic-gate g_pslive--; 7867c478bd9Sstevel@tonic-gate break; 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7917c478bd9Sstevel@tonic-gate static int 792a1b5e537Sbmc errhandler(const dtrace_errdata_t *data, void *arg) 7937c478bd9Sstevel@tonic-gate { 7947c478bd9Sstevel@tonic-gate error(data->dteda_msg); 7957c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 7967c478bd9Sstevel@tonic-gate } 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7997c478bd9Sstevel@tonic-gate static int 800a1b5e537Sbmc drophandler(const dtrace_dropdata_t *data, void *arg) 8017c478bd9Sstevel@tonic-gate { 8027c478bd9Sstevel@tonic-gate error(data->dtdda_msg); 8037c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 8047c478bd9Sstevel@tonic-gate } 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8077c478bd9Sstevel@tonic-gate static int 808a1b5e537Sbmc setopthandler(const dtrace_setoptdata_t *data, void *arg) 809a1b5e537Sbmc { 810a1b5e537Sbmc if (strcmp(data->dtsda_option, "quiet") == 0) 811a1b5e537Sbmc g_quiet = data->dtsda_newval != DTRACEOPT_UNSET; 812a1b5e537Sbmc 813a1b5e537Sbmc if (strcmp(data->dtsda_option, "flowindent") == 0) 814a1b5e537Sbmc g_flowindent = data->dtsda_newval != DTRACEOPT_UNSET; 815a1b5e537Sbmc 816a1b5e537Sbmc return (DTRACE_HANDLE_OK); 817a1b5e537Sbmc } 818a1b5e537Sbmc 81930ef842dSbmc #define BUFDUMPHDR(hdr) \ 82030ef842dSbmc (void) printf("%s: %s%s\n", g_pname, hdr, strlen(hdr) > 0 ? ":" : ""); 82130ef842dSbmc 82230ef842dSbmc #define BUFDUMPSTR(ptr, field) \ 82330ef842dSbmc (void) printf("%s: %20s => ", g_pname, #field); \ 82430ef842dSbmc if ((ptr)->field != NULL) { \ 82530ef842dSbmc const char *c = (ptr)->field; \ 82630ef842dSbmc (void) printf("\""); \ 82730ef842dSbmc do { \ 82830ef842dSbmc if (*c == '\n') { \ 82930ef842dSbmc (void) printf("\\n"); \ 83030ef842dSbmc continue; \ 83130ef842dSbmc } \ 83230ef842dSbmc \ 83330ef842dSbmc (void) printf("%c", *c); \ 83430ef842dSbmc } while (*c++ != '\0'); \ 83530ef842dSbmc (void) printf("\"\n"); \ 83630ef842dSbmc } else { \ 83730ef842dSbmc (void) printf("<NULL>\n"); \ 83830ef842dSbmc } 83930ef842dSbmc 84030ef842dSbmc #define BUFDUMPASSTR(ptr, field, str) \ 84130ef842dSbmc (void) printf("%s: %20s => %s\n", g_pname, #field, str); 84230ef842dSbmc 84330ef842dSbmc #define BUFDUMP(ptr, field) \ 84430ef842dSbmc (void) printf("%s: %20s => %lld\n", g_pname, #field, \ 84530ef842dSbmc (long long)(ptr)->field); 84630ef842dSbmc 84730ef842dSbmc #define BUFDUMPPTR(ptr, field) \ 84830ef842dSbmc (void) printf("%s: %20s => %s\n", g_pname, #field, \ 84930ef842dSbmc (ptr)->field != NULL ? "<non-NULL>" : "<NULL>"); 85030ef842dSbmc 85130ef842dSbmc /*ARGSUSED*/ 85230ef842dSbmc static int 85330ef842dSbmc bufhandler(const dtrace_bufdata_t *bufdata, void *arg) 85430ef842dSbmc { 85530ef842dSbmc const dtrace_aggdata_t *agg = bufdata->dtbda_aggdata; 85630ef842dSbmc const dtrace_recdesc_t *rec = bufdata->dtbda_recdesc; 85730ef842dSbmc const dtrace_probedesc_t *pd; 85830ef842dSbmc uint32_t flags = bufdata->dtbda_flags; 85930ef842dSbmc char buf[512], *c = buf, *end = c + sizeof (buf); 86030ef842dSbmc int i, printed; 86130ef842dSbmc 86230ef842dSbmc struct { 86330ef842dSbmc const char *name; 86430ef842dSbmc uint32_t value; 86530ef842dSbmc } flagnames[] = { 86630ef842dSbmc { "AGGVAL", DTRACE_BUFDATA_AGGVAL }, 86730ef842dSbmc { "AGGKEY", DTRACE_BUFDATA_AGGKEY }, 86830ef842dSbmc { "AGGFORMAT", DTRACE_BUFDATA_AGGFORMAT }, 86930ef842dSbmc { "AGGLAST", DTRACE_BUFDATA_AGGLAST }, 87030ef842dSbmc { "???", UINT32_MAX }, 87130ef842dSbmc { NULL } 87230ef842dSbmc }; 87330ef842dSbmc 87430ef842dSbmc if (bufdata->dtbda_probe != NULL) { 87530ef842dSbmc pd = bufdata->dtbda_probe->dtpda_pdesc; 87630ef842dSbmc } else if (agg != NULL) { 87730ef842dSbmc pd = agg->dtada_pdesc; 87830ef842dSbmc } else { 87930ef842dSbmc pd = NULL; 88030ef842dSbmc } 88130ef842dSbmc 88230ef842dSbmc BUFDUMPHDR(">>> Called buffer handler"); 88330ef842dSbmc BUFDUMPHDR(""); 88430ef842dSbmc 88530ef842dSbmc BUFDUMPHDR(" dtrace_bufdata"); 88630ef842dSbmc BUFDUMPSTR(bufdata, dtbda_buffered); 88730ef842dSbmc BUFDUMPPTR(bufdata, dtbda_probe); 88830ef842dSbmc BUFDUMPPTR(bufdata, dtbda_aggdata); 88930ef842dSbmc BUFDUMPPTR(bufdata, dtbda_recdesc); 89030ef842dSbmc 89130ef842dSbmc (void) snprintf(c, end - c, "0x%x ", bufdata->dtbda_flags); 89230ef842dSbmc c += strlen(c); 89330ef842dSbmc 89430ef842dSbmc for (i = 0, printed = 0; flagnames[i].name != NULL; i++) { 89530ef842dSbmc if (!(flags & flagnames[i].value)) 89630ef842dSbmc continue; 89730ef842dSbmc 89830ef842dSbmc (void) snprintf(c, end - c, 89930ef842dSbmc "%s%s", printed++ ? " | " : "(", flagnames[i].name); 90030ef842dSbmc c += strlen(c); 90130ef842dSbmc flags &= ~flagnames[i].value; 90230ef842dSbmc } 90330ef842dSbmc 90430ef842dSbmc if (printed) 90530ef842dSbmc (void) snprintf(c, end - c, ")"); 90630ef842dSbmc 90730ef842dSbmc BUFDUMPASSTR(bufdata, dtbda_flags, buf); 90830ef842dSbmc BUFDUMPHDR(""); 90930ef842dSbmc 91030ef842dSbmc if (pd != NULL) { 91130ef842dSbmc BUFDUMPHDR(" dtrace_probedesc"); 91230ef842dSbmc BUFDUMPSTR(pd, dtpd_provider); 91330ef842dSbmc BUFDUMPSTR(pd, dtpd_mod); 91430ef842dSbmc BUFDUMPSTR(pd, dtpd_func); 91530ef842dSbmc BUFDUMPSTR(pd, dtpd_name); 91630ef842dSbmc BUFDUMPHDR(""); 91730ef842dSbmc } 91830ef842dSbmc 91930ef842dSbmc if (rec != NULL) { 92030ef842dSbmc BUFDUMPHDR(" dtrace_recdesc"); 92130ef842dSbmc BUFDUMP(rec, dtrd_action); 92230ef842dSbmc BUFDUMP(rec, dtrd_size); 92302198c0bSbmc 92402198c0bSbmc if (agg != NULL) { 92502198c0bSbmc uint8_t *data; 92602198c0bSbmc int lim = rec->dtrd_size; 92702198c0bSbmc 92802198c0bSbmc (void) sprintf(buf, "%d (data: ", rec->dtrd_offset); 92902198c0bSbmc c = buf + strlen(buf); 93002198c0bSbmc 93102198c0bSbmc if (lim > sizeof (uint64_t)) 93202198c0bSbmc lim = sizeof (uint64_t); 93302198c0bSbmc 93402198c0bSbmc data = (uint8_t *)agg->dtada_data + rec->dtrd_offset; 93502198c0bSbmc 93602198c0bSbmc for (i = 0; i < lim; i++) { 93702198c0bSbmc (void) snprintf(c, end - c, "%s%02x", 93802198c0bSbmc i == 0 ? "" : " ", *data++); 93902198c0bSbmc c += strlen(c); 94002198c0bSbmc } 94102198c0bSbmc 94202198c0bSbmc (void) snprintf(c, end - c, 94302198c0bSbmc "%s)", lim < rec->dtrd_size ? " ..." : ""); 94402198c0bSbmc BUFDUMPASSTR(rec, dtrd_offset, buf); 94502198c0bSbmc } else { 94630ef842dSbmc BUFDUMP(rec, dtrd_offset); 94702198c0bSbmc } 94802198c0bSbmc 94930ef842dSbmc BUFDUMPHDR(""); 95030ef842dSbmc } 95130ef842dSbmc 95230ef842dSbmc if (agg != NULL) { 95330ef842dSbmc dtrace_aggdesc_t *desc = agg->dtada_desc; 95430ef842dSbmc 95530ef842dSbmc BUFDUMPHDR(" dtrace_aggdesc"); 95630ef842dSbmc BUFDUMPSTR(desc, dtagd_name); 95730ef842dSbmc BUFDUMP(desc, dtagd_varid); 95830ef842dSbmc BUFDUMP(desc, dtagd_id); 95930ef842dSbmc BUFDUMP(desc, dtagd_nrecs); 96030ef842dSbmc BUFDUMPHDR(""); 96130ef842dSbmc } 96230ef842dSbmc 96330ef842dSbmc return (DTRACE_HANDLE_OK); 96430ef842dSbmc } 96530ef842dSbmc 966a1b5e537Sbmc /*ARGSUSED*/ 967a1b5e537Sbmc static int 9687c478bd9Sstevel@tonic-gate chewrec(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg) 9697c478bd9Sstevel@tonic-gate { 9707c478bd9Sstevel@tonic-gate dtrace_actkind_t act; 9717c478bd9Sstevel@tonic-gate uintptr_t addr; 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate if (rec == NULL) { 9747c478bd9Sstevel@tonic-gate /* 9757c478bd9Sstevel@tonic-gate * We have processed the final record; output the newline if 9767c478bd9Sstevel@tonic-gate * we're not in quiet mode. 9777c478bd9Sstevel@tonic-gate */ 9787c478bd9Sstevel@tonic-gate if (!g_quiet) 9797c478bd9Sstevel@tonic-gate oprintf("\n"); 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 9827c478bd9Sstevel@tonic-gate } 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate act = rec->dtrd_action; 9857c478bd9Sstevel@tonic-gate addr = (uintptr_t)data->dtpda_data; 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate if (act == DTRACEACT_EXIT) { 9887c478bd9Sstevel@tonic-gate g_status = *((uint32_t *)addr); 9897c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate 9927c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9967c478bd9Sstevel@tonic-gate static int 9977c478bd9Sstevel@tonic-gate chew(const dtrace_probedata_t *data, void *arg) 9987c478bd9Sstevel@tonic-gate { 9997c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pd = data->dtpda_pdesc; 10007c478bd9Sstevel@tonic-gate processorid_t cpu = data->dtpda_cpu; 10017c478bd9Sstevel@tonic-gate static int heading; 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate if (g_impatient) { 10047c478bd9Sstevel@tonic-gate g_newline = 0; 10057c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_ABORT); 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate if (heading == 0) { 10097c478bd9Sstevel@tonic-gate if (!g_flowindent) { 10107c478bd9Sstevel@tonic-gate if (!g_quiet) { 10117c478bd9Sstevel@tonic-gate oprintf("%3s %6s %32s\n", 10127c478bd9Sstevel@tonic-gate "CPU", "ID", "FUNCTION:NAME"); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate } else { 10157c478bd9Sstevel@tonic-gate oprintf("%3s %-41s\n", "CPU", "FUNCTION"); 10167c478bd9Sstevel@tonic-gate } 10177c478bd9Sstevel@tonic-gate heading = 1; 10187c478bd9Sstevel@tonic-gate } 10197c478bd9Sstevel@tonic-gate 10207c478bd9Sstevel@tonic-gate if (!g_flowindent) { 10217c478bd9Sstevel@tonic-gate if (!g_quiet) { 10227c478bd9Sstevel@tonic-gate char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2]; 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate (void) snprintf(name, sizeof (name), "%s:%s", 10257c478bd9Sstevel@tonic-gate pd->dtpd_func, pd->dtpd_name); 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate oprintf("%3d %6d %32s ", cpu, pd->dtpd_id, name); 10287c478bd9Sstevel@tonic-gate } 10297c478bd9Sstevel@tonic-gate } else { 10307c478bd9Sstevel@tonic-gate int indent = data->dtpda_indent; 10317c478bd9Sstevel@tonic-gate char *name; 10327c478bd9Sstevel@tonic-gate size_t len; 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate if (data->dtpda_flow == DTRACEFLOW_NONE) { 10357c478bd9Sstevel@tonic-gate len = indent + DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 5; 10367c478bd9Sstevel@tonic-gate name = alloca(len); 10377c478bd9Sstevel@tonic-gate (void) snprintf(name, len, "%*s%s%s:%s", indent, "", 10387c478bd9Sstevel@tonic-gate data->dtpda_prefix, pd->dtpd_func, 10397c478bd9Sstevel@tonic-gate pd->dtpd_name); 10407c478bd9Sstevel@tonic-gate } else { 10417c478bd9Sstevel@tonic-gate len = indent + DTRACE_FUNCNAMELEN + 5; 10427c478bd9Sstevel@tonic-gate name = alloca(len); 10437c478bd9Sstevel@tonic-gate (void) snprintf(name, len, "%*s%s%s", indent, "", 10447c478bd9Sstevel@tonic-gate data->dtpda_prefix, pd->dtpd_func); 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate oprintf("%3d %-41s ", cpu, name); 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 10517c478bd9Sstevel@tonic-gate } 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate static void 10547c478bd9Sstevel@tonic-gate go(void) 10557c478bd9Sstevel@tonic-gate { 10567c478bd9Sstevel@tonic-gate int i; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate struct { 10597c478bd9Sstevel@tonic-gate char *name; 10607c478bd9Sstevel@tonic-gate char *optname; 10617c478bd9Sstevel@tonic-gate dtrace_optval_t val; 10627c478bd9Sstevel@tonic-gate } bufs[] = { 10637c478bd9Sstevel@tonic-gate { "buffer size", "bufsize" }, 10647c478bd9Sstevel@tonic-gate { "aggregation size", "aggsize" }, 10657c478bd9Sstevel@tonic-gate { "speculation size", "specsize" }, 10667c478bd9Sstevel@tonic-gate { "dynamic variable size", "dynvarsize" }, 10677c478bd9Sstevel@tonic-gate { NULL } 10687c478bd9Sstevel@tonic-gate }, rates[] = { 10697c478bd9Sstevel@tonic-gate { "cleaning rate", "cleanrate" }, 10707c478bd9Sstevel@tonic-gate { "status rate", "statusrate" }, 10717c478bd9Sstevel@tonic-gate { NULL } 10727c478bd9Sstevel@tonic-gate }; 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate for (i = 0; bufs[i].name != NULL; i++) { 10757c478bd9Sstevel@tonic-gate if (dtrace_getopt(g_dtp, bufs[i].optname, &bufs[i].val) == -1) 10767c478bd9Sstevel@tonic-gate fatal("couldn't get option %s", bufs[i].optname); 10777c478bd9Sstevel@tonic-gate } 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate for (i = 0; rates[i].name != NULL; i++) { 10807c478bd9Sstevel@tonic-gate if (dtrace_getopt(g_dtp, rates[i].optname, &rates[i].val) == -1) 10817c478bd9Sstevel@tonic-gate fatal("couldn't get option %s", rates[i].optname); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate if (dtrace_go(g_dtp) == -1) 10857c478bd9Sstevel@tonic-gate dfatal("could not enable tracing"); 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate for (i = 0; bufs[i].name != NULL; i++) { 10887c478bd9Sstevel@tonic-gate dtrace_optval_t j = 0, mul = 10; 10897c478bd9Sstevel@tonic-gate dtrace_optval_t nsize; 10907c478bd9Sstevel@tonic-gate 10917c478bd9Sstevel@tonic-gate if (bufs[i].val == DTRACEOPT_UNSET) 10927c478bd9Sstevel@tonic-gate continue; 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, bufs[i].optname, &nsize); 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate if (nsize == DTRACEOPT_UNSET || nsize == 0) 10977c478bd9Sstevel@tonic-gate continue; 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate if (nsize >= bufs[i].val - sizeof (uint64_t)) 11007c478bd9Sstevel@tonic-gate continue; 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate for (; (INT64_C(1) << mul) <= nsize; j++, mul += 10) 11037c478bd9Sstevel@tonic-gate continue; 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate if (!(nsize & ((INT64_C(1) << (mul - 10)) - 1))) { 11067c478bd9Sstevel@tonic-gate error("%s lowered to %lld%c\n", bufs[i].name, 11077c478bd9Sstevel@tonic-gate (long long)nsize >> (mul - 10), " kmgtpe"[j]); 11087c478bd9Sstevel@tonic-gate } else { 11097c478bd9Sstevel@tonic-gate error("%s lowered to %lld bytes\n", bufs[i].name, 11107c478bd9Sstevel@tonic-gate (long long)nsize); 11117c478bd9Sstevel@tonic-gate } 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate for (i = 0; rates[i].name != NULL; i++) { 11157c478bd9Sstevel@tonic-gate dtrace_optval_t nval; 11167c478bd9Sstevel@tonic-gate char *dir; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if (rates[i].val == DTRACEOPT_UNSET) 11197c478bd9Sstevel@tonic-gate continue; 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, rates[i].optname, &nval); 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate if (nval == DTRACEOPT_UNSET || nval == 0) 11247c478bd9Sstevel@tonic-gate continue; 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate if (rates[i].val == nval) 11277c478bd9Sstevel@tonic-gate continue; 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate dir = nval > rates[i].val ? "reduced" : "increased"; 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate if (nval <= NANOSEC && (NANOSEC % nval) == 0) { 11327c478bd9Sstevel@tonic-gate error("%s %s to %lld hz\n", rates[i].name, dir, 11337c478bd9Sstevel@tonic-gate (long long)NANOSEC / (long long)nval); 11347c478bd9Sstevel@tonic-gate continue; 11357c478bd9Sstevel@tonic-gate } 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate if ((nval % NANOSEC) == 0) { 11387c478bd9Sstevel@tonic-gate error("%s %s to once every %lld seconds\n", 11397c478bd9Sstevel@tonic-gate rates[i].name, dir, 11407c478bd9Sstevel@tonic-gate (long long)nval / (long long)NANOSEC); 11417c478bd9Sstevel@tonic-gate continue; 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate error("%s %s to once every %lld nanoseconds\n", 11457c478bd9Sstevel@tonic-gate rates[i].name, dir, (long long)nval); 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11507c478bd9Sstevel@tonic-gate static void 11517c478bd9Sstevel@tonic-gate intr(int signo) 11527c478bd9Sstevel@tonic-gate { 11537c478bd9Sstevel@tonic-gate if (!g_intr) 11547c478bd9Sstevel@tonic-gate g_newline = 1; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate if (g_intr++) 11577c478bd9Sstevel@tonic-gate g_impatient = 1; 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate int 11617c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 11627c478bd9Sstevel@tonic-gate { 11637c478bd9Sstevel@tonic-gate dtrace_bufdesc_t buf; 1164e4586ebfSmws struct sigaction act, oact; 11657c478bd9Sstevel@tonic-gate dtrace_status_t status[2]; 11667c478bd9Sstevel@tonic-gate dtrace_optval_t opt; 11677c478bd9Sstevel@tonic-gate dtrace_cmd_t *dcp; 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate int done = 0, mode = 0; 11707c478bd9Sstevel@tonic-gate int err, i; 11717c478bd9Sstevel@tonic-gate char c, *p, **v; 11727c478bd9Sstevel@tonic-gate struct ps_prochandle *P; 11737c478bd9Sstevel@tonic-gate pid_t pid; 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate g_pname = basename(argv[0]); 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate if (argc == 1) 11787c478bd9Sstevel@tonic-gate return (usage(stderr)); 11797c478bd9Sstevel@tonic-gate 11807c478bd9Sstevel@tonic-gate if ((g_argv = malloc(sizeof (char *) * argc)) == NULL || 11817c478bd9Sstevel@tonic-gate (g_cmdv = malloc(sizeof (dtrace_cmd_t) * argc)) == NULL || 11827c478bd9Sstevel@tonic-gate (g_psv = malloc(sizeof (struct ps_prochandle *) * argc)) == NULL) 11837c478bd9Sstevel@tonic-gate fatal("failed to allocate memory for arguments"); 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate g_argv[g_argc++] = argv[0]; /* propagate argv[0] to D as $0/$$0 */ 11867c478bd9Sstevel@tonic-gate argv[0] = g_pname; /* rewrite argv[0] for getopt errors */ 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate bzero(status, sizeof (status)); 11897c478bd9Sstevel@tonic-gate bzero(&buf, sizeof (buf)); 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate /* 11927c478bd9Sstevel@tonic-gate * Make an initial pass through argv[] processing any arguments that 11937c478bd9Sstevel@tonic-gate * affect our behavior mode (g_mode) and flags used for dtrace_open(). 11947c478bd9Sstevel@tonic-gate * We also accumulate arguments that are not affiliated with getopt 11957c478bd9Sstevel@tonic-gate * options into g_argv[], and abort if any invalid options are found. 11967c478bd9Sstevel@tonic-gate */ 11977c478bd9Sstevel@tonic-gate for (optind = 1; optind < argc; optind++) { 11987c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 11997c478bd9Sstevel@tonic-gate switch (c) { 12007c478bd9Sstevel@tonic-gate case '3': 12017c478bd9Sstevel@tonic-gate if (strcmp(optarg, "2") != 0) { 12027c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12037c478bd9Sstevel@tonic-gate "%s: illegal option -- 3%s\n", 12047c478bd9Sstevel@tonic-gate argv[0], optarg); 12057c478bd9Sstevel@tonic-gate return (usage(stderr)); 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate g_oflags &= ~DTRACE_O_LP64; 12087c478bd9Sstevel@tonic-gate g_oflags |= DTRACE_O_ILP32; 12097c478bd9Sstevel@tonic-gate break; 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate case '6': 12127c478bd9Sstevel@tonic-gate if (strcmp(optarg, "4") != 0) { 12137c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12147c478bd9Sstevel@tonic-gate "%s: illegal option -- 6%s\n", 12157c478bd9Sstevel@tonic-gate argv[0], optarg); 12167c478bd9Sstevel@tonic-gate return (usage(stderr)); 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate g_oflags &= ~DTRACE_O_ILP32; 12197c478bd9Sstevel@tonic-gate g_oflags |= DTRACE_O_LP64; 12207c478bd9Sstevel@tonic-gate break; 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate case 'a': 12237c478bd9Sstevel@tonic-gate g_grabanon++; /* also checked in pass 2 below */ 12247c478bd9Sstevel@tonic-gate break; 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate case 'A': 12277c478bd9Sstevel@tonic-gate g_mode = DMODE_ANON; 12287c478bd9Sstevel@tonic-gate g_exec = 0; 12297c478bd9Sstevel@tonic-gate mode++; 12307c478bd9Sstevel@tonic-gate break; 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate case 'e': 12337c478bd9Sstevel@tonic-gate g_exec = 0; 12347c478bd9Sstevel@tonic-gate done = 1; 12357c478bd9Sstevel@tonic-gate break; 12367c478bd9Sstevel@tonic-gate 1237900524f3Sahl case 'h': 1238900524f3Sahl g_mode = DMODE_HEADER; 1239900524f3Sahl g_oflags |= DTRACE_O_NODEV; 1240900524f3Sahl g_cflags |= DTRACE_C_ZDEFS; /* -h implies -Z */ 1241900524f3Sahl g_exec = 0; 1242900524f3Sahl mode++; 1243900524f3Sahl break; 1244900524f3Sahl 12457c478bd9Sstevel@tonic-gate case 'G': 12467c478bd9Sstevel@tonic-gate g_mode = DMODE_LINK; 12477c478bd9Sstevel@tonic-gate g_oflags |= DTRACE_O_NODEV; 12487c478bd9Sstevel@tonic-gate g_cflags |= DTRACE_C_ZDEFS; /* -G implies -Z */ 12497c478bd9Sstevel@tonic-gate g_exec = 0; 12507c478bd9Sstevel@tonic-gate mode++; 12517c478bd9Sstevel@tonic-gate break; 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate case 'l': 12547c478bd9Sstevel@tonic-gate g_mode = DMODE_LIST; 12557c478bd9Sstevel@tonic-gate g_cflags |= DTRACE_C_ZDEFS; /* -l implies -Z */ 12567c478bd9Sstevel@tonic-gate mode++; 12577c478bd9Sstevel@tonic-gate break; 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate case 'V': 12607c478bd9Sstevel@tonic-gate g_mode = DMODE_VERS; 12617c478bd9Sstevel@tonic-gate mode++; 12627c478bd9Sstevel@tonic-gate break; 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate default: 12657c478bd9Sstevel@tonic-gate if (strchr(DTRACE_OPTSTR, c) == NULL) 12667c478bd9Sstevel@tonic-gate return (usage(stderr)); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate } 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate if (optind < argc) 12717c478bd9Sstevel@tonic-gate g_argv[g_argc++] = argv[optind]; 12727c478bd9Sstevel@tonic-gate } 12737c478bd9Sstevel@tonic-gate 12747c478bd9Sstevel@tonic-gate if (mode > 1) { 1275900524f3Sahl (void) fprintf(stderr, "%s: only one of the [-AGhlV] options " 12767c478bd9Sstevel@tonic-gate "can be specified at a time\n", g_pname); 12777c478bd9Sstevel@tonic-gate return (E_USAGE); 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate if (g_mode == DMODE_VERS) 12817c478bd9Sstevel@tonic-gate return (printf("%s: %s\n", g_pname, _dtrace_version) <= 0); 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate /* 12842b6e762cSahl * If we're in linker mode and the data model hasn't been specified, 12852b6e762cSahl * we try to guess the appropriate setting by examining the object 12862b6e762cSahl * files. We ignore certain errors since we'll catch them later when 12872b6e762cSahl * we actually process the object files. 12882b6e762cSahl */ 12892b6e762cSahl if (g_mode == DMODE_LINK && 12902b6e762cSahl (g_oflags & (DTRACE_O_ILP32 | DTRACE_O_LP64)) == 0 && 12912b6e762cSahl elf_version(EV_CURRENT) != EV_NONE) { 12922b6e762cSahl int fd; 12932b6e762cSahl Elf *elf; 12942b6e762cSahl GElf_Ehdr ehdr; 12952b6e762cSahl 12962b6e762cSahl for (i = 1; i < g_argc; i++) { 12972b6e762cSahl if ((fd = open64(g_argv[i], O_RDONLY)) == -1) 12982b6e762cSahl break; 12992b6e762cSahl 13002b6e762cSahl if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 13012b6e762cSahl (void) close(fd); 13022b6e762cSahl break; 13032b6e762cSahl } 13042b6e762cSahl 13052b6e762cSahl if (elf_kind(elf) != ELF_K_ELF || 13062b6e762cSahl gelf_getehdr(elf, &ehdr) == NULL) { 13072b6e762cSahl (void) close(fd); 13082b6e762cSahl (void) elf_end(elf); 13092b6e762cSahl break; 13102b6e762cSahl } 13112b6e762cSahl 13122b6e762cSahl (void) close(fd); 13132b6e762cSahl (void) elf_end(elf); 13142b6e762cSahl 13152b6e762cSahl if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) { 13162b6e762cSahl if (g_oflags & DTRACE_O_ILP32) { 13172b6e762cSahl fatal("can't mix 32-bit and 64-bit " 13182b6e762cSahl "object files\n"); 13192b6e762cSahl } 13202b6e762cSahl g_oflags |= DTRACE_O_LP64; 13212b6e762cSahl } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) { 13222b6e762cSahl if (g_oflags & DTRACE_O_LP64) { 13232b6e762cSahl fatal("can't mix 32-bit and 64-bit " 13242b6e762cSahl "object files\n"); 13252b6e762cSahl } 13262b6e762cSahl g_oflags |= DTRACE_O_ILP32; 13272b6e762cSahl } else { 13282b6e762cSahl break; 13292b6e762cSahl } 13302b6e762cSahl } 13312b6e762cSahl } 13322b6e762cSahl 13332b6e762cSahl /* 13347c478bd9Sstevel@tonic-gate * Open libdtrace. If we are not actually going to be enabling any 13357c478bd9Sstevel@tonic-gate * instrumentation attempt to reopen libdtrace using DTRACE_O_NODEV. 13367c478bd9Sstevel@tonic-gate */ 13377c478bd9Sstevel@tonic-gate while ((g_dtp = dtrace_open(DTRACE_VERSION, g_oflags, &err)) == NULL) { 13387c478bd9Sstevel@tonic-gate if (!(g_oflags & DTRACE_O_NODEV) && !g_exec && !g_grabanon) { 13397c478bd9Sstevel@tonic-gate g_oflags |= DTRACE_O_NODEV; 13407c478bd9Sstevel@tonic-gate continue; 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate fatal("failed to initialize dtrace: %s\n", 13447c478bd9Sstevel@tonic-gate dtrace_errmsg(NULL, err)); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate (void) dtrace_setopt(g_dtp, "bufsize", "4m"); 13487c478bd9Sstevel@tonic-gate (void) dtrace_setopt(g_dtp, "aggsize", "4m"); 1349e5803b76SAdam H. Leventhal (void) dtrace_setopt(g_dtp, "temporal", "yes"); 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate /* 13527c478bd9Sstevel@tonic-gate * If -G is specified, enable -xlink=dynamic and -xunodefs to permit 13537c478bd9Sstevel@tonic-gate * references to undefined symbols to remain as unresolved relocations. 13547c478bd9Sstevel@tonic-gate * If -A is specified, enable -xlink=primary to permit static linking 13557c478bd9Sstevel@tonic-gate * only to kernel symbols that are defined in a primary kernel module. 13567c478bd9Sstevel@tonic-gate */ 13577c478bd9Sstevel@tonic-gate if (g_mode == DMODE_LINK) { 13587c478bd9Sstevel@tonic-gate (void) dtrace_setopt(g_dtp, "linkmode", "dynamic"); 13597c478bd9Sstevel@tonic-gate (void) dtrace_setopt(g_dtp, "unodefs", NULL); 13607c478bd9Sstevel@tonic-gate 13612b6e762cSahl /* 13622b6e762cSahl * Use the remaining arguments as the list of object files 13632b6e762cSahl * when in linker mode. 13642b6e762cSahl */ 13652b6e762cSahl g_objc = g_argc - 1; 13662b6e762cSahl g_objv = g_argv + 1; 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* 13697c478bd9Sstevel@tonic-gate * We still use g_argv[0], the name of the executable. 13707c478bd9Sstevel@tonic-gate */ 13717c478bd9Sstevel@tonic-gate g_argc = 1; 13727c478bd9Sstevel@tonic-gate } else if (g_mode == DMODE_ANON) 13737c478bd9Sstevel@tonic-gate (void) dtrace_setopt(g_dtp, "linkmode", "primary"); 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate /* 13767c478bd9Sstevel@tonic-gate * Now that we have libdtrace open, make a second pass through argv[] 13777c478bd9Sstevel@tonic-gate * to perform any dtrace_setopt() calls and change any compiler flags. 13787c478bd9Sstevel@tonic-gate * We also accumulate any program specifications into our g_cmdv[] at 13797c478bd9Sstevel@tonic-gate * this time; these will compiled as part of the fourth processing pass. 13807c478bd9Sstevel@tonic-gate */ 13817c478bd9Sstevel@tonic-gate for (optind = 1; optind < argc; optind++) { 13827c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 13837c478bd9Sstevel@tonic-gate switch (c) { 13847c478bd9Sstevel@tonic-gate case 'a': 13857c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "grabanon", 0) != 0) 13867c478bd9Sstevel@tonic-gate dfatal("failed to set -a"); 13877c478bd9Sstevel@tonic-gate break; 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate case 'b': 13907c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, 13917c478bd9Sstevel@tonic-gate "bufsize", optarg) != 0) 13927c478bd9Sstevel@tonic-gate dfatal("failed to set -b %s", optarg); 13937c478bd9Sstevel@tonic-gate break; 13947c478bd9Sstevel@tonic-gate 139530ef842dSbmc case 'B': 139630ef842dSbmc g_ofp = NULL; 139730ef842dSbmc break; 139830ef842dSbmc 13997c478bd9Sstevel@tonic-gate case 'C': 14007c478bd9Sstevel@tonic-gate g_cflags |= DTRACE_C_CPP; 14017c478bd9Sstevel@tonic-gate break; 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate case 'D': 14047c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "define", optarg) != 0) 14057c478bd9Sstevel@tonic-gate dfatal("failed to set -D %s", optarg); 14067c478bd9Sstevel@tonic-gate break; 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate case 'f': 14097c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14107c478bd9Sstevel@tonic-gate dcp->dc_func = compile_str; 14117c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_FUNC; 14127c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14137c478bd9Sstevel@tonic-gate break; 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate case 'F': 14167c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "flowindent", 0) != 0) 14177c478bd9Sstevel@tonic-gate dfatal("failed to set -F"); 14187c478bd9Sstevel@tonic-gate break; 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate case 'H': 14217c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "cpphdrs", 0) != 0) 14227c478bd9Sstevel@tonic-gate dfatal("failed to set -H"); 14237c478bd9Sstevel@tonic-gate break; 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate case 'i': 14267c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14277c478bd9Sstevel@tonic-gate dcp->dc_func = compile_str; 14287c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_NAME; 14297c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14307c478bd9Sstevel@tonic-gate break; 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate case 'I': 14337c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "incdir", optarg) != 0) 14347c478bd9Sstevel@tonic-gate dfatal("failed to set -I %s", optarg); 14357c478bd9Sstevel@tonic-gate break; 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate case 'L': 14387c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "libdir", optarg) != 0) 14397c478bd9Sstevel@tonic-gate dfatal("failed to set -L %s", optarg); 14407c478bd9Sstevel@tonic-gate break; 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate case 'm': 14437c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14447c478bd9Sstevel@tonic-gate dcp->dc_func = compile_str; 14457c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_MOD; 14467c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14477c478bd9Sstevel@tonic-gate break; 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate case 'n': 14507c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14517c478bd9Sstevel@tonic-gate dcp->dc_func = compile_str; 14527c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_NAME; 14537c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14547c478bd9Sstevel@tonic-gate break; 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate case 'P': 14577c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14587c478bd9Sstevel@tonic-gate dcp->dc_func = compile_str; 14597c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_PROVIDER; 14607c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14617c478bd9Sstevel@tonic-gate break; 14627c478bd9Sstevel@tonic-gate 14637c478bd9Sstevel@tonic-gate case 'q': 14647c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "quiet", 0) != 0) 14657c478bd9Sstevel@tonic-gate dfatal("failed to set -q"); 14667c478bd9Sstevel@tonic-gate break; 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate case 'o': 14697c478bd9Sstevel@tonic-gate g_ofile = optarg; 14707c478bd9Sstevel@tonic-gate break; 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate case 's': 14737c478bd9Sstevel@tonic-gate dcp = &g_cmdv[g_cmdc++]; 14747c478bd9Sstevel@tonic-gate dcp->dc_func = compile_file; 14757c478bd9Sstevel@tonic-gate dcp->dc_spec = DTRACE_PROBESPEC_NONE; 14767c478bd9Sstevel@tonic-gate dcp->dc_arg = optarg; 14777c478bd9Sstevel@tonic-gate break; 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate case 'S': 14807c478bd9Sstevel@tonic-gate g_cflags |= DTRACE_C_DIFV; 14817c478bd9Sstevel@tonic-gate break; 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate case 'U': 14847c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "undef", optarg) != 0) 14857c478bd9Sstevel@tonic-gate dfatal("failed to set -U %s", optarg); 14867c478bd9Sstevel@tonic-gate break; 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate case 'v': 14897c478bd9Sstevel@tonic-gate g_verbose++; 14907c478bd9Sstevel@tonic-gate break; 14917c478bd9Sstevel@tonic-gate 14927c478bd9Sstevel@tonic-gate case 'w': 14937c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "destructive", 0) != 0) 14947c478bd9Sstevel@tonic-gate dfatal("failed to set -w"); 14957c478bd9Sstevel@tonic-gate break; 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate case 'x': 14987c478bd9Sstevel@tonic-gate if ((p = strchr(optarg, '=')) != NULL) 14997c478bd9Sstevel@tonic-gate *p++ = '\0'; 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, optarg, p) != 0) 15027c478bd9Sstevel@tonic-gate dfatal("failed to set -x %s", optarg); 15037c478bd9Sstevel@tonic-gate break; 15047c478bd9Sstevel@tonic-gate 15057c478bd9Sstevel@tonic-gate case 'X': 15067c478bd9Sstevel@tonic-gate if (dtrace_setopt(g_dtp, "stdc", optarg) != 0) 15077c478bd9Sstevel@tonic-gate dfatal("failed to set -X %s", optarg); 15087c478bd9Sstevel@tonic-gate break; 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate case 'Z': 15117c478bd9Sstevel@tonic-gate g_cflags |= DTRACE_C_ZDEFS; 15127c478bd9Sstevel@tonic-gate break; 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate default: 15157c478bd9Sstevel@tonic-gate if (strchr(DTRACE_OPTSTR, c) == NULL) 15167c478bd9Sstevel@tonic-gate return (usage(stderr)); 15177c478bd9Sstevel@tonic-gate } 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate } 15207c478bd9Sstevel@tonic-gate 152130ef842dSbmc if (g_ofp == NULL && g_mode != DMODE_EXEC) { 152230ef842dSbmc (void) fprintf(stderr, "%s: -B not valid in combination" 152330ef842dSbmc " with [-AGl] options\n", g_pname); 152430ef842dSbmc return (E_USAGE); 152530ef842dSbmc } 152630ef842dSbmc 152730ef842dSbmc if (g_ofp == NULL && g_ofile != NULL) { 152830ef842dSbmc (void) fprintf(stderr, "%s: -B not valid in combination" 152930ef842dSbmc " with -o option\n", g_pname); 153030ef842dSbmc return (E_USAGE); 153130ef842dSbmc } 153230ef842dSbmc 15337c478bd9Sstevel@tonic-gate /* 15347c478bd9Sstevel@tonic-gate * In our third pass we handle any command-line options related to 15357c478bd9Sstevel@tonic-gate * grabbing or creating victim processes. The behavior of these calls 15367c478bd9Sstevel@tonic-gate * may been affected by any library options set by the second pass. 15377c478bd9Sstevel@tonic-gate */ 15387c478bd9Sstevel@tonic-gate for (optind = 1; optind < argc; optind++) { 15397c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 15407c478bd9Sstevel@tonic-gate switch (c) { 15417c478bd9Sstevel@tonic-gate case 'c': 15427c478bd9Sstevel@tonic-gate if ((v = make_argv(optarg)) == NULL) 15437c478bd9Sstevel@tonic-gate fatal("failed to allocate memory"); 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate P = dtrace_proc_create(g_dtp, v[0], v); 15467c478bd9Sstevel@tonic-gate if (P == NULL) 15477c478bd9Sstevel@tonic-gate dfatal(NULL); /* dtrace_errmsg() only */ 15487c478bd9Sstevel@tonic-gate 15497c478bd9Sstevel@tonic-gate g_psv[g_psc++] = P; 15507c478bd9Sstevel@tonic-gate free(v); 15517c478bd9Sstevel@tonic-gate break; 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate case 'p': 15547c478bd9Sstevel@tonic-gate errno = 0; 15557c478bd9Sstevel@tonic-gate pid = strtol(optarg, &p, 10); 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate if (errno != 0 || p == optarg || p[0] != '\0') 15587c478bd9Sstevel@tonic-gate fatal("invalid pid: %s\n", optarg); 15597c478bd9Sstevel@tonic-gate 15607c478bd9Sstevel@tonic-gate P = dtrace_proc_grab(g_dtp, pid, 0); 15617c478bd9Sstevel@tonic-gate if (P == NULL) 15627c478bd9Sstevel@tonic-gate dfatal(NULL); /* dtrace_errmsg() only */ 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate g_psv[g_psc++] = P; 15657c478bd9Sstevel@tonic-gate break; 15667c478bd9Sstevel@tonic-gate } 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate 15707c478bd9Sstevel@tonic-gate /* 15717c478bd9Sstevel@tonic-gate * In our fourth pass we finish g_cmdv[] by calling dc_func to convert 15727c478bd9Sstevel@tonic-gate * each string or file specification into a compiled program structure. 15737c478bd9Sstevel@tonic-gate */ 15747c478bd9Sstevel@tonic-gate for (i = 0; i < g_cmdc; i++) 15757c478bd9Sstevel@tonic-gate g_cmdv[i].dc_func(&g_cmdv[i]); 15767c478bd9Sstevel@tonic-gate 15777c478bd9Sstevel@tonic-gate if (g_mode != DMODE_LIST) { 15787c478bd9Sstevel@tonic-gate if (dtrace_handle_err(g_dtp, &errhandler, NULL) == -1) 15797c478bd9Sstevel@tonic-gate dfatal("failed to establish error handler"); 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate if (dtrace_handle_drop(g_dtp, &drophandler, NULL) == -1) 15827c478bd9Sstevel@tonic-gate dfatal("failed to establish drop handler"); 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate if (dtrace_handle_proc(g_dtp, &prochandler, NULL) == -1) 15857c478bd9Sstevel@tonic-gate dfatal("failed to establish proc handler"); 1586a1b5e537Sbmc 1587a1b5e537Sbmc if (dtrace_handle_setopt(g_dtp, &setopthandler, NULL) == -1) 1588a1b5e537Sbmc dfatal("failed to establish setopt handler"); 158930ef842dSbmc 159030ef842dSbmc if (g_ofp == NULL && 159130ef842dSbmc dtrace_handle_buffered(g_dtp, &bufhandler, NULL) == -1) 159230ef842dSbmc dfatal("failed to establish buffered handler"); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "flowindent", &opt); 15967c478bd9Sstevel@tonic-gate g_flowindent = opt != DTRACEOPT_UNSET; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "grabanon", &opt); 15997c478bd9Sstevel@tonic-gate g_grabanon = opt != DTRACEOPT_UNSET; 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "quiet", &opt); 16027c478bd9Sstevel@tonic-gate g_quiet = opt != DTRACEOPT_UNSET; 16037c478bd9Sstevel@tonic-gate 16047c478bd9Sstevel@tonic-gate /* 16057c478bd9Sstevel@tonic-gate * Now make a fifth and final pass over the options that have been 16067c478bd9Sstevel@tonic-gate * turned into programs and saved in g_cmdv[], performing any mode- 16077c478bd9Sstevel@tonic-gate * specific processing. If g_mode is DMODE_EXEC, we will break out 16087c478bd9Sstevel@tonic-gate * of the switch() and continue on to the data processing loop. For 16097c478bd9Sstevel@tonic-gate * other modes, we will exit dtrace once mode-specific work is done. 16107c478bd9Sstevel@tonic-gate */ 16117c478bd9Sstevel@tonic-gate switch (g_mode) { 16127c478bd9Sstevel@tonic-gate case DMODE_EXEC: 16137c478bd9Sstevel@tonic-gate if (g_ofile != NULL && (g_ofp = fopen(g_ofile, "a")) == NULL) 16147c478bd9Sstevel@tonic-gate fatal("failed to open output file '%s'", g_ofile); 16157c478bd9Sstevel@tonic-gate 16167c478bd9Sstevel@tonic-gate for (i = 0; i < g_cmdc; i++) 16177c478bd9Sstevel@tonic-gate exec_prog(&g_cmdv[i]); 16187c478bd9Sstevel@tonic-gate 16191a7c1b72Smws if (done && !g_grabanon) { 16201a7c1b72Smws dtrace_close(g_dtp); 16217c478bd9Sstevel@tonic-gate return (g_status); 16221a7c1b72Smws } 16237c478bd9Sstevel@tonic-gate break; 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate case DMODE_ANON: 16267c478bd9Sstevel@tonic-gate if (g_ofile == NULL) 16277c478bd9Sstevel@tonic-gate g_ofile = "/kernel/drv/dtrace.conf"; 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate dof_prune(g_ofile); /* strip out any old DOF directives */ 16307c478bd9Sstevel@tonic-gate etcsystem_prune(); /* string out any forceload directives */ 16317c478bd9Sstevel@tonic-gate 16321a7c1b72Smws if (g_cmdc == 0) { 16331a7c1b72Smws dtrace_close(g_dtp); 16347c478bd9Sstevel@tonic-gate return (g_status); 16351a7c1b72Smws } 16367c478bd9Sstevel@tonic-gate 16377c478bd9Sstevel@tonic-gate if ((g_ofp = fopen(g_ofile, "a")) == NULL) 16387c478bd9Sstevel@tonic-gate fatal("failed to open output file '%s'", g_ofile); 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate for (i = 0; i < g_cmdc; i++) { 16417c478bd9Sstevel@tonic-gate anon_prog(&g_cmdv[i], 16427c478bd9Sstevel@tonic-gate dtrace_dof_create(g_dtp, g_cmdv[i].dc_prog, 0), i); 16437c478bd9Sstevel@tonic-gate } 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate /* 16467c478bd9Sstevel@tonic-gate * Dump out the DOF corresponding to the error handler and the 16477c478bd9Sstevel@tonic-gate * current options as the final DOF property in the .conf file. 16487c478bd9Sstevel@tonic-gate */ 16497c478bd9Sstevel@tonic-gate anon_prog(NULL, dtrace_geterr_dof(g_dtp), i++); 16507c478bd9Sstevel@tonic-gate anon_prog(NULL, dtrace_getopt_dof(g_dtp), i++); 16517c478bd9Sstevel@tonic-gate 16527c478bd9Sstevel@tonic-gate if (fclose(g_ofp) == EOF) 16537c478bd9Sstevel@tonic-gate fatal("failed to close output file '%s'", g_ofile); 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate /* 16567c478bd9Sstevel@tonic-gate * These messages would use notice() rather than error(), but 16577c478bd9Sstevel@tonic-gate * we don't want them suppressed when -A is run on a D program 16587c478bd9Sstevel@tonic-gate * that itself contains a #pragma D option quiet. 16597c478bd9Sstevel@tonic-gate */ 16607c478bd9Sstevel@tonic-gate error("saved anonymous enabling in %s\n", g_ofile); 16617c478bd9Sstevel@tonic-gate etcsystem_add(); 16627c478bd9Sstevel@tonic-gate error("run update_drv(1M) or reboot to enable changes\n"); 16637c478bd9Sstevel@tonic-gate 16641a7c1b72Smws dtrace_close(g_dtp); 16657c478bd9Sstevel@tonic-gate return (g_status); 16667c478bd9Sstevel@tonic-gate 16677c478bd9Sstevel@tonic-gate case DMODE_LINK: 1668e4586ebfSmws if (g_cmdc == 0) { 1669e4586ebfSmws (void) fprintf(stderr, "%s: -G requires one or more " 1670e4586ebfSmws "scripts or enabling options\n", g_pname); 1671e4586ebfSmws dtrace_close(g_dtp); 1672e4586ebfSmws return (E_USAGE); 1673e4586ebfSmws } 1674e4586ebfSmws 16757c478bd9Sstevel@tonic-gate for (i = 0; i < g_cmdc; i++) 16767c478bd9Sstevel@tonic-gate link_prog(&g_cmdv[i]); 16770b38a8bdSahl 16780b38a8bdSahl if (g_cmdc > 1 && g_ofile != NULL) { 16790b38a8bdSahl char **objv = alloca(g_cmdc * sizeof (char *)); 16800b38a8bdSahl 16810b38a8bdSahl for (i = 0; i < g_cmdc; i++) 16820b38a8bdSahl objv[i] = g_cmdv[i].dc_ofile; 16830b38a8bdSahl 16840b38a8bdSahl if (dtrace_program_link(g_dtp, NULL, DTRACE_D_PROBES, 16850b38a8bdSahl g_ofile, g_cmdc, objv) != 0) 16861a7c1b72Smws dfatal(NULL); /* dtrace_errmsg() only */ 16870b38a8bdSahl } 16880b38a8bdSahl 16891a7c1b72Smws dtrace_close(g_dtp); 16907c478bd9Sstevel@tonic-gate return (g_status); 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate case DMODE_LIST: 16937c478bd9Sstevel@tonic-gate if (g_ofile != NULL && (g_ofp = fopen(g_ofile, "a")) == NULL) 16947c478bd9Sstevel@tonic-gate fatal("failed to open output file '%s'", g_ofile); 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate oprintf("%5s %10s %17s %33s %s\n", 16977c478bd9Sstevel@tonic-gate "ID", "PROVIDER", "MODULE", "FUNCTION", "NAME"); 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate for (i = 0; i < g_cmdc; i++) 17007c478bd9Sstevel@tonic-gate list_prog(&g_cmdv[i]); 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate if (g_cmdc == 0) 17037c478bd9Sstevel@tonic-gate (void) dtrace_probe_iter(g_dtp, NULL, list_probe, NULL); 17047c478bd9Sstevel@tonic-gate 17051a7c1b72Smws dtrace_close(g_dtp); 17067c478bd9Sstevel@tonic-gate return (g_status); 1707900524f3Sahl 1708900524f3Sahl case DMODE_HEADER: 1709900524f3Sahl if (g_cmdc == 0) { 1710900524f3Sahl (void) fprintf(stderr, "%s: -h requires one or more " 1711900524f3Sahl "scripts or enabling options\n", g_pname); 1712900524f3Sahl dtrace_close(g_dtp); 1713900524f3Sahl return (E_USAGE); 1714900524f3Sahl } 1715900524f3Sahl 1716900524f3Sahl if (g_ofile == NULL) { 1717900524f3Sahl char *p; 1718900524f3Sahl 1719900524f3Sahl if (g_cmdc > 1) { 1720900524f3Sahl (void) fprintf(stderr, "%s: -h requires an " 1721900524f3Sahl "output file if multiple scripts are " 1722900524f3Sahl "specified\n", g_pname); 1723900524f3Sahl dtrace_close(g_dtp); 1724900524f3Sahl return (E_USAGE); 1725900524f3Sahl } 1726900524f3Sahl 1727900524f3Sahl if ((p = strrchr(g_cmdv[0].dc_arg, '.')) == NULL || 1728900524f3Sahl strcmp(p, ".d") != 0) { 1729900524f3Sahl (void) fprintf(stderr, "%s: -h requires an " 1730900524f3Sahl "output file if no scripts are " 1731900524f3Sahl "specified\n", g_pname); 1732900524f3Sahl dtrace_close(g_dtp); 1733900524f3Sahl return (E_USAGE); 1734900524f3Sahl } 1735900524f3Sahl 1736900524f3Sahl p[0] = '\0'; /* strip .d suffix */ 1737900524f3Sahl g_ofile = p = g_cmdv[0].dc_ofile; 1738900524f3Sahl (void) snprintf(p, sizeof (g_cmdv[0].dc_ofile), 1739900524f3Sahl "%s.h", basename(g_cmdv[0].dc_arg)); 1740900524f3Sahl } 1741900524f3Sahl 1742900524f3Sahl if ((g_ofp = fopen(g_ofile, "w")) == NULL) 1743900524f3Sahl fatal("failed to open header file '%s'", g_ofile); 1744900524f3Sahl 1745900524f3Sahl oprintf("/*\n * Generated by dtrace(1M).\n */\n\n"); 1746900524f3Sahl 1747900524f3Sahl if (dtrace_program_header(g_dtp, g_ofp, g_ofile) != 0 || 1748900524f3Sahl fclose(g_ofp) == EOF) 1749900524f3Sahl dfatal("failed to create header file %s", g_ofile); 1750900524f3Sahl 1751900524f3Sahl dtrace_close(g_dtp); 1752900524f3Sahl return (g_status); 17537c478bd9Sstevel@tonic-gate } 17547c478bd9Sstevel@tonic-gate 17557c478bd9Sstevel@tonic-gate /* 17567c478bd9Sstevel@tonic-gate * If -a and -Z were not specified and no probes have been matched, no 17577c478bd9Sstevel@tonic-gate * probe criteria was specified on the command line and we abort. 17587c478bd9Sstevel@tonic-gate */ 17597c478bd9Sstevel@tonic-gate if (g_total == 0 && !g_grabanon && !(g_cflags & DTRACE_C_ZDEFS)) 17607c478bd9Sstevel@tonic-gate dfatal("no probes %s\n", g_cmdc ? "matched" : "specified"); 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate /* 17637c478bd9Sstevel@tonic-gate * Start tracing. Once we dtrace_go(), reload any options that affect 17647c478bd9Sstevel@tonic-gate * our globals in case consuming anonymous state has changed them. 17657c478bd9Sstevel@tonic-gate */ 17667c478bd9Sstevel@tonic-gate go(); 17677c478bd9Sstevel@tonic-gate 17687c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "flowindent", &opt); 17697c478bd9Sstevel@tonic-gate g_flowindent = opt != DTRACEOPT_UNSET; 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "grabanon", &opt); 17727c478bd9Sstevel@tonic-gate g_grabanon = opt != DTRACEOPT_UNSET; 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "quiet", &opt); 17757c478bd9Sstevel@tonic-gate g_quiet = opt != DTRACEOPT_UNSET; 17767c478bd9Sstevel@tonic-gate 17777c478bd9Sstevel@tonic-gate (void) dtrace_getopt(g_dtp, "destructive", &opt); 17787c478bd9Sstevel@tonic-gate if (opt != DTRACEOPT_UNSET) 17797c478bd9Sstevel@tonic-gate notice("allowing destructive actions\n"); 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate (void) sigemptyset(&act.sa_mask); 17827c478bd9Sstevel@tonic-gate act.sa_flags = 0; 17837c478bd9Sstevel@tonic-gate act.sa_handler = intr; 1784e4586ebfSmws 1785e4586ebfSmws if (sigaction(SIGINT, NULL, &oact) == 0 && oact.sa_handler != SIG_IGN) 17867c478bd9Sstevel@tonic-gate (void) sigaction(SIGINT, &act, NULL); 1787e4586ebfSmws 1788e4586ebfSmws if (sigaction(SIGTERM, NULL, &oact) == 0 && oact.sa_handler != SIG_IGN) 17897c478bd9Sstevel@tonic-gate (void) sigaction(SIGTERM, &act, NULL); 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate /* 17927c478bd9Sstevel@tonic-gate * Now that tracing is active and we are ready to consume trace data, 17937c478bd9Sstevel@tonic-gate * continue any grabbed or created processes, setting them running 17947c478bd9Sstevel@tonic-gate * using the /proc control mechanism inside of libdtrace. 17957c478bd9Sstevel@tonic-gate */ 17967c478bd9Sstevel@tonic-gate for (i = 0; i < g_psc; i++) 17977c478bd9Sstevel@tonic-gate dtrace_proc_continue(g_dtp, g_psv[i]); 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate g_pslive = g_psc; /* count for prochandler() */ 18007c478bd9Sstevel@tonic-gate 18017c478bd9Sstevel@tonic-gate do { 18027c478bd9Sstevel@tonic-gate if (!g_intr && !done) 18037c478bd9Sstevel@tonic-gate dtrace_sleep(g_dtp); 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate if (g_newline) { 18067c478bd9Sstevel@tonic-gate /* 18077c478bd9Sstevel@tonic-gate * Output a newline just to make the output look 18087c478bd9Sstevel@tonic-gate * slightly cleaner. Note that we do this even in 18097c478bd9Sstevel@tonic-gate * "quiet" mode... 18107c478bd9Sstevel@tonic-gate */ 18117c478bd9Sstevel@tonic-gate oprintf("\n"); 18127c478bd9Sstevel@tonic-gate g_newline = 0; 18137c478bd9Sstevel@tonic-gate } 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate if (done || g_intr || (g_psc != 0 && g_pslive == 0)) { 18167c478bd9Sstevel@tonic-gate done = 1; 18177c478bd9Sstevel@tonic-gate if (dtrace_stop(g_dtp) == -1) 18187c478bd9Sstevel@tonic-gate dfatal("couldn't stop tracing"); 18197c478bd9Sstevel@tonic-gate } 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate switch (dtrace_work(g_dtp, g_ofp, chew, chewrec, NULL)) { 18227c478bd9Sstevel@tonic-gate case DTRACE_WORKSTATUS_DONE: 18237c478bd9Sstevel@tonic-gate done = 1; 18247c478bd9Sstevel@tonic-gate break; 18257c478bd9Sstevel@tonic-gate case DTRACE_WORKSTATUS_OKAY: 18267c478bd9Sstevel@tonic-gate break; 18277c478bd9Sstevel@tonic-gate default: 18287c478bd9Sstevel@tonic-gate if (!g_impatient && dtrace_errno(g_dtp) != EINTR) 18297c478bd9Sstevel@tonic-gate dfatal("processing aborted"); 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate 183230ef842dSbmc if (g_ofp != NULL && fflush(g_ofp) == EOF) 18337c478bd9Sstevel@tonic-gate clearerr(g_ofp); 18347c478bd9Sstevel@tonic-gate } while (!done); 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate oprintf("\n"); 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate if (!g_impatient) { 18397c478bd9Sstevel@tonic-gate if (dtrace_aggregate_print(g_dtp, g_ofp, NULL) == -1 && 18407c478bd9Sstevel@tonic-gate dtrace_errno(g_dtp) != EINTR) 18417c478bd9Sstevel@tonic-gate dfatal("failed to print aggregations"); 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate dtrace_close(g_dtp); 18457c478bd9Sstevel@tonic-gate return (g_status); 18467c478bd9Sstevel@tonic-gate } 1847