1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 2769 ahl * Common Development and Distribution License (the "License"). 6 2769 ahl * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 1222 mws 22 0 stevel /* 23 1222 mws * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24 0 stevel * Use is subject to license terms. 25 0 stevel */ 26 0 stevel 27 0 stevel #pragma ident "%Z%%M% %I% %E% SMI" 28 0 stevel 29 0 stevel #include <sys/types.h> 30 0 stevel #include <sys/stat.h> 31 0 stevel #include <sys/wait.h> 32 0 stevel 33 0 stevel #include <dtrace.h> 34 0 stevel #include <stdlib.h> 35 0 stevel #include <stdarg.h> 36 0 stevel #include <stdio.h> 37 0 stevel #include <strings.h> 38 0 stevel #include <unistd.h> 39 0 stevel #include <limits.h> 40 0 stevel #include <fcntl.h> 41 0 stevel #include <errno.h> 42 0 stevel #include <signal.h> 43 0 stevel #include <alloca.h> 44 0 stevel #include <libgen.h> 45 0 stevel #include <libproc.h> 46 0 stevel 47 0 stevel typedef struct dtrace_cmd { 48 0 stevel void (*dc_func)(struct dtrace_cmd *); /* function to compile arg */ 49 0 stevel dtrace_probespec_t dc_spec; /* probe specifier context */ 50 0 stevel char *dc_arg; /* argument from main argv */ 51 0 stevel const char *dc_name; /* name for error messages */ 52 0 stevel const char *dc_desc; /* desc for error messages */ 53 0 stevel dtrace_prog_t *dc_prog; /* program compiled from arg */ 54 191 ahl char dc_ofile[PATH_MAX]; /* derived output file name */ 55 0 stevel } dtrace_cmd_t; 56 0 stevel 57 0 stevel #define DMODE_VERS 0 /* display version information and exit (-V) */ 58 0 stevel #define DMODE_EXEC 1 /* compile program for enabling (-a/e/E) */ 59 0 stevel #define DMODE_ANON 2 /* compile program for anonymous tracing (-A) */ 60 0 stevel #define DMODE_LINK 3 /* compile program for linking with ELF (-G) */ 61 0 stevel #define DMODE_LIST 4 /* compile program and list probes (-l) */ 62 1399 ahl #define DMODE_HEADER 5 /* compile program for headergen (-h) */ 63 0 stevel 64 0 stevel #define E_SUCCESS 0 65 0 stevel #define E_ERROR 1 66 0 stevel #define E_USAGE 2 67 0 stevel 68 0 stevel static const char DTRACE_OPTSTR[] = 69 1399 ahl "3:6:aAb:Bc:CD:ef:FGhHi:I:lL:m:n:o:p:P:qs:SU:vVwx:X:Z"; 70 0 stevel 71 0 stevel static char **g_argv; 72 0 stevel static int g_argc; 73 0 stevel static char **g_objv; 74 0 stevel static int g_objc; 75 0 stevel static dtrace_cmd_t *g_cmdv; 76 0 stevel static int g_cmdc; 77 0 stevel static struct ps_prochandle **g_psv; 78 0 stevel static int g_psc; 79 0 stevel static int g_pslive; 80 0 stevel static char *g_pname; 81 0 stevel static int g_quiet; 82 0 stevel static int g_flowindent; 83 0 stevel static int g_intr; 84 0 stevel static int g_impatient; 85 0 stevel static int g_newline; 86 0 stevel static int g_total; 87 0 stevel static int g_cflags; 88 0 stevel static int g_oflags; 89 0 stevel static int g_verbose; 90 0 stevel static int g_exec = 1; 91 0 stevel static int g_mode = DMODE_EXEC; 92 0 stevel static int g_status = E_SUCCESS; 93 0 stevel static int g_grabanon = 0; 94 0 stevel static const char *g_ofile = NULL; 95 0 stevel static FILE *g_ofp = stdout; 96 0 stevel static dtrace_hdl_t *g_dtp; 97 0 stevel static char *g_etcfile = "/etc/system"; 98 0 stevel static const char *g_etcbegin = "* vvvv Added by DTrace"; 99 0 stevel static const char *g_etcend = "* ^^^^ Added by DTrace"; 100 0 stevel 101 0 stevel static const char *g_etc[] = { 102 0 stevel "*", 103 0 stevel "* The following forceload directives were added by dtrace(1M) to allow for", 104 0 stevel "* tracing during boot. If these directives are removed, the system will", 105 0 stevel "* continue to function, but tracing will not occur during boot as desired.", 106 0 stevel "* To remove these directives (and this block comment) automatically, run", 107 0 stevel "* \"dtrace -A\" without additional arguments. See the \"Anonymous Tracing\"", 108 0 stevel "* chapter of the Solaris Dynamic Tracing Guide for details.", 109 0 stevel "*", 110 0 stevel NULL }; 111 0 stevel 112 0 stevel static int 113 0 stevel usage(FILE *fp) 114 0 stevel { 115 0 stevel static const char predact[] = "[[ predicate ] action ]"; 116 0 stevel 117 1399 ahl (void) fprintf(fp, "Usage: %s [-32|-64] [-aACeFGhHlqSvVwZ] " 118 0 stevel "[-b bufsz] [-c cmd] [-D name[=def]]\n\t[-I path] [-L path] " 119 0 stevel "[-o output] [-p pid] [-s script] [-U name]\n\t" 120 0 stevel "[-x opt[=val]] [-X a|c|s|t]\n\n" 121 0 stevel "\t[-P provider %s]\n" 122 0 stevel "\t[-m [ provider: ] module %s]\n" 123 0 stevel "\t[-f [[ provider: ] module: ] func %s]\n" 124 0 stevel "\t[-n [[[ provider: ] module: ] func: ] name %s]\n" 125 0 stevel "\t[-i probe-id %s] [ args ... ]\n\n", g_pname, 126 0 stevel predact, predact, predact, predact, predact); 127 0 stevel 128 0 stevel (void) fprintf(fp, "\tpredicate -> '/' D-expression '/'\n"); 129 0 stevel (void) fprintf(fp, "\t action -> '{' D-statements '}'\n"); 130 0 stevel 131 0 stevel (void) fprintf(fp, "\n" 132 0 stevel "\t-32 generate 32-bit D programs and ELF files\n" 133 0 stevel "\t-64 generate 64-bit D programs and ELF files\n\n" 134 0 stevel "\t-a claim anonymous tracing state\n" 135 0 stevel "\t-A generate driver.conf(4) directives for anonymous tracing\n" 136 0 stevel "\t-b set trace buffer size\n" 137 0 stevel "\t-c run specified command and exit upon its completion\n" 138 0 stevel "\t-C run cpp(1) preprocessor on script files\n" 139 0 stevel "\t-D define symbol when invoking preprocessor\n" 140 0 stevel "\t-e exit after compiling request but prior to enabling probes\n" 141 0 stevel "\t-f enable or list probes matching the specified function name\n" 142 0 stevel "\t-F coalesce trace output by function\n" 143 0 stevel "\t-G generate an ELF file containing embedded dtrace program\n" 144 1399 ahl "\t-h generate a header file with definitions for static probes\n" 145 0 stevel "\t-H print included files when invoking preprocessor\n" 146 0 stevel "\t-i enable or list probes matching the specified probe id\n" 147 0 stevel "\t-I add include directory to preprocessor search path\n" 148 0 stevel "\t-l list probes matching specified criteria\n" 149 0 stevel "\t-L add library directory to library search path\n" 150 0 stevel "\t-m enable or list probes matching the specified module name\n" 151 0 stevel "\t-n enable or list probes matching the specified probe name\n" 152 0 stevel "\t-o set output file\n" 153 0 stevel "\t-p grab specified process-ID and cache its symbol tables\n" 154 0 stevel "\t-P enable or list probes matching the specified provider name\n" 155 0 stevel "\t-q set quiet mode (only output explicitly traced data)\n" 156 0 stevel "\t-s enable or list probes according to the specified D script\n" 157 0 stevel "\t-S print D compiler intermediate code\n" 158 0 stevel "\t-U undefine symbol when invoking preprocessor\n" 159 0 stevel "\t-v set verbose mode (report stability attributes, arguments)\n" 160 0 stevel "\t-V report DTrace API version\n" 161 0 stevel "\t-w permit destructive actions\n" 162 0 stevel "\t-x enable or modify compiler and tracing options\n" 163 0 stevel "\t-X specify ISO C conformance settings for preprocessor\n" 164 0 stevel "\t-Z permit probe descriptions that match zero probes\n"); 165 0 stevel 166 0 stevel return (E_USAGE); 167 0 stevel } 168 0 stevel 169 0 stevel static void 170 0 stevel verror(const char *fmt, va_list ap) 171 0 stevel { 172 0 stevel int error = errno; 173 0 stevel 174 0 stevel (void) fprintf(stderr, "%s: ", g_pname); 175 0 stevel (void) vfprintf(stderr, fmt, ap); 176 0 stevel 177 0 stevel if (fmt[strlen(fmt) - 1] != '\n') 178 0 stevel (void) fprintf(stderr, ": %s\n", strerror(error)); 179 0 stevel } 180 0 stevel 181 0 stevel /*PRINTFLIKE1*/ 182 0 stevel static void 183 0 stevel fatal(const char *fmt, ...) 184 0 stevel { 185 0 stevel va_list ap; 186 0 stevel 187 0 stevel va_start(ap, fmt); 188 0 stevel verror(fmt, ap); 189 0 stevel va_end(ap); 190 0 stevel 191 0 stevel exit(E_ERROR); 192 0 stevel } 193 0 stevel 194 0 stevel /*PRINTFLIKE1*/ 195 0 stevel static void 196 0 stevel dfatal(const char *fmt, ...) 197 0 stevel { 198 0 stevel va_list ap; 199 0 stevel 200 0 stevel va_start(ap, fmt); 201 0 stevel 202 0 stevel (void) fprintf(stderr, "%s: ", g_pname); 203 0 stevel if (fmt != NULL) 204 0 stevel (void) vfprintf(stderr, fmt, ap); 205 0 stevel 206 0 stevel va_end(ap); 207 0 stevel 208 0 stevel if (fmt != NULL && fmt[strlen(fmt) - 1] != '\n') { 209 0 stevel (void) fprintf(stderr, ": %s\n", 210 0 stevel dtrace_errmsg(g_dtp, dtrace_errno(g_dtp))); 211 0 stevel } else if (fmt == NULL) { 212 0 stevel (void) fprintf(stderr, "%s\n", 213 0 stevel dtrace_errmsg(g_dtp, dtrace_errno(g_dtp))); 214 0 stevel } 215 2769 ahl 216 2769 ahl /* 217 2769 ahl * Close the DTrace handle to ensure that any controlled processes are 218 2769 ahl * correctly restored and continued. 219 2769 ahl */ 220 2769 ahl dtrace_close(g_dtp); 221 0 stevel 222 0 stevel exit(E_ERROR); 223 0 stevel } 224 0 stevel 225 0 stevel /*PRINTFLIKE1*/ 226 0 stevel static void 227 0 stevel error(const char *fmt, ...) 228 0 stevel { 229 0 stevel va_list ap; 230 0 stevel 231 0 stevel va_start(ap, fmt); 232 0 stevel verror(fmt, ap); 233 0 stevel va_end(ap); 234 0 stevel } 235 0 stevel 236 0 stevel /*PRINTFLIKE1*/ 237 0 stevel static void 238 0 stevel notice(const char *fmt, ...) 239 0 stevel { 240 0 stevel va_list ap; 241 0 stevel 242 0 stevel if (g_quiet) 243 0 stevel return; /* -q or quiet pragma suppresses notice()s */ 244 0 stevel 245 0 stevel va_start(ap, fmt); 246 0 stevel verror(fmt, ap); 247 0 stevel va_end(ap); 248 0 stevel } 249 0 stevel 250 0 stevel /*PRINTFLIKE1*/ 251 0 stevel static void 252 0 stevel oprintf(const char *fmt, ...) 253 0 stevel { 254 0 stevel va_list ap; 255 0 stevel int n; 256 1017 bmc 257 1017 bmc if (g_ofp == NULL) 258 1017 bmc return; 259 0 stevel 260 0 stevel va_start(ap, fmt); 261 0 stevel n = vfprintf(g_ofp, fmt, ap); 262 0 stevel va_end(ap); 263 0 stevel 264 0 stevel if (n < 0) { 265 0 stevel if (errno != EINTR) { 266 0 stevel fatal("failed to write to %s", 267 0 stevel g_ofile ? g_ofile : "<stdout>"); 268 0 stevel } 269 0 stevel clearerr(g_ofp); 270 0 stevel } 271 0 stevel } 272 0 stevel 273 0 stevel static char ** 274 0 stevel make_argv(char *s) 275 0 stevel { 276 0 stevel const char *ws = "\f\n\r\t\v "; 277 0 stevel char **argv = malloc(sizeof (char *) * (strlen(s) / 2 + 1)); 278 0 stevel int argc = 0; 279 0 stevel char *p = s; 280 0 stevel 281 0 stevel if (argv == NULL) 282 0 stevel return (NULL); 283 0 stevel 284 0 stevel for (p = strtok(s, ws); p != NULL; p = strtok(NULL, ws)) 285 0 stevel argv[argc++] = p; 286 0 stevel 287 0 stevel if (argc == 0) 288 0 stevel argv[argc++] = s; 289 0 stevel 290 0 stevel argv[argc] = NULL; 291 0 stevel return (argv); 292 0 stevel } 293 0 stevel 294 0 stevel static void 295 0 stevel dof_prune(const char *fname) 296 0 stevel { 297 0 stevel struct stat sbuf; 298 0 stevel size_t sz, i, j, mark, len; 299 0 stevel char *buf; 300 0 stevel int msg = 0, fd; 301 0 stevel 302 0 stevel if ((fd = open(fname, O_RDONLY)) == -1) { 303 0 stevel /* 304 0 stevel * This is okay only if the file doesn't exist at all. 305 0 stevel */ 306 0 stevel if (errno != ENOENT) 307 0 stevel fatal("failed to open %s", fname); 308 0 stevel return; 309 0 stevel } 310 0 stevel 311 0 stevel if (fstat(fd, &sbuf) == -1) 312 0 stevel fatal("failed to fstat %s", fname); 313 0 stevel 314 0 stevel if ((buf = malloc((sz = sbuf.st_size) + 1)) == NULL) 315 0 stevel fatal("failed to allocate memory for %s", fname); 316 0 stevel 317 0 stevel if (read(fd, buf, sz) != sz) 318 0 stevel fatal("failed to read %s", fname); 319 0 stevel 320 0 stevel buf[sz] = '\0'; 321 0 stevel (void) close(fd); 322 0 stevel 323 0 stevel if ((fd = open(fname, O_WRONLY | O_TRUNC)) == -1) 324 0 stevel fatal("failed to open %s for writing", fname); 325 0 stevel 326 0 stevel len = strlen("dof-data-"); 327 0 stevel 328 0 stevel for (mark = 0, i = 0; i < sz; i++) { 329 0 stevel if (strncmp(&buf[i], "dof-data-", len) != 0) 330 0 stevel continue; 331 0 stevel 332 0 stevel /* 333 0 stevel * This is only a match if it's in the 0th column. 334 0 stevel */ 335 0 stevel if (i != 0 && buf[i - 1] != '\n') 336 0 stevel continue; 337 0 stevel 338 0 stevel if (msg++ == 0) { 339 0 stevel error("cleaned up old anonymous " 340 0 stevel "enabling in %s\n", fname); 341 0 stevel } 342 0 stevel 343 0 stevel /* 344 0 stevel * We have a match. First write out our data up until now. 345 0 stevel */ 346 0 stevel if (i != mark) { 347 0 stevel if (write(fd, &buf[mark], i - mark) != i - mark) 348 0 stevel fatal("failed to write to %s", fname); 349 0 stevel } 350 0 stevel 351 0 stevel /* 352 0 stevel * Now scan forward until we scan past a newline. 353 0 stevel */ 354 0 stevel for (j = i; j < sz && buf[j] != '\n'; j++) 355 0 stevel continue; 356 0 stevel 357 0 stevel /* 358 0 stevel * Reset our mark. 359 0 stevel */ 360 0 stevel if ((mark = j + 1) >= sz) 361 0 stevel break; 362 0 stevel 363 0 stevel i = j; 364 0 stevel } 365 0 stevel 366 0 stevel if (mark < sz) { 367 0 stevel if (write(fd, &buf[mark], sz - mark) != sz - mark) 368 0 stevel fatal("failed to write to %s", fname); 369 0 stevel } 370 0 stevel 371 0 stevel (void) close(fd); 372 0 stevel free(buf); 373 0 stevel } 374 0 stevel 375 0 stevel static void 376 0 stevel etcsystem_prune(void) 377 0 stevel { 378 0 stevel struct stat sbuf; 379 0 stevel size_t sz; 380 0 stevel char *buf, *start, *end; 381 0 stevel int fd; 382 0 stevel char *fname = g_etcfile, *tmpname; 383 0 stevel 384 0 stevel if ((fd = open(fname, O_RDONLY)) == -1) 385 0 stevel fatal("failed to open %s", fname); 386 0 stevel 387 0 stevel if (fstat(fd, &sbuf) == -1) 388 0 stevel fatal("failed to fstat %s", fname); 389 0 stevel 390 0 stevel if ((buf = malloc((sz = sbuf.st_size) + 1)) == NULL) 391 0 stevel fatal("failed to allocate memory for %s", fname); 392 0 stevel 393 0 stevel if (read(fd, buf, sz) != sz) 394 0 stevel fatal("failed to read %s", fname); 395 0 stevel 396 0 stevel buf[sz] = '\0'; 397 0 stevel (void) close(fd); 398 0 stevel 399 0 stevel if ((start = strstr(buf, g_etcbegin)) == NULL) 400 0 stevel goto out; 401 0 stevel 402 0 stevel if (strlen(buf) != sz) { 403 0 stevel fatal("embedded nul byte in %s; manual repair of %s " 404 0 stevel "required\n", fname, fname); 405 0 stevel } 406 0 stevel 407 0 stevel if (strstr(start + 1, g_etcbegin) != NULL) { 408 0 stevel fatal("multiple start sentinels in %s; manual repair of %s " 409 0 stevel "required\n", fname, fname); 410 0 stevel } 411 0 stevel 412 0 stevel if ((end = strstr(buf, g_etcend)) == NULL) { 413 0 stevel fatal("missing end sentinel in %s; manual repair of %s " 414 0 stevel "required\n", fname, fname); 415 0 stevel } 416 0 stevel 417 0 stevel if (start > end) { 418 0 stevel fatal("end sentinel preceeds start sentinel in %s; manual " 419 0 stevel "repair of %s required\n", fname, fname); 420 0 stevel } 421 0 stevel 422 0 stevel end += strlen(g_etcend) + 1; 423 0 stevel bcopy(end, start, strlen(end) + 1); 424 0 stevel 425 0 stevel tmpname = alloca(sz = strlen(fname) + 80); 426 0 stevel (void) snprintf(tmpname, sz, "%s.dtrace.%d", fname, getpid()); 427 0 stevel 428 0 stevel if ((fd = open(tmpname, 429 0 stevel O_WRONLY | O_CREAT | O_EXCL, sbuf.st_mode)) == -1) 430 0 stevel fatal("failed to create %s", tmpname); 431 0 stevel 432 0 stevel if (write(fd, buf, strlen(buf)) < strlen(buf)) { 433 0 stevel (void) unlink(tmpname); 434 0 stevel fatal("failed to write to %s", tmpname); 435 0 stevel } 436 0 stevel 437 0 stevel (void) close(fd); 438 0 stevel 439 0 stevel if (chown(tmpname, sbuf.st_uid, sbuf.st_gid) != 0) { 440 0 stevel (void) unlink(tmpname); 441 0 stevel fatal("failed to chown(2) %s to uid %d, gid %d", tmpname, 442 0 stevel (int)sbuf.st_uid, (int)sbuf.st_gid); 443 0 stevel } 444 0 stevel 445 0 stevel if (rename(tmpname, fname) == -1) 446 0 stevel fatal("rename of %s to %s failed", tmpname, fname); 447 0 stevel 448 0 stevel error("cleaned up forceload directives in %s\n", fname); 449 0 stevel out: 450 0 stevel free(buf); 451 0 stevel } 452 0 stevel 453 0 stevel static void 454 0 stevel etcsystem_add(void) 455 0 stevel { 456 0 stevel const char *mods[20]; 457 0 stevel int nmods, line; 458 0 stevel 459 0 stevel if ((g_ofp = fopen(g_ofile = g_etcfile, "a")) == NULL) 460 0 stevel fatal("failed to open output file '%s'", g_ofile); 461 0 stevel 462 0 stevel oprintf("%s\n", g_etcbegin); 463 0 stevel 464 0 stevel for (line = 0; g_etc[line] != NULL; line++) 465 0 stevel oprintf("%s\n", g_etc[line]); 466 0 stevel 467 0 stevel nmods = dtrace_provider_modules(g_dtp, mods, 468 0 stevel sizeof (mods) / sizeof (char *) - 1); 469 0 stevel 470 0 stevel if (nmods >= sizeof (mods) / sizeof (char *)) 471 0 stevel fatal("unexpectedly large number of modules!"); 472 0 stevel 473 0 stevel mods[nmods++] = "dtrace"; 474 0 stevel 475 0 stevel for (line = 0; line < nmods; line++) 476 0 stevel oprintf("forceload: drv/%s\n", mods[line]); 477 0 stevel 478 0 stevel oprintf("%s\n", g_etcend); 479 0 stevel 480 0 stevel if (fclose(g_ofp) == EOF) 481 0 stevel fatal("failed to close output file '%s'", g_ofile); 482 0 stevel 483 0 stevel error("added forceload directives to %s\n", g_ofile); 484 0 stevel } 485 0 stevel 486 0 stevel static void 487 0 stevel print_probe_info(const dtrace_probeinfo_t *p) 488 0 stevel { 489 0 stevel char buf[BUFSIZ]; 490 0 stevel int i; 491 0 stevel 492 0 stevel oprintf("\n\tProbe Description Attributes\n"); 493 0 stevel 494 0 stevel oprintf("\t\tIdentifier Names: %s\n", 495 0 stevel dtrace_stability_name(p->dtp_attr.dtat_name)); 496 0 stevel oprintf("\t\tData Semantics: %s\n", 497 0 stevel dtrace_stability_name(p->dtp_attr.dtat_data)); 498 0 stevel oprintf("\t\tDependency Class: %s\n", 499 0 stevel dtrace_class_name(p->dtp_attr.dtat_class)); 500 0 stevel 501 0 stevel oprintf("\n\tArgument Attributes\n"); 502 0 stevel 503 0 stevel oprintf("\t\tIdentifier Names: %s\n", 504 0 stevel dtrace_stability_name(p->dtp_arga.dtat_name)); 505 0 stevel oprintf("\t\tData Semantics: %s\n", 506 0 stevel dtrace_stability_name(p->dtp_arga.dtat_data)); 507 0 stevel oprintf("\t\tDependency Class: %s\n", 508 0 stevel dtrace_class_name(p->dtp_arga.dtat_class)); 509 0 stevel 510 0 stevel oprintf("\n\tArgument Types\n"); 511 0 stevel 512 0 stevel for (i = 0; i < p->dtp_argc; i++) { 513 0 stevel if (ctf_type_name(p->dtp_argv[i].dtt_ctfp, 514 0 stevel p->dtp_argv[i].dtt_type, buf, sizeof (buf)) == NULL) 515 0 stevel (void) strlcpy(buf, "(unknown)", sizeof (buf)); 516 0 stevel oprintf("\t\targs[%d]: %s\n", i, buf); 517 0 stevel } 518 0 stevel 519 0 stevel if (p->dtp_argc == 0) 520 0 stevel oprintf("\t\tNone\n"); 521 0 stevel 522 0 stevel oprintf("\n"); 523 0 stevel } 524 0 stevel 525 0 stevel /*ARGSUSED*/ 526 0 stevel static int 527 0 stevel info_stmt(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, 528 0 stevel dtrace_stmtdesc_t *stp, dtrace_ecbdesc_t **last) 529 0 stevel { 530 0 stevel dtrace_ecbdesc_t *edp = stp->dtsd_ecbdesc; 531 0 stevel dtrace_probedesc_t *pdp = &edp->dted_probe; 532 0 stevel dtrace_probeinfo_t p; 533 0 stevel 534 0 stevel if (edp == *last) 535 0 stevel return (0); 536 0 stevel 537 0 stevel oprintf("\n%s:%s:%s:%s\n", 538 0 stevel pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 539 0 stevel 540 0 stevel if (dtrace_probe_info(dtp, pdp, &p) == 0) 541 0 stevel print_probe_info(&p); 542 0 stevel 543 0 stevel *last = edp; 544 0 stevel return (0); 545 0 stevel } 546 0 stevel 547 0 stevel /* 548 0 stevel * Execute the specified program by enabling the corresponding instrumentation. 549 0 stevel * If -e has been specified, we get the program info but do not enable it. If 550 0 stevel * -v has been specified, we print a stability report for the program. 551 0 stevel */ 552 0 stevel static void 553 0 stevel exec_prog(const dtrace_cmd_t *dcp) 554 0 stevel { 555 0 stevel dtrace_ecbdesc_t *last = NULL; 556 0 stevel dtrace_proginfo_t dpi; 557 0 stevel 558 0 stevel if (!g_exec) { 559 0 stevel dtrace_program_info(g_dtp, dcp->dc_prog, &dpi); 560 0 stevel } else if (dtrace_program_exec(g_dtp, dcp->dc_prog, &dpi) == -1) { 561 0 stevel dfatal("failed to enable '%s'", dcp->dc_name); 562 0 stevel } else { 563 0 stevel notice("%s '%s' matched %u probe%s\n", 564 0 stevel dcp->dc_desc, dcp->dc_name, 565 0 stevel dpi.dpi_matches, dpi.dpi_matches == 1 ? "" : "s"); 566 0 stevel } 567 0 stevel 568 0 stevel if (g_verbose) { 569 0 stevel oprintf("\nStability attributes for %s %s:\n", 570 0 stevel dcp->dc_desc, dcp->dc_name); 571 0 stevel 572 0 stevel oprintf("\n\tMinimum Probe Description Attributes\n"); 573 0 stevel oprintf("\t\tIdentifier Names: %s\n", 574 0 stevel dtrace_stability_name(dpi.dpi_descattr.dtat_name)); 575 0 stevel oprintf("\t\tData Semantics: %s\n", 576 0 stevel dtrace_stability_name(dpi.dpi_descattr.dtat_data)); 577 0 stevel oprintf("\t\tDependency Class: %s\n", 578 0 stevel dtrace_class_name(dpi.dpi_descattr.dtat_class)); 579 0 stevel 580 0 stevel oprintf("\n\tMinimum Statement Attributes\n"); 581 0 stevel 582 0 stevel oprintf("\t\tIdentifier Names: %s\n", 583 0 stevel dtrace_stability_name(dpi.dpi_stmtattr.dtat_name)); 584 0 stevel oprintf("\t\tData Semantics: %s\n", 585 0 stevel dtrace_stability_name(dpi.dpi_stmtattr.dtat_data)); 586 0 stevel oprintf("\t\tDependency Class: %s\n", 587 0 stevel dtrace_class_name(dpi.dpi_stmtattr.dtat_class)); 588 0 stevel 589 0 stevel if (!g_exec) { 590 0 stevel (void) dtrace_stmt_iter(g_dtp, dcp->dc_prog, 591 0 stevel (dtrace_stmt_f *)info_stmt, &last); 592 0 stevel } else 593 0 stevel oprintf("\n"); 594 0 stevel } 595 0 stevel 596 0 stevel g_total += dpi.dpi_matches; 597 0 stevel } 598 0 stevel 599 0 stevel /* 600 0 stevel * Print out the specified DOF buffer as a set of ASCII bytes appropriate for 601 0 stevel * storing in a driver.conf(4) file associated with the dtrace driver. 602 0 stevel */ 603 0 stevel static void 604 0 stevel anon_prog(const dtrace_cmd_t *dcp, dof_hdr_t *dof, int n) 605 0 stevel { 606 0 stevel const uchar_t *p, *q; 607 0 stevel 608 0 stevel if (dof == NULL) 609 0 stevel dfatal("failed to create DOF image for '%s'", dcp->dc_name); 610 0 stevel 611 0 stevel p = (uchar_t *)dof; 612 0 stevel q = p + dof->dofh_loadsz; 613 0 stevel 614 0 stevel oprintf("dof-data-%d=0x%x", n, *p++); 615 0 stevel 616 0 stevel while (p < q) 617 0 stevel oprintf(",0x%x", *p++); 618 0 stevel 619 0 stevel oprintf(";\n"); 620 0 stevel dtrace_dof_destroy(g_dtp, dof); 621 0 stevel } 622 0 stevel 623 0 stevel /* 624 0 stevel * Link the specified D program in DOF form into an ELF file for use in either 625 0 stevel * helpers, userland provider definitions, or both. If -o was specified, that 626 0 stevel * path is used as the output file name. If -o wasn't specified and the input 627 0 stevel * program is from a script whose name is %.d, use basename(%.o) as the output 628 0 stevel * file name. Otherwise we use "d.out" as the default output file name. 629 0 stevel */ 630 0 stevel static void 631 191 ahl link_prog(dtrace_cmd_t *dcp) 632 0 stevel { 633 191 ahl char *p; 634 0 stevel 635 191 ahl if (g_cmdc == 1 && g_ofile != NULL) { 636 191 ahl (void) strlcpy(dcp->dc_ofile, g_ofile, sizeof (dcp->dc_ofile)); 637 0 stevel } else if ((p = strrchr(dcp->dc_arg, '.')) != NULL && 638 0 stevel strcmp(p, ".d") == 0) { 639 0 stevel p[0] = '\0'; /* strip .d suffix */ 640 191 ahl (void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile), 641 0 stevel "%s.o", basename(dcp->dc_arg)); 642 0 stevel } else { 643 191 ahl (void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile), 644 191 ahl g_cmdc > 1 ? "%s.%d" : "%s", "d.out", (int)(dcp - g_cmdv)); 645 0 stevel } 646 0 stevel 647 0 stevel if (dtrace_program_link(g_dtp, dcp->dc_prog, DTRACE_D_PROBES, 648 2769 ahl dcp->dc_ofile, g_objc, g_objv) != 0) 649 0 stevel dfatal("failed to link %s %s", dcp->dc_desc, dcp->dc_name); 650 0 stevel } 651 0 stevel 652 0 stevel /*ARGSUSED*/ 653 0 stevel static int 654 0 stevel list_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg) 655 0 stevel { 656 0 stevel dtrace_probeinfo_t p; 657 0 stevel 658 0 stevel oprintf("%5d %10s %17s %33s %s\n", pdp->dtpd_id, 659 0 stevel pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 660 0 stevel 661 0 stevel if (g_verbose && dtrace_probe_info(dtp, pdp, &p) == 0) 662 0 stevel print_probe_info(&p); 663 0 stevel 664 0 stevel return (0); 665 0 stevel } 666 0 stevel 667 0 stevel /*ARGSUSED*/ 668 0 stevel static int 669 0 stevel list_stmt(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, 670 0 stevel dtrace_stmtdesc_t *stp, dtrace_ecbdesc_t **last) 671 0 stevel { 672 0 stevel dtrace_ecbdesc_t *edp = stp->dtsd_ecbdesc; 673 0 stevel 674 0 stevel if (edp == *last) 675 0 stevel return (0); 676 0 stevel 677 0 stevel if (dtrace_probe_iter(g_dtp, &edp->dted_probe, list_probe, NULL) != 0) { 678 0 stevel error("failed to match %s:%s:%s:%s: %s\n", 679 0 stevel edp->dted_probe.dtpd_provider, edp->dted_probe.dtpd_mod, 680 0 stevel edp->dted_probe.dtpd_func, edp->dted_probe.dtpd_name, 681 0 stevel dtrace_errmsg(dtp, dtrace_errno(dtp))); 682 0 stevel } 683 0 stevel 684 0 stevel *last = edp; 685 0 stevel return (0); 686 0 stevel } 687 0 stevel 688 0 stevel /* 689 0 stevel * List the probes corresponding to the specified program by iterating over 690 0 stevel * each statement and then matching probes to the statement probe descriptions. 691 0 stevel */ 692 0 stevel static void 693 0 stevel list_prog(const dtrace_cmd_t *dcp) 694 0 stevel { 695 0 stevel dtrace_ecbdesc_t *last = NULL; 696 0 stevel 697 0 stevel (void) dtrace_stmt_iter(g_dtp, dcp->dc_prog, 698 0 stevel (dtrace_stmt_f *)list_stmt, &last); 699 0 stevel } 700 0 stevel 701 0 stevel static void 702 0 stevel compile_file(dtrace_cmd_t *dcp) 703 0 stevel { 704 0 stevel char *arg0; 705 0 stevel FILE *fp; 706 0 stevel 707 0 stevel if ((fp = fopen(dcp->dc_arg, "r")) == NULL) 708 0 stevel fatal("failed to open %s", dcp->dc_arg); 709 0 stevel 710 0 stevel arg0 = g_argv[0]; 711 0 stevel g_argv[0] = dcp->dc_arg; 712 0 stevel 713 0 stevel if ((dcp->dc_prog = dtrace_program_fcompile(g_dtp, fp, 714 0 stevel g_cflags, g_argc, g_argv)) == NULL) 715 0 stevel dfatal("failed to compile script %s", dcp->dc_arg); 716 0 stevel 717 0 stevel g_argv[0] = arg0; 718 0 stevel (void) fclose(fp); 719 0 stevel 720 0 stevel dcp->dc_desc = "script"; 721 0 stevel dcp->dc_name = dcp->dc_arg; 722 0 stevel } 723 0 stevel 724 0 stevel static void 725 0 stevel compile_str(dtrace_cmd_t *dcp) 726 0 stevel { 727 0 stevel char *p; 728 0 stevel 729 0 stevel if ((dcp->dc_prog = dtrace_program_strcompile(g_dtp, dcp->dc_arg, 730 0 stevel dcp->dc_spec, g_cflags | DTRACE_C_PSPEC, g_argc, g_argv)) == NULL) 731 0 stevel dfatal("invalid probe specifier %s", dcp->dc_arg); 732 0 stevel 733 0 stevel if ((p = strpbrk(dcp->dc_arg, "{/;")) != NULL) 734 0 stevel *p = '\0'; /* crop name for reporting */ 735 0 stevel 736 0 stevel dcp->dc_desc = "description"; 737 0 stevel dcp->dc_name = dcp->dc_arg; 738 0 stevel } 739 0 stevel 740 0 stevel /*ARGSUSED*/ 741 0 stevel static void 742 1399 ahl prochandler(struct ps_prochandle *P, const char *msg, void *arg) 743 0 stevel { 744 0 stevel const psinfo_t *prp = Ppsinfo(P); 745 0 stevel int pid = Pstatus(P)->pr_pid; 746 0 stevel char name[SIG2STR_MAX]; 747 1399 ahl 748 1399 ahl if (msg != NULL) { 749 1399 ahl notice("pid %d: %s\n", pid, msg); 750 1399 ahl return; 751 1399 ahl } 752 0 stevel 753 0 stevel switch (Pstate(P)) { 754 0 stevel case PS_UNDEAD: 755 0 stevel /* 756 0 stevel * Ideally we would like to always report pr_wstat here, but it 757 0 stevel * isn't possible given current /proc semantics. If we grabbed 758 0 stevel * the process, Ppsinfo() will either fail or return a zeroed 759 0 stevel * psinfo_t depending on how far the parent is in reaping it. 760 0 stevel * When /proc provides a stable pr_wstat in the status file, 761 0 stevel * this code can be improved by examining this new pr_wstat. 762 0 stevel */ 763 0 stevel if (prp != NULL && WIFSIGNALED(prp->pr_wstat)) { 764 0 stevel notice("pid %d terminated by %s\n", pid, 765 0 stevel proc_signame(WTERMSIG(prp->pr_wstat), 766 0 stevel name, sizeof (name))); 767 0 stevel } else if (prp != NULL && WEXITSTATUS(prp->pr_wstat) != 0) { 768 0 stevel notice("pid %d exited with status %d\n", 769 0 stevel pid, WEXITSTATUS(prp->pr_wstat)); 770 0 stevel } else { 771 0 stevel notice("pid %d has exited\n", pid); 772 0 stevel } 773 0 stevel g_pslive--; 774 0 stevel break; 775 0 stevel 776 0 stevel case PS_LOST: 777 0 stevel notice("pid %d exec'd a set-id or unobservable program\n", pid); 778 0 stevel g_pslive--; 779 0 stevel break; 780 0 stevel } 781 0 stevel } 782 0 stevel 783 0 stevel /*ARGSUSED*/ 784 0 stevel static int 785 457 bmc errhandler(const dtrace_errdata_t *data, void *arg) 786 0 stevel { 787 0 stevel error(data->dteda_msg); 788 0 stevel return (DTRACE_HANDLE_OK); 789 0 stevel } 790 0 stevel 791 0 stevel /*ARGSUSED*/ 792 0 stevel static int 793 457 bmc drophandler(const dtrace_dropdata_t *data, void *arg) 794 0 stevel { 795 0 stevel error(data->dtdda_msg); 796 457 bmc return (DTRACE_HANDLE_OK); 797 457 bmc } 798 457 bmc 799 457 bmc /*ARGSUSED*/ 800 457 bmc static int 801 457 bmc setopthandler(const dtrace_setoptdata_t *data, void *arg) 802 457 bmc { 803 457 bmc if (strcmp(data->dtsda_option, "quiet") == 0) 804 457 bmc g_quiet = data->dtsda_newval != DTRACEOPT_UNSET; 805 457 bmc 806 457 bmc if (strcmp(data->dtsda_option, "flowindent") == 0) 807 457 bmc g_flowindent = data->dtsda_newval != DTRACEOPT_UNSET; 808 457 bmc 809 0 stevel return (DTRACE_HANDLE_OK); 810 0 stevel } 811 0 stevel 812 1017 bmc #define BUFDUMPHDR(hdr) \ 813 1017 bmc (void) printf("%s: %s%s\n", g_pname, hdr, strlen(hdr) > 0 ? ":" : ""); 814 1017 bmc 815 1017 bmc #define BUFDUMPSTR(ptr, field) \ 816 1017 bmc (void) printf("%s: %20s => ", g_pname, #field); \ 817 1017 bmc if ((ptr)->field != NULL) { \ 818 1017 bmc const char *c = (ptr)->field; \ 819 1017 bmc (void) printf("\""); \ 820 1017 bmc do { \ 821 1017 bmc if (*c == '\n') { \ 822 1017 bmc (void) printf("\\n"); \ 823 1017 bmc continue; \ 824 1017 bmc } \ 825 1017 bmc \ 826 1017 bmc (void) printf("%c", *c); \ 827 1017 bmc } while (*c++ != '\0'); \ 828 1017 bmc (void) printf("\"\n"); \ 829 1017 bmc } else { \ 830 1017 bmc (void) printf("<NULL>\n"); \ 831 1017 bmc } 832 1017 bmc 833 1017 bmc #define BUFDUMPASSTR(ptr, field, str) \ 834 1017 bmc (void) printf("%s: %20s => %s\n", g_pname, #field, str); 835 1017 bmc 836 1017 bmc #define BUFDUMP(ptr, field) \ 837 1017 bmc (void) printf("%s: %20s => %lld\n", g_pname, #field, \ 838 1017 bmc (long long)(ptr)->field); 839 1017 bmc 840 1017 bmc #define BUFDUMPPTR(ptr, field) \ 841 1017 bmc (void) printf("%s: %20s => %s\n", g_pname, #field, \ 842 1017 bmc (ptr)->field != NULL ? "<non-NULL>" : "<NULL>"); 843 1017 bmc 844 1017 bmc /*ARGSUSED*/ 845 1017 bmc static int 846 1017 bmc bufhandler(const dtrace_bufdata_t *bufdata, void *arg) 847 1017 bmc { 848 1017 bmc const dtrace_aggdata_t *agg = bufdata->dtbda_aggdata; 849 1017 bmc const dtrace_recdesc_t *rec = bufdata->dtbda_recdesc; 850 1017 bmc const dtrace_probedesc_t *pd; 851 1017 bmc uint32_t flags = bufdata->dtbda_flags; 852 1017 bmc char buf[512], *c = buf, *end = c + sizeof (buf); 853 1017 bmc int i, printed; 854 1017 bmc 855 1017 bmc struct { 856 1017 bmc const char *name; 857 1017 bmc uint32_t value; 858 1017 bmc } flagnames[] = { 859 1017 bmc { "AGGVAL", DTRACE_BUFDATA_AGGVAL }, 860 1017 bmc { "AGGKEY", DTRACE_BUFDATA_AGGKEY }, 861 1017 bmc { "AGGFORMAT", DTRACE_BUFDATA_AGGFORMAT }, 862 1017 bmc { "AGGLAST", DTRACE_BUFDATA_AGGLAST }, 863 1017 bmc { "???", UINT32_MAX }, 864 1017 bmc { NULL } 865 1017 bmc }; 866 1017 bmc 867 1017 bmc if (bufdata->dtbda_probe != NULL) { 868 1017 bmc pd = bufdata->dtbda_probe->dtpda_pdesc; 869 1017 bmc } else if (agg != NULL) { 870 1017 bmc pd = agg->dtada_pdesc; 871 1017 bmc } else { 872 1017 bmc pd = NULL; 873 1017 bmc } 874 1017 bmc 875 1017 bmc BUFDUMPHDR(">>> Called buffer handler"); 876 1017 bmc BUFDUMPHDR(""); 877 1017 bmc 878 1017 bmc BUFDUMPHDR(" dtrace_bufdata"); 879 1017 bmc BUFDUMPSTR(bufdata, dtbda_buffered); 880 1017 bmc BUFDUMPPTR(bufdata, dtbda_probe); 881 1017 bmc BUFDUMPPTR(bufdata, dtbda_aggdata); 882 1017 bmc BUFDUMPPTR(bufdata, dtbda_recdesc); 883 1017 bmc 884 1017 bmc (void) snprintf(c, end - c, "0x%x ", bufdata->dtbda_flags); 885 1017 bmc c += strlen(c); 886 1017 bmc 887 1017 bmc for (i = 0, printed = 0; flagnames[i].name != NULL; i++) { 888 1017 bmc if (!(flags & flagnames[i].value)) 889 1017 bmc continue; 890 1017 bmc 891 1017 bmc (void) snprintf(c, end - c, 892 1017 bmc "%s%s", printed++ ? " | " : "(", flagnames[i].name); 893 1017 bmc c += strlen(c); 894 1017 bmc flags &= ~flagnames[i].value; 895 1017 bmc } 896 1017 bmc 897 1017 bmc if (printed) 898 1017 bmc (void) snprintf(c, end - c, ")"); 899 1017 bmc 900 1017 bmc BUFDUMPASSTR(bufdata, dtbda_flags, buf); 901 1017 bmc BUFDUMPHDR(""); 902 1017 bmc 903 1017 bmc if (pd != NULL) { 904 1017 bmc BUFDUMPHDR(" dtrace_probedesc"); 905 1017 bmc BUFDUMPSTR(pd, dtpd_provider); 906 1017 bmc BUFDUMPSTR(pd, dtpd_mod); 907 1017 bmc BUFDUMPSTR(pd, dtpd_func); 908 1017 bmc BUFDUMPSTR(pd, dtpd_name); 909 1017 bmc BUFDUMPHDR(""); 910 1017 bmc } 911 1017 bmc 912 1017 bmc if (rec != NULL) { 913 1017 bmc BUFDUMPHDR(" dtrace_recdesc"); 914 1017 bmc BUFDUMP(rec, dtrd_action); 915 1017 bmc BUFDUMP(rec, dtrd_size); 916 1028 bmc 917 1028 bmc if (agg != NULL) { 918 1028 bmc uint8_t *data; 919 1028 bmc int lim = rec->dtrd_size; 920 1028 bmc 921 1028 bmc (void) sprintf(buf, "%d (data: ", rec->dtrd_offset); 922 1028 bmc c = buf + strlen(buf); 923 1028 bmc 924 1028 bmc if (lim > sizeof (uint64_t)) 925 1028 bmc lim = sizeof (uint64_t); 926 1028 bmc 927 1028 bmc data = (uint8_t *)agg->dtada_data + rec->dtrd_offset; 928 1028 bmc 929 1028 bmc for (i = 0; i < lim; i++) { 930 1028 bmc (void) snprintf(c, end - c, "%s%02x", 931 1028 bmc i == 0 ? "" : " ", *data++); 932 1028 bmc c += strlen(c); 933 1028 bmc } 934 1028 bmc 935 1028 bmc (void) snprintf(c, end - c, 936 1028 bmc "%s)", lim < rec->dtrd_size ? " ..." : ""); 937 1028 bmc BUFDUMPASSTR(rec, dtrd_offset, buf); 938 1028 bmc } else { 939 1028 bmc BUFDUMP(rec, dtrd_offset); 940 1028 bmc } 941 1028 bmc 942 1017 bmc BUFDUMPHDR(""); 943 1017 bmc } 944 1017 bmc 945 1017 bmc if (agg != NULL) { 946 1017 bmc dtrace_aggdesc_t *desc = agg->dtada_desc; 947 1017 bmc 948 1017 bmc BUFDUMPHDR(" dtrace_aggdesc"); 949 1017 bmc BUFDUMPSTR(desc, dtagd_name); 950 1017 bmc BUFDUMP(desc, dtagd_varid); 951 1017 bmc BUFDUMP(desc, dtagd_id); 952 1017 bmc BUFDUMP(desc, dtagd_nrecs); 953 1017 bmc BUFDUMPHDR(""); 954 1017 bmc } 955 1017 bmc 956 1017 bmc return (DTRACE_HANDLE_OK); 957 1017 bmc } 958 1017 bmc 959 0 stevel /*ARGSUSED*/ 960 0 stevel static int 961 0 stevel chewrec(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg) 962 0 stevel { 963 0 stevel dtrace_actkind_t act; 964 0 stevel uintptr_t addr; 965 0 stevel 966 0 stevel if (rec == NULL) { 967 0 stevel /* 968 0 stevel * We have processed the final record; output the newline if 969 0 stevel * we're not in quiet mode. 970 0 stevel */ 971 0 stevel if (!g_quiet) 972 0 stevel oprintf("\n"); 973 0 stevel 974 0 stevel return (DTRACE_CONSUME_NEXT); 975 0 stevel } 976 0 stevel 977 0 stevel act = rec->dtrd_action; 978 0 stevel addr = (uintptr_t)data->dtpda_data; 979 0 stevel 980 0 stevel if (act == DTRACEACT_EXIT) { 981 0 stevel g_status = *((uint32_t *)addr); 982 0 stevel return (DTRACE_CONSUME_NEXT); 983 0 stevel } 984 0 stevel 985 0 stevel return (DTRACE_CONSUME_THIS); 986 0 stevel } 987 0 stevel 988 0 stevel /*ARGSUSED*/ 989 0 stevel static int 990 0 stevel chew(const dtrace_probedata_t *data, void *arg) 991 0 stevel { 992 0 stevel dtrace_probedesc_t *pd = data->dtpda_pdesc; 993 0 stevel processorid_t cpu = data->dtpda_cpu; 994 0 stevel static int heading; 995 0 stevel 996 0 stevel if (g_impatient) { 997 0 stevel g_newline = 0; 998 0 stevel return (DTRACE_CONSUME_ABORT); 999 0 stevel } 1000 0 stevel 1001 0 stevel if (heading == 0) { 1002 0 stevel if (!g_flowindent) { 1003 0 stevel if (!g_quiet) { 1004 0 stevel oprintf("%3s %6s %32s\n", 1005 0 stevel "CPU", "ID", "FUNCTION:NAME"); 1006 0 stevel } 1007 0 stevel } else { 1008 0 stevel oprintf("%3s %-41s\n", "CPU", "FUNCTION"); 1009 0 stevel } 1010 0 stevel heading = 1; 1011 0 stevel } 1012 0 stevel 1013 0 stevel if (!g_flowindent) { 1014 0 stevel if (!g_quiet) { 1015 0 stevel char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2]; 1016 0 stevel 1017 0 stevel (void) snprintf(name, sizeof (name), "%s:%s", 1018 0 stevel pd->dtpd_func, pd->dtpd_name); 1019 0 stevel 1020 0 stevel oprintf("%3d %6d %32s ", cpu, pd->dtpd_id, name); 1021 0 stevel } 1022 0 stevel } else { 1023 0 stevel int indent = data->dtpda_indent; 1024 0 stevel char *name; 1025 0 stevel size_t len; 1026 0 stevel 1027 0 stevel if (data->dtpda_flow == DTRACEFLOW_NONE) { 1028 0 stevel len = indent + DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 5; 1029 0 stevel name = alloca(len); 1030 0 stevel (void) snprintf(name, len, "%*s%s%s:%s", indent, "", 1031 0 stevel data->dtpda_prefix, pd->dtpd_func, 1032 0 stevel pd->dtpd_name); 1033 0 stevel } else { 1034 0 stevel len = indent + DTRACE_FUNCNAMELEN + 5; 1035 0 stevel name = alloca(len); 1036 0 stevel (void) snprintf(name, len, "%*s%s%s", indent, "", 1037 0 stevel data->dtpda_prefix, pd->dtpd_func); 1038 0 stevel } 1039 0 stevel 1040 0 stevel oprintf("%3d %-41s ", cpu, name); 1041 0 stevel } 1042 0 stevel 1043 0 stevel return (DTRACE_CONSUME_THIS); 1044 0 stevel } 1045 0 stevel 1046 0 stevel static void 1047 0 stevel go(void) 1048 0 stevel { 1049 0 stevel int i; 1050 0 stevel 1051 0 stevel struct { 1052 0 stevel char *name; 1053 0 stevel char *optname; 1054 0 stevel dtrace_optval_t val; 1055 0 stevel } bufs[] = { 1056 0 stevel { "buffer size", "bufsize" }, 1057 0 stevel { "aggregation size", "aggsize" }, 1058 0 stevel { "speculation size", "specsize" }, 1059 0 stevel { "dynamic variable size", "dynvarsize" }, 1060 0 stevel { NULL } 1061 0 stevel }, rates[] = { 1062 0 stevel { "cleaning rate", "cleanrate" }, 1063 0 stevel { "status rate", "statusrate" }, 1064 0 stevel { NULL } 1065 0 stevel }; 1066 0 stevel 1067 0 stevel for (i = 0; bufs[i].name != NULL; i++) { 1068 0 stevel if (dtrace_getopt(g_dtp, bufs[i].optname, &bufs[i].val) == -1) 1069 0 stevel fatal("couldn't get option %s", bufs[i].optname); 1070 0 stevel } 1071 0 stevel 1072 0 stevel for (i = 0; rates[i].name != NULL; i++) { 1073 0 stevel if (dtrace_getopt(g_dtp, rates[i].optname, &rates[i].val) == -1) 1074 0 stevel fatal("couldn't get option %s", rates[i].optname); 1075 0 stevel } 1076 0 stevel 1077 0 stevel if (dtrace_go(g_dtp) == -1) 1078 0 stevel dfatal("could not enable tracing"); 1079 0 stevel 1080 0 stevel for (i = 0; bufs[i].name != NULL; i++) { 1081 0 stevel dtrace_optval_t j = 0, mul = 10; 1082 0 stevel dtrace_optval_t nsize; 1083 0 stevel 1084 0 stevel if (bufs[i].val == DTRACEOPT_UNSET) 1085 0 stevel continue; 1086 0 stevel 1087 0 stevel (void) dtrace_getopt(g_dtp, bufs[i].optname, &nsize); 1088 0 stevel 1089 0 stevel if (nsize == DTRACEOPT_UNSET || nsize == 0) 1090 0 stevel continue; 1091 0 stevel 1092 0 stevel if (nsize >= bufs[i].val - sizeof (uint64_t)) 1093 0 stevel continue; 1094 0 stevel 1095 0 stevel for (; (INT64_C(1) << mul) <= nsize; j++, mul += 10) 1096 0 stevel continue; 1097 0 stevel 1098 0 stevel if (!(nsize & ((INT64_C(1) << (mul - 10)) - 1))) { 1099 0 stevel error("%s lowered to %lld%c\n", bufs[i].name, 1100 0 stevel (long long)nsize >> (mul - 10), " kmgtpe"[j]); 1101 0 stevel } else { 1102 0 stevel error("%s lowered to %lld bytes\n", bufs[i].name, 1103 0 stevel (long long)nsize); 1104 0 stevel } 1105 0 stevel } 1106 0 stevel 1107 0 stevel for (i = 0; rates[i].name != NULL; i++) { 1108 0 stevel dtrace_optval_t nval; 1109 0 stevel char *dir; 1110 0 stevel 1111 0 stevel if (rates[i].val == DTRACEOPT_UNSET) 1112 0 stevel continue; 1113 0 stevel 1114 0 stevel (void) dtrace_getopt(g_dtp, rates[i].optname, &nval); 1115 0 stevel 1116 0 stevel if (nval == DTRACEOPT_UNSET || nval == 0) 1117 0 stevel continue; 1118 0 stevel 1119 0 stevel if (rates[i].val == nval) 1120 0 stevel continue; 1121 0 stevel 1122 0 stevel dir = nval > rates[i].val ? "reduced" : "increased"; 1123 0 stevel 1124 0 stevel if (nval <= NANOSEC && (NANOSEC % nval) == 0) { 1125 0 stevel error("%s %s to %lld hz\n", rates[i].name, dir, 1126 0 stevel (long long)NANOSEC / (long long)nval); 1127 0 stevel continue; 1128 0 stevel } 1129 0 stevel 1130 0 stevel if ((nval % NANOSEC) == 0) { 1131 0 stevel error("%s %s to once every %lld seconds\n", 1132 0 stevel rates[i].name, dir, 1133 0 stevel (long long)nval / (long long)NANOSEC); 1134 0 stevel continue; 1135 0 stevel } 1136 0 stevel 1137 0 stevel error("%s %s to once every %lld nanoseconds\n", 1138 0 stevel rates[i].name, dir, (long long)nval); 1139 0 stevel } 1140 0 stevel } 1141 0 stevel 1142 0 stevel /*ARGSUSED*/ 1143 0 stevel static void 1144 0 stevel intr(int signo) 1145 0 stevel { 1146 0 stevel if (!g_intr) 1147 0 stevel g_newline = 1; 1148 0 stevel 1149 0 stevel if (g_intr++) 1150 0 stevel g_impatient = 1; 1151 0 stevel } 1152 0 stevel 1153 0 stevel int 1154 0 stevel main(int argc, char *argv[]) 1155 0 stevel { 1156 0 stevel dtrace_bufdesc_t buf; 1157 1222 mws struct sigaction act, oact; 1158 0 stevel dtrace_status_t status[2]; 1159 0 stevel dtrace_optval_t opt; 1160 0 stevel dtrace_cmd_t *dcp; 1161 0 stevel 1162 0 stevel int done = 0, mode = 0; 1163 0 stevel int err, i; 1164 0 stevel char c, *p, **v; 1165 0 stevel struct ps_prochandle *P; 1166 0 stevel pid_t pid; 1167 0 stevel 1168 0 stevel g_pname = basename(argv[0]); 1169 0 stevel 1170 0 stevel if (argc == 1) 1171 0 stevel return (usage(stderr)); 1172 0 stevel 1173 0 stevel if ((g_argv = malloc(sizeof (char *) * argc)) == NULL || 1174 0 stevel (g_cmdv = malloc(sizeof (dtrace_cmd_t) * argc)) == NULL || 1175 0 stevel (g_psv = malloc(sizeof (struct ps_prochandle *) * argc)) == NULL) 1176 0 stevel fatal("failed to allocate memory for arguments"); 1177 0 stevel 1178 0 stevel g_argv[g_argc++] = argv[0]; /* propagate argv[0] to D as $0/$$0 */ 1179 0 stevel argv[0] = g_pname; /* rewrite argv[0] for getopt errors */ 1180 0 stevel 1181 0 stevel bzero(status, sizeof (status)); 1182 0 stevel bzero(&buf, sizeof (buf)); 1183 0 stevel 1184 0 stevel /* 1185 0 stevel * Make an initial pass through argv[] processing any arguments that 1186 0 stevel * affect our behavior mode (g_mode) and flags used for dtrace_open(). 1187 0 stevel * We also accumulate arguments that are not affiliated with getopt 1188 0 stevel * options into g_argv[], and abort if any invalid options are found. 1189 0 stevel */ 1190 0 stevel for (optind = 1; optind < argc; optind++) { 1191 0 stevel while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 1192 0 stevel switch (c) { 1193 0 stevel case '3': 1194 0 stevel if (strcmp(optarg, "2") != 0) { 1195 0 stevel (void) fprintf(stderr, 1196 0 stevel "%s: illegal option -- 3%s\n", 1197 0 stevel argv[0], optarg); 1198 0 stevel return (usage(stderr)); 1199 0 stevel } 1200 0 stevel g_oflags &= ~DTRACE_O_LP64; 1201 0 stevel g_oflags |= DTRACE_O_ILP32; 1202 0 stevel break; 1203 0 stevel 1204 0 stevel case '6': 1205 0 stevel if (strcmp(optarg, "4") != 0) { 1206 0 stevel (void) fprintf(stderr, 1207 0 stevel "%s: illegal option -- 6%s\n", 1208 0 stevel argv[0], optarg); 1209 0 stevel return (usage(stderr)); 1210 0 stevel } 1211 0 stevel g_oflags &= ~DTRACE_O_ILP32; 1212 0 stevel g_oflags |= DTRACE_O_LP64; 1213 0 stevel break; 1214 0 stevel 1215 0 stevel case 'a': 1216 0 stevel g_grabanon++; /* also checked in pass 2 below */ 1217 0 stevel break; 1218 0 stevel 1219 0 stevel case 'A': 1220 0 stevel g_mode = DMODE_ANON; 1221 0 stevel g_exec = 0; 1222 0 stevel mode++; 1223 0 stevel break; 1224 0 stevel 1225 0 stevel case 'e': 1226 0 stevel g_exec = 0; 1227 0 stevel done = 1; 1228 0 stevel break; 1229 0 stevel 1230 1399 ahl case 'h': 1231 1399 ahl g_mode = DMODE_HEADER; 1232 1399 ahl g_oflags |= DTRACE_O_NODEV; 1233 1399 ahl g_cflags |= DTRACE_C_ZDEFS; /* -h implies -Z */ 1234 1399 ahl g_exec = 0; 1235 1399 ahl mode++; 1236 1399 ahl break; 1237 1399 ahl 1238 0 stevel case 'G': 1239 0 stevel g_mode = DMODE_LINK; 1240 0 stevel g_oflags |= DTRACE_O_NODEV; 1241 0 stevel g_cflags |= DTRACE_C_ZDEFS; /* -G implies -Z */ 1242 0 stevel g_exec = 0; 1243 0 stevel mode++; 1244 0 stevel break; 1245 0 stevel 1246 0 stevel case 'l': 1247 0 stevel g_mode = DMODE_LIST; 1248 0 stevel g_cflags |= DTRACE_C_ZDEFS; /* -l implies -Z */ 1249 0 stevel mode++; 1250 0 stevel break; 1251 0 stevel 1252 0 stevel case 'V': 1253 0 stevel g_mode = DMODE_VERS; 1254 0 stevel mode++; 1255 0 stevel break; 1256 0 stevel 1257 0 stevel default: 1258 0 stevel if (strchr(DTRACE_OPTSTR, c) == NULL) 1259 0 stevel return (usage(stderr)); 1260 0 stevel } 1261 0 stevel } 1262 0 stevel 1263 0 stevel if (optind < argc) 1264 0 stevel g_argv[g_argc++] = argv[optind]; 1265 0 stevel } 1266 0 stevel 1267 0 stevel if (mode > 1) { 1268 1399 ahl (void) fprintf(stderr, "%s: only one of the [-AGhlV] options " 1269 0 stevel "can be specified at a time\n", g_pname); 1270 0 stevel return (E_USAGE); 1271 0 stevel } 1272 0 stevel 1273 0 stevel if (g_mode == DMODE_VERS) 1274 0 stevel return (printf("%s: %s\n", g_pname, _dtrace_version) <= 0); 1275 0 stevel 1276 0 stevel /* 1277 2769 ahl * If we're in linker mode and the data model hasn't been specified, 1278 2769 ahl * we try to guess the appropriate setting by examining the object 1279 2769 ahl * files. We ignore certain errors since we'll catch them later when 1280 2769 ahl * we actually process the object files. 1281 2769 ahl */ 1282 2769 ahl if (g_mode == DMODE_LINK && 1283 2769 ahl (g_oflags & (DTRACE_O_ILP32 | DTRACE_O_LP64)) == 0 && 1284 2769 ahl elf_version(EV_CURRENT) != EV_NONE) { 1285 2769 ahl int fd; 1286 2769 ahl Elf *elf; 1287 2769 ahl GElf_Ehdr ehdr; 1288 2769 ahl 1289 2769 ahl for (i = 1; i < g_argc; i++) { 1290 2769 ahl if ((fd = open64(g_argv[i], O_RDONLY)) == -1) 1291 2769 ahl break; 1292 2769 ahl 1293 2769 ahl if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { 1294 2769 ahl (void) close(fd); 1295 2769 ahl break; 1296 2769 ahl } 1297 2769 ahl 1298 2769 ahl if (elf_kind(elf) != ELF_K_ELF || 1299 2769 ahl gelf_getehdr(elf, &ehdr) == NULL) { 1300 2769 ahl (void) close(fd); 1301 2769 ahl (void) elf_end(elf); 1302 2769 ahl break; 1303 2769 ahl } 1304 2769 ahl 1305 2769 ahl (void) close(fd); 1306 2769 ahl (void) elf_end(elf); 1307 2769 ahl 1308 2769 ahl if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) { 1309 2769 ahl if (g_oflags & DTRACE_O_ILP32) { 1310 2769 ahl fatal("can't mix 32-bit and 64-bit " 1311 2769 ahl "object files\n"); 1312 2769 ahl } 1313 2769 ahl g_oflags |= DTRACE_O_LP64; 1314 2769 ahl } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) { 1315 2769 ahl if (g_oflags & DTRACE_O_LP64) { 1316 2769 ahl fatal("can't mix 32-bit and 64-bit " 1317 2769 ahl "object files\n"); 1318 2769 ahl } 1319 2769 ahl g_oflags |= DTRACE_O_ILP32; 1320 2769 ahl } else { 1321 2769 ahl break; 1322 2769 ahl } 1323 2769 ahl } 1324 2769 ahl } 1325 2769 ahl 1326 2769 ahl /* 1327 0 stevel * Open libdtrace. If we are not actually going to be enabling any 1328 0 stevel * instrumentation attempt to reopen libdtrace using DTRACE_O_NODEV. 1329 0 stevel */ 1330 0 stevel while ((g_dtp = dtrace_open(DTRACE_VERSION, g_oflags, &err)) == NULL) { 1331 0 stevel if (!(g_oflags & DTRACE_O_NODEV) && !g_exec && !g_grabanon) { 1332 0 stevel g_oflags |= DTRACE_O_NODEV; 1333 0 stevel continue; 1334 0 stevel } 1335 0 stevel 1336 0 stevel fatal("failed to initialize dtrace: %s\n", 1337 0 stevel dtrace_errmsg(NULL, err)); 1338 0 stevel } 1339 0 stevel 1340 0 stevel (void) dtrace_setopt(g_dtp, "bufsize", "4m"); 1341 0 stevel (void) dtrace_setopt(g_dtp, "aggsize", "4m"); 1342 0 stevel 1343 0 stevel /* 1344 0 stevel * If -G is specified, enable -xlink=dynamic and -xunodefs to permit 1345 0 stevel * references to undefined symbols to remain as unresolved relocations. 1346 0 stevel * If -A is specified, enable -xlink=primary to permit static linking 1347 0 stevel * only to kernel symbols that are defined in a primary kernel module. 1348 0 stevel */ 1349 0 stevel if (g_mode == DMODE_LINK) { 1350 0 stevel (void) dtrace_setopt(g_dtp, "linkmode", "dynamic"); 1351 0 stevel (void) dtrace_setopt(g_dtp, "unodefs", NULL); 1352 0 stevel 1353 2769 ahl /* 1354 2769 ahl * Use the remaining arguments as the list of object files 1355 2769 ahl * when in linker mode. 1356 2769 ahl */ 1357 2769 ahl g_objc = g_argc - 1; 1358 2769 ahl g_objv = g_argv + 1; 1359 0 stevel 1360 0 stevel /* 1361 0 stevel * We still use g_argv[0], the name of the executable. 1362 0 stevel */ 1363 0 stevel g_argc = 1; 1364 0 stevel } else if (g_mode == DMODE_ANON) 1365 0 stevel (void) dtrace_setopt(g_dtp, "linkmode", "primary"); 1366 0 stevel 1367 0 stevel /* 1368 0 stevel * Now that we have libdtrace open, make a second pass through argv[] 1369 0 stevel * to perform any dtrace_setopt() calls and change any compiler flags. 1370 0 stevel * We also accumulate any program specifications into our g_cmdv[] at 1371 0 stevel * this time; these will compiled as part of the fourth processing pass. 1372 0 stevel */ 1373 0 stevel for (optind = 1; optind < argc; optind++) { 1374 0 stevel while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 1375 0 stevel switch (c) { 1376 0 stevel case 'a': 1377 0 stevel if (dtrace_setopt(g_dtp, "grabanon", 0) != 0) 1378 0 stevel dfatal("failed to set -a"); 1379 0 stevel break; 1380 0 stevel 1381 0 stevel case 'b': 1382 0 stevel if (dtrace_setopt(g_dtp, 1383 0 stevel "bufsize", optarg) != 0) 1384 0 stevel dfatal("failed to set -b %s", optarg); 1385 0 stevel break; 1386 0 stevel 1387 1017 bmc case 'B': 1388 1017 bmc g_ofp = NULL; 1389 1017 bmc break; 1390 1017 bmc 1391 0 stevel case 'C': 1392 0 stevel g_cflags |= DTRACE_C_CPP; 1393 0 stevel break; 1394 0 stevel 1395 0 stevel case 'D': 1396 0 stevel if (dtrace_setopt(g_dtp, "define", optarg) != 0) 1397 0 stevel dfatal("failed to set -D %s", optarg); 1398 0 stevel break; 1399 0 stevel 1400 0 stevel case 'f': 1401 0 stevel dcp = &g_cmdv[g_cmdc++]; 1402 0 stevel dcp->dc_func = compile_str; 1403 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_FUNC; 1404 0 stevel dcp->dc_arg = optarg; 1405 0 stevel break; 1406 0 stevel 1407 0 stevel case 'F': 1408 0 stevel if (dtrace_setopt(g_dtp, "flowindent", 0) != 0) 1409 0 stevel dfatal("failed to set -F"); 1410 0 stevel break; 1411 0 stevel 1412 0 stevel case 'H': 1413 0 stevel if (dtrace_setopt(g_dtp, "cpphdrs", 0) != 0) 1414 0 stevel dfatal("failed to set -H"); 1415 0 stevel break; 1416 0 stevel 1417 0 stevel case 'i': 1418 0 stevel dcp = &g_cmdv[g_cmdc++]; 1419 0 stevel dcp->dc_func = compile_str; 1420 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_NAME; 1421 0 stevel dcp->dc_arg = optarg; 1422 0 stevel break; 1423 0 stevel 1424 0 stevel case 'I': 1425 0 stevel if (dtrace_setopt(g_dtp, "incdir", optarg) != 0) 1426 0 stevel dfatal("failed to set -I %s", optarg); 1427 0 stevel break; 1428 0 stevel 1429 0 stevel case 'L': 1430 0 stevel if (dtrace_setopt(g_dtp, "libdir", optarg) != 0) 1431 0 stevel dfatal("failed to set -L %s", optarg); 1432 0 stevel break; 1433 0 stevel 1434 0 stevel case 'm': 1435 0 stevel dcp = &g_cmdv[g_cmdc++]; 1436 0 stevel dcp->dc_func = compile_str; 1437 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_MOD; 1438 0 stevel dcp->dc_arg = optarg; 1439 0 stevel break; 1440 0 stevel 1441 0 stevel case 'n': 1442 0 stevel dcp = &g_cmdv[g_cmdc++]; 1443 0 stevel dcp->dc_func = compile_str; 1444 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_NAME; 1445 0 stevel dcp->dc_arg = optarg; 1446 0 stevel break; 1447 0 stevel 1448 0 stevel case 'P': 1449 0 stevel dcp = &g_cmdv[g_cmdc++]; 1450 0 stevel dcp->dc_func = compile_str; 1451 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_PROVIDER; 1452 0 stevel dcp->dc_arg = optarg; 1453 0 stevel break; 1454 0 stevel 1455 0 stevel case 'q': 1456 0 stevel if (dtrace_setopt(g_dtp, "quiet", 0) != 0) 1457 0 stevel dfatal("failed to set -q"); 1458 0 stevel break; 1459 0 stevel 1460 0 stevel case 'o': 1461 0 stevel g_ofile = optarg; 1462 0 stevel break; 1463 0 stevel 1464 0 stevel case 's': 1465 0 stevel dcp = &g_cmdv[g_cmdc++]; 1466 0 stevel dcp->dc_func = compile_file; 1467 0 stevel dcp->dc_spec = DTRACE_PROBESPEC_NONE; 1468 0 stevel dcp->dc_arg = optarg; 1469 0 stevel break; 1470 0 stevel 1471 0 stevel case 'S': 1472 0 stevel g_cflags |= DTRACE_C_DIFV; 1473 0 stevel break; 1474 0 stevel 1475 0 stevel case 'U': 1476 0 stevel if (dtrace_setopt(g_dtp, "undef", optarg) != 0) 1477 0 stevel dfatal("failed to set -U %s", optarg); 1478 0 stevel break; 1479 0 stevel 1480 0 stevel case 'v': 1481 0 stevel g_verbose++; 1482 0 stevel break; 1483 0 stevel 1484 0 stevel case 'w': 1485 0 stevel if (dtrace_setopt(g_dtp, "destructive", 0) != 0) 1486 0 stevel dfatal("failed to set -w"); 1487 0 stevel break; 1488 0 stevel 1489 0 stevel case 'x': 1490 0 stevel if ((p = strchr(optarg, '=')) != NULL) 1491 0 stevel *p++ = '\0'; 1492 0 stevel 1493 0 stevel if (dtrace_setopt(g_dtp, optarg, p) != 0) 1494 0 stevel dfatal("failed to set -x %s", optarg); 1495 0 stevel break; 1496 0 stevel 1497 0 stevel case 'X': 1498 0 stevel if (dtrace_setopt(g_dtp, "stdc", optarg) != 0) 1499 0 stevel dfatal("failed to set -X %s", optarg); 1500 0 stevel break; 1501 0 stevel 1502 0 stevel case 'Z': 1503 0 stevel g_cflags |= DTRACE_C_ZDEFS; 1504 0 stevel break; 1505 0 stevel 1506 0 stevel default: 1507 0 stevel if (strchr(DTRACE_OPTSTR, c) == NULL) 1508 0 stevel return (usage(stderr)); 1509 0 stevel } 1510 0 stevel } 1511 0 stevel } 1512 0 stevel 1513 1017 bmc if (g_ofp == NULL && g_mode != DMODE_EXEC) { 1514 1017 bmc (void) fprintf(stderr, "%s: -B not valid in combination" 1515 1017 bmc " with [-AGl] options\n", g_pname); 1516 1017 bmc return (E_USAGE); 1517 1017 bmc } 1518 1017 bmc 1519 1017 bmc if (g_ofp == NULL && g_ofile != NULL) { 1520 1017 bmc (void) fprintf(stderr, "%s: -B not valid in combination" 1521 1017 bmc " with -o option\n", g_pname); 1522 1017 bmc return (E_USAGE); 1523 1017 bmc } 1524 1017 bmc 1525 0 stevel /* 1526 0 stevel * In our third pass we handle any command-line options related to 1527 0 stevel * grabbing or creating victim processes. The behavior of these calls 1528 0 stevel * may been affected by any library options set by the second pass. 1529 0 stevel */ 1530 0 stevel for (optind = 1; optind < argc; optind++) { 1531 0 stevel while ((c = getopt(argc, argv, DTRACE_OPTSTR)) != EOF) { 1532 0 stevel switch (c) { 1533 0 stevel case 'c': 1534 0 stevel if ((v = make_argv(optarg)) == NULL) 1535 0 stevel fatal("failed to allocate memory"); 1536 0 stevel 1537 0 stevel P = dtrace_proc_create(g_dtp, v[0], v); 1538 0 stevel if (P == NULL) 1539 0 stevel dfatal(NULL); /* dtrace_errmsg() only */ 1540 0 stevel 1541 0 stevel g_psv[g_psc++] = P; 1542 0 stevel free(v); 1543 0 stevel break; 1544 0 stevel 1545 0 stevel case 'p': 1546 0 stevel errno = 0; 1547 0 stevel pid = strtol(optarg, &p, 10); 1548 0 stevel 1549 0 stevel if (errno != 0 || p == optarg || p[0] != '\0') 1550 0 stevel fatal("invalid pid: %s\n", optarg); 1551 0 stevel 1552 0 stevel P = dtrace_proc_grab(g_dtp, pid, 0); 1553 0 stevel if (P == NULL) 1554 0 stevel dfatal(NULL); /* dtrace_errmsg() only */ 1555 0 stevel 1556 0 stevel g_psv[g_psc++] = P; 1557 0 stevel break; 1558 0 stevel } 1559 0 stevel } 1560 0 stevel } 1561 0 stevel 1562 0 stevel /* 1563 0 stevel * In our fourth pass we finish g_cmdv[] by calling dc_func to convert 1564 0 stevel * each string or file specification into a compiled program structure. 1565 0 stevel */ 1566 0 stevel for (i = 0; i < g_cmdc; i++) 1567 0 stevel g_cmdv[i].dc_func(&g_cmdv[i]); 1568 0 stevel 1569 0 stevel if (g_mode != DMODE_LIST) { 1570 0 stevel if (dtrace_handle_err(g_dtp, &errhandler, NULL) == -1) 1571 0 stevel dfatal("failed to establish error handler"); 1572 0 stevel 1573 0 stevel if (dtrace_handle_drop(g_dtp, &drophandler, NULL) == -1) 1574 0 stevel dfatal("failed to establish drop handler"); 1575 0 stevel 1576 0 stevel if (dtrace_handle_proc(g_dtp, &prochandler, NULL) == -1) 1577 0 stevel dfatal("failed to establish proc handler"); 1578 457 bmc 1579 457 bmc if (dtrace_handle_setopt(g_dtp, &setopthandler, NULL) == -1) 1580 457 bmc dfatal("failed to establish setopt handler"); 1581 1017 bmc 1582 1017 bmc if (g_ofp == NULL && 1583 1017 bmc dtrace_handle_buffered(g_dtp, &bufhandler, NULL) == -1) 1584 1017 bmc dfatal("failed to establish buffered handler"); 1585 0 stevel } 1586 0 stevel 1587 0 stevel (void) dtrace_getopt(g_dtp, "flowindent", &opt); 1588 0 stevel g_flowindent = opt != DTRACEOPT_UNSET; 1589 0 stevel 1590 0 stevel (void) dtrace_getopt(g_dtp, "grabanon", &opt); 1591 0 stevel g_grabanon = opt != DTRACEOPT_UNSET; 1592 0 stevel 1593 0 stevel (void) dtrace_getopt(g_dtp, "quiet", &opt); 1594 0 stevel g_quiet = opt != DTRACEOPT_UNSET; 1595 0 stevel 1596 0 stevel /* 1597 0 stevel * Now make a fifth and final pass over the options that have been 1598 0 stevel * turned into programs and saved in g_cmdv[], performing any mode- 1599 0 stevel * specific processing. If g_mode is DMODE_EXEC, we will break out 1600 0 stevel * of the switch() and continue on to the data processing loop. For 1601 0 stevel * other modes, we will exit dtrace once mode-specific work is done. 1602 0 stevel */ 1603 0 stevel switch (g_mode) { 1604 0 stevel case DMODE_EXEC: 1605 0 stevel if (g_ofile != NULL && (g_ofp = fopen(g_ofile, "a")) == NULL) 1606 0 stevel fatal("failed to open output file '%s'", g_ofile); 1607 0 stevel 1608 0 stevel for (i = 0; i < g_cmdc; i++) 1609 0 stevel exec_prog(&g_cmdv[i]); 1610 0 stevel 1611 265 mws if (done && !g_grabanon) { 1612 265 mws dtrace_close(g_dtp); 1613 0 stevel return (g_status); 1614 265 mws } 1615 0 stevel break; 1616 0 stevel 1617 0 stevel case DMODE_ANON: 1618 0 stevel if (g_ofile == NULL) 1619 0 stevel g_ofile = "/kernel/drv/dtrace.conf"; 1620 0 stevel 1621 0 stevel dof_prune(g_ofile); /* strip out any old DOF directives */ 1622 0 stevel etcsystem_prune(); /* string out any forceload directives */ 1623 0 stevel 1624 265 mws if (g_cmdc == 0) { 1625 265 mws dtrace_close(g_dtp); 1626 0 stevel return (g_status); 1627 265 mws } 1628 0 stevel 1629 0 stevel if ((g_ofp = fopen(g_ofile, "a")) == NULL) 1630 0 stevel fatal("failed to open output file '%s'", g_ofile); 1631 0 stevel 1632 0 stevel for (i = 0; i < g_cmdc; i++) { 1633 0 stevel anon_prog(&g_cmdv[i], 1634 0 stevel dtrace_dof_create(g_dtp, g_cmdv[i].dc_prog, 0), i); 1635 0 stevel } 1636 0 stevel 1637 0 stevel /* 1638 0 stevel * Dump out the DOF corresponding to the error handler and the 1639 0 stevel * current options as the final DOF property in the .conf file. 1640 0 stevel */ 1641 0 stevel anon_prog(NULL, dtrace_geterr_dof(g_dtp), i++); 1642 0 stevel anon_prog(NULL, dtrace_getopt_dof(g_dtp), i++); 1643 0 stevel 1644 0 stevel if (fclose(g_ofp) == EOF) 1645 0 stevel fatal("failed to close output file '%s'", g_ofile); 1646 0 stevel 1647 0 stevel /* 1648 0 stevel * These messages would use notice() rather than error(), but 1649 0 stevel * we don't want them suppressed when -A is run on a D program 1650 0 stevel * that itself contains a #pragma D option quiet. 1651 0 stevel */ 1652 0 stevel error("saved anonymous enabling in %s\n", g_ofile); 1653 0 stevel etcsystem_add(); 1654 0 stevel error("run update_drv(1M) or reboot to enable changes\n"); 1655 0 stevel 1656 265 mws dtrace_close(g_dtp); 1657 0 stevel return (g_status); 1658 0 stevel 1659 0 stevel case DMODE_LINK: 1660 1222 mws if (g_cmdc == 0) { 1661 1222 mws (void) fprintf(stderr, "%s: -G requires one or more " 1662 1222 mws "scripts or enabling options\n", g_pname); 1663 1222 mws dtrace_close(g_dtp); 1664 1222 mws return (E_USAGE); 1665 1222 mws } 1666 1222 mws 1667 0 stevel for (i = 0; i < g_cmdc; i++) 1668 0 stevel link_prog(&g_cmdv[i]); 1669 191 ahl 1670 191 ahl if (g_cmdc > 1 && g_ofile != NULL) { 1671 191 ahl char **objv = alloca(g_cmdc * sizeof (char *)); 1672 191 ahl 1673 191 ahl for (i = 0; i < g_cmdc; i++) 1674 191 ahl objv[i] = g_cmdv[i].dc_ofile; 1675 191 ahl 1676 191 ahl if (dtrace_program_link(g_dtp, NULL, DTRACE_D_PROBES, 1677 191 ahl g_ofile, g_cmdc, objv) != 0) 1678 265 mws dfatal(NULL); /* dtrace_errmsg() only */ 1679 191 ahl } 1680 191 ahl 1681 265 mws dtrace_close(g_dtp); 1682 0 stevel return (g_status); 1683 0 stevel 1684 0 stevel case DMODE_LIST: 1685 0 stevel if (g_ofile != NULL && (g_ofp = fopen(g_ofile, "a")) == NULL) 1686 0 stevel fatal("failed to open output file '%s'", g_ofile); 1687 0 stevel 1688 0 stevel oprintf("%5s %10s %17s %33s %s\n", 1689 0 stevel "ID", "PROVIDER", "MODULE", "FUNCTION", "NAME"); 1690 0 stevel 1691 0 stevel for (i = 0; i < g_cmdc; i++) 1692 0 stevel list_prog(&g_cmdv[i]); 1693 0 stevel 1694 0 stevel if (g_cmdc == 0) 1695 0 stevel (void) dtrace_probe_iter(g_dtp, NULL, list_probe, NULL); 1696 0 stevel 1697 265 mws dtrace_close(g_dtp); 1698 0 stevel return (g_status); 1699 1399 ahl 1700 1399 ahl case DMODE_HEADER: 1701 1399 ahl if (g_cmdc == 0) { 1702 1399 ahl (void) fprintf(stderr, "%s: -h requires one or more " 1703 1399 ahl "scripts or enabling options\n", g_pname); 1704 1399 ahl dtrace_close(g_dtp); 1705 1399 ahl return (E_USAGE); 1706 1399 ahl } 1707 1399 ahl 1708 1399 ahl if (g_ofile == NULL) { 1709 1399 ahl char *p; 1710 1399 ahl 1711 1399 ahl if (g_cmdc > 1) { 1712 1399 ahl (void) fprintf(stderr, "%s: -h requires an " 1713 1399 ahl "output file if multiple scripts are " 1714 1399 ahl "specified\n", g_pname); 1715 1399 ahl dtrace_close(g_dtp); 1716 1399 ahl return (E_USAGE); 1717 1399 ahl } 1718 1399 ahl 1719 1399 ahl if ((p = strrchr(g_cmdv[0].dc_arg, '.')) == NULL || 1720 1399 ahl strcmp(p, ".d") != 0) { 1721 1399 ahl (void) fprintf(stderr, "%s: -h requires an " 1722 1399 ahl "output file if no scripts are " 1723 1399 ahl "specified\n", g_pname); 1724 1399 ahl dtrace_close(g_dtp); 1725 1399 ahl return (E_USAGE); 1726 1399 ahl } 1727 1399 ahl 1728 1399 ahl p[0] = '\0'; /* strip .d suffix */ 1729 1399 ahl g_ofile = p = g_cmdv[0].dc_ofile; 1730 1399 ahl (void) snprintf(p, sizeof (g_cmdv[0].dc_ofile), 1731 1399 ahl "%s.h", basename(g_cmdv[0].dc_arg)); 1732 1399 ahl } 1733 1399 ahl 1734 1399 ahl if ((g_ofp = fopen(g_ofile, "w")) == NULL) 1735 1399 ahl fatal("failed to open header file '%s'", g_ofile); 1736 1399 ahl 1737 1399 ahl oprintf("/*\n * Generated by dtrace(1M).\n */\n\n"); 1738 1399 ahl 1739 1399 ahl if (dtrace_program_header(g_dtp, g_ofp, g_ofile) != 0 || 1740 1399 ahl fclose(g_ofp) == EOF) 1741 1399 ahl dfatal("failed to create header file %s", g_ofile); 1742 1399 ahl 1743 1399 ahl dtrace_close(g_dtp); 1744 1399 ahl return (g_status); 1745 0 stevel } 1746 0 stevel 1747 0 stevel /* 1748 0 stevel * If -a and -Z were not specified and no probes have been matched, no 1749 0 stevel * probe criteria was specified on the command line and we abort. 1750 0 stevel */ 1751 0 stevel if (g_total == 0 && !g_grabanon && !(g_cflags & DTRACE_C_ZDEFS)) 1752 0 stevel dfatal("no probes %s\n", g_cmdc ? "matched" : "specified"); 1753 0 stevel 1754 0 stevel /* 1755 0 stevel * Start tracing. Once we dtrace_go(), reload any options that affect 1756 0 stevel * our globals in case consuming anonymous state has changed them. 1757 0 stevel */ 1758 0 stevel go(); 1759 0 stevel 1760 0 stevel (void) dtrace_getopt(g_dtp, "flowindent", &opt); 1761 0 stevel g_flowindent = opt != DTRACEOPT_UNSET; 1762 0 stevel 1763 0 stevel (void) dtrace_getopt(g_dtp, "grabanon", &opt); 1764 0 stevel g_grabanon = opt != DTRACEOPT_UNSET; 1765 0 stevel 1766 0 stevel (void) dtrace_getopt(g_dtp, "quiet", &opt); 1767 0 stevel g_quiet = opt != DTRACEOPT_UNSET; 1768 0 stevel 1769 0 stevel (void) dtrace_getopt(g_dtp, "destructive", &opt); 1770 0 stevel if (opt != DTRACEOPT_UNSET) 1771 0 stevel notice("allowing destructive actions\n"); 1772 0 stevel 1773 0 stevel (void) sigemptyset(&act.sa_mask); 1774 0 stevel act.sa_flags = 0; 1775 0 stevel act.sa_handler = intr; 1776 1222 mws 1777 1222 mws if (sigaction(SIGINT, NULL, &oact) == 0 && oact.sa_handler != SIG_IGN) 1778 1222 mws (void) sigaction(SIGINT, &act, NULL); 1779 1222 mws 1780 1222 mws if (sigaction(SIGTERM, NULL, &oact) == 0 && oact.sa_handler != SIG_IGN) 1781 1222 mws (void) sigaction(SIGTERM, &act, NULL); 1782 0 stevel 1783 0 stevel /* 1784 0 stevel * Now that tracing is active and we are ready to consume trace data, 1785 0 stevel * continue any grabbed or created processes, setting them running 1786 0 stevel * using the /proc control mechanism inside of libdtrace. 1787 0 stevel */ 1788 0 stevel for (i = 0; i < g_psc; i++) 1789 0 stevel dtrace_proc_continue(g_dtp, g_psv[i]); 1790 0 stevel 1791 0 stevel g_pslive = g_psc; /* count for prochandler() */ 1792 0 stevel 1793 0 stevel do { 1794 0 stevel if (!g_intr && !done) 1795 0 stevel dtrace_sleep(g_dtp); 1796 0 stevel 1797 0 stevel if (g_newline) { 1798 0 stevel /* 1799 0 stevel * Output a newline just to make the output look 1800 0 stevel * slightly cleaner. Note that we do this even in 1801 0 stevel * "quiet" mode... 1802 0 stevel */ 1803 0 stevel oprintf("\n"); 1804 0 stevel g_newline = 0; 1805 0 stevel } 1806 0 stevel 1807 0 stevel if (done || g_intr || (g_psc != 0 && g_pslive == 0)) { 1808 0 stevel done = 1; 1809 0 stevel if (dtrace_stop(g_dtp) == -1) 1810 0 stevel dfatal("couldn't stop tracing"); 1811 0 stevel } 1812 0 stevel 1813 0 stevel switch (dtrace_work(g_dtp, g_ofp, chew, chewrec, NULL)) { 1814 0 stevel case DTRACE_WORKSTATUS_DONE: 1815 0 stevel done = 1; 1816 0 stevel break; 1817 0 stevel case DTRACE_WORKSTATUS_OKAY: 1818 0 stevel break; 1819 0 stevel default: 1820 0 stevel if (!g_impatient && dtrace_errno(g_dtp) != EINTR) 1821 0 stevel dfatal("processing aborted"); 1822 0 stevel } 1823 0 stevel 1824 1017 bmc if (g_ofp != NULL && fflush(g_ofp) == EOF) 1825 0 stevel clearerr(g_ofp); 1826 0 stevel } while (!done); 1827 0 stevel 1828 0 stevel oprintf("\n"); 1829 0 stevel 1830 0 stevel if (!g_impatient) { 1831 0 stevel if (dtrace_aggregate_print(g_dtp, g_ofp, NULL) == -1 && 1832 0 stevel dtrace_errno(g_dtp) != EINTR) 1833 0 stevel dfatal("failed to print aggregations"); 1834 0 stevel } 1835 0 stevel 1836 0 stevel dtrace_close(g_dtp); 1837 0 stevel return (g_status); 1838 0 stevel } 1839
Indexes created Wed Nov 25 10:59:19 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.