1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 2012 by Delphix. All rights reserved. 29 */ 30 31 #include <sys/resource.h> 32 #include <sys/mman.h> 33 #include <sys/types.h> 34 35 #include <strings.h> 36 #include <signal.h> 37 #include <stdlib.h> 38 #include <unistd.h> 39 #include <limits.h> 40 #if defined(sun) 41 #include <alloca.h> 42 #endif 43 #include <errno.h> 44 #include <fcntl.h> 45 46 #include <dt_impl.h> 47 #include <dt_string.h> 48 49 static int 50 dt_opt_agg(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 51 { 52 dt_aggregate_t *agp = &dtp->dt_aggregate; 53 54 if (arg != NULL) 55 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 56 57 agp->dtat_flags |= option; 58 return (0); 59 } 60 61 /*ARGSUSED*/ 62 static int 63 dt_opt_amin(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 64 { 65 char str[DTRACE_ATTR2STR_MAX]; 66 dtrace_attribute_t attr; 67 68 if (arg == NULL || dtrace_str2attr(arg, &attr) == -1) 69 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 70 71 dt_dprintf("set compiler attribute minimum to %s\n", 72 dtrace_attr2str(attr, str, sizeof (str))); 73 74 if (dtp->dt_pcb != NULL) { 75 dtp->dt_pcb->pcb_cflags |= DTRACE_C_EATTR; 76 dtp->dt_pcb->pcb_amin = attr; 77 } else { 78 dtp->dt_cflags |= DTRACE_C_EATTR; 79 dtp->dt_amin = attr; 80 } 81 82 return (0); 83 } 84 85 static void 86 dt_coredump(void) 87 { 88 const char msg[] = "libdtrace DEBUG: [ forcing coredump ]\n"; 89 90 struct sigaction act; 91 struct rlimit lim; 92 93 (void) write(STDERR_FILENO, msg, sizeof (msg) - 1); 94 95 act.sa_handler = SIG_DFL; 96 act.sa_flags = 0; 97 98 (void) sigemptyset(&act.sa_mask); 99 (void) sigaction(SIGABRT, &act, NULL); 100 101 lim.rlim_cur = RLIM_INFINITY; 102 lim.rlim_max = RLIM_INFINITY; 103 104 (void) setrlimit(RLIMIT_CORE, &lim); 105 abort(); 106 } 107 108 /*ARGSUSED*/ 109 static int 110 dt_opt_core(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 111 { 112 static int enabled = 0; 113 114 if (arg != NULL) 115 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 116 117 if (enabled++ || atexit(dt_coredump) == 0) 118 return (0); 119 120 return (dt_set_errno(dtp, errno)); 121 } 122 123 /*ARGSUSED*/ 124 static int 125 dt_opt_cpp_hdrs(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 126 { 127 if (arg != NULL) 128 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 129 130 if (dtp->dt_pcb != NULL) 131 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 132 133 if (dt_cpp_add_arg(dtp, "-H") == NULL) 134 return (dt_set_errno(dtp, EDT_NOMEM)); 135 136 return (0); 137 } 138 139 /*ARGSUSED*/ 140 static int 141 dt_opt_cpp_path(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 142 { 143 char *cpp; 144 145 if (arg == NULL) 146 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 147 148 if (dtp->dt_pcb != NULL) 149 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 150 151 if ((cpp = strdup(arg)) == NULL) 152 return (dt_set_errno(dtp, EDT_NOMEM)); 153 154 dtp->dt_cpp_argv[0] = (char *)strbasename(cpp); 155 free(dtp->dt_cpp_path); 156 dtp->dt_cpp_path = cpp; 157 158 return (0); 159 } 160 161 static int 162 dt_opt_cpp_opts(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 163 { 164 char *buf; 165 size_t len; 166 const char *opt = (const char *)option; 167 168 if (opt == NULL || arg == NULL) 169 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 170 171 if (dtp->dt_pcb != NULL) 172 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 173 174 len = strlen(opt) + strlen(arg) + 1; 175 buf = alloca(len); 176 177 (void) strcpy(buf, opt); 178 (void) strcat(buf, arg); 179 180 if (dt_cpp_add_arg(dtp, buf) == NULL) 181 return (dt_set_errno(dtp, EDT_NOMEM)); 182 183 return (0); 184 } 185 186 /*ARGSUSED*/ 187 static int 188 dt_opt_ctypes(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 189 { 190 int fd; 191 192 if (arg == NULL) 193 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 194 195 if ((fd = open64(arg, O_CREAT | O_WRONLY, 0666)) == -1) 196 return (dt_set_errno(dtp, errno)); 197 198 (void) close(dtp->dt_cdefs_fd); 199 dtp->dt_cdefs_fd = fd; 200 return (0); 201 } 202 203 /*ARGSUSED*/ 204 static int 205 dt_opt_droptags(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 206 { 207 dtp->dt_droptags = 1; 208 return (0); 209 } 210 211 /*ARGSUSED*/ 212 static int 213 dt_opt_dtypes(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 214 { 215 int fd; 216 217 if (arg == NULL) 218 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 219 220 if ((fd = open64(arg, O_CREAT | O_WRONLY, 0666)) == -1) 221 return (dt_set_errno(dtp, errno)); 222 223 (void) close(dtp->dt_ddefs_fd); 224 dtp->dt_ddefs_fd = fd; 225 return (0); 226 } 227 228 /*ARGSUSED*/ 229 static int 230 dt_opt_debug(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 231 { 232 if (arg != NULL) 233 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 234 235 _dtrace_debug = 1; 236 return (0); 237 } 238 239 /*ARGSUSED*/ 240 static int 241 dt_opt_iregs(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 242 { 243 int n; 244 245 if (arg == NULL || (n = atoi(arg)) <= 0) 246 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 247 248 dtp->dt_conf.dtc_difintregs = n; 249 return (0); 250 } 251 252 /*ARGSUSED*/ 253 static int 254 dt_opt_lazyload(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 255 { 256 dtp->dt_lazyload = 1; 257 258 return (0); 259 } 260 261 /*ARGSUSED*/ 262 static int 263 dt_opt_ld_path(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 264 { 265 char *ld; 266 267 if (arg == NULL) 268 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 269 270 if (dtp->dt_pcb != NULL) 271 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 272 273 if ((ld = strdup(arg)) == NULL) 274 return (dt_set_errno(dtp, EDT_NOMEM)); 275 276 free(dtp->dt_ld_path); 277 dtp->dt_ld_path = ld; 278 279 return (0); 280 } 281 282 /*ARGSUSED*/ 283 static int 284 dt_opt_libdir(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 285 { 286 dt_dirpath_t *dp; 287 288 if (arg == NULL) 289 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 290 291 if ((dp = malloc(sizeof (dt_dirpath_t))) == NULL || 292 (dp->dir_path = strdup(arg)) == NULL) { 293 free(dp); 294 return (dt_set_errno(dtp, EDT_NOMEM)); 295 } 296 297 dt_list_append(&dtp->dt_lib_path, dp); 298 return (0); 299 } 300 301 /*ARGSUSED*/ 302 static int 303 dt_opt_linkmode(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 304 { 305 if (arg == NULL) 306 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 307 308 if (strcmp(arg, "kernel") == 0) 309 dtp->dt_linkmode = DT_LINK_KERNEL; 310 else if (strcmp(arg, "primary") == 0) 311 dtp->dt_linkmode = DT_LINK_PRIMARY; 312 else if (strcmp(arg, "dynamic") == 0) 313 dtp->dt_linkmode = DT_LINK_DYNAMIC; 314 else if (strcmp(arg, "static") == 0) 315 dtp->dt_linkmode = DT_LINK_STATIC; 316 else 317 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 318 319 return (0); 320 } 321 322 /*ARGSUSED*/ 323 static int 324 dt_opt_linktype(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 325 { 326 if (arg == NULL) 327 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 328 329 if (strcasecmp(arg, "elf") == 0) 330 dtp->dt_linktype = DT_LTYP_ELF; 331 else if (strcasecmp(arg, "dof") == 0) 332 dtp->dt_linktype = DT_LTYP_DOF; 333 else 334 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 335 336 return (0); 337 } 338 339 /*ARGSUSED*/ 340 static int 341 dt_opt_evaltime(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 342 { 343 if (arg == NULL) 344 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 345 346 if (strcmp(arg, "exec") == 0) 347 dtp->dt_prcmode = DT_PROC_STOP_CREATE; 348 else if (strcmp(arg, "preinit") == 0) 349 dtp->dt_prcmode = DT_PROC_STOP_PREINIT; 350 else if (strcmp(arg, "postinit") == 0) 351 dtp->dt_prcmode = DT_PROC_STOP_POSTINIT; 352 else if (strcmp(arg, "main") == 0) 353 dtp->dt_prcmode = DT_PROC_STOP_MAIN; 354 else 355 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 356 357 return (0); 358 } 359 360 /*ARGSUSED*/ 361 static int 362 dt_opt_pgmax(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 363 { 364 int n; 365 366 if (arg == NULL || (n = atoi(arg)) < 0) 367 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 368 369 dtp->dt_procs->dph_lrulim = n; 370 return (0); 371 } 372 373 static int 374 dt_opt_setenv(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 375 { 376 char **p; 377 char *var; 378 int i; 379 380 /* 381 * We can't effectively set environment variables from #pragma lines 382 * since the processes have already been spawned. 383 */ 384 if (dtp->dt_pcb != NULL) 385 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 386 387 if (arg == NULL) 388 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 389 390 if (!option && strchr(arg, '=') != NULL) 391 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 392 393 for (i = 1, p = dtp->dt_proc_env; *p != NULL; i++, p++) 394 continue; 395 396 for (p = dtp->dt_proc_env; *p != NULL; p++) { 397 var = strchr(*p, '='); 398 if (var == NULL) 399 var = *p + strlen(*p); 400 if (strncmp(*p, arg, var - *p) == 0) { 401 dt_free(dtp, *p); 402 *p = dtp->dt_proc_env[i - 1]; 403 dtp->dt_proc_env[i - 1] = NULL; 404 i--; 405 } 406 } 407 408 if (option) { 409 if ((var = strdup(arg)) == NULL) 410 return (dt_set_errno(dtp, EDT_NOMEM)); 411 412 if ((p = dt_alloc(dtp, sizeof (char *) * (i + 1))) == NULL) { 413 dt_free(dtp, var); 414 return (dt_set_errno(dtp, EDT_NOMEM)); 415 } 416 417 bcopy(dtp->dt_proc_env, p, sizeof (char *) * i); 418 dt_free(dtp, dtp->dt_proc_env); 419 dtp->dt_proc_env = p; 420 421 dtp->dt_proc_env[i - 1] = var; 422 dtp->dt_proc_env[i] = NULL; 423 } 424 425 return (0); 426 } 427 428 /*ARGSUSED*/ 429 static int 430 dt_opt_stdc(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 431 { 432 if (arg == NULL) 433 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 434 435 if (dtp->dt_pcb != NULL) 436 return (dt_set_errno(dtp, EDT_BADOPTCTX)); 437 438 if (strcmp(arg, "a") == 0) 439 dtp->dt_stdcmode = DT_STDC_XA; 440 else if (strcmp(arg, "c") == 0) 441 dtp->dt_stdcmode = DT_STDC_XC; 442 else if (strcmp(arg, "s") == 0) 443 dtp->dt_stdcmode = DT_STDC_XS; 444 else if (strcmp(arg, "t") == 0) 445 dtp->dt_stdcmode = DT_STDC_XT; 446 else 447 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 448 449 return (0); 450 } 451 452 /*ARGSUSED*/ 453 static int 454 dt_opt_syslibdir(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 455 { 456 dt_dirpath_t *dp = dt_list_next(&dtp->dt_lib_path); 457 char *path; 458 459 if (arg == NULL) 460 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 461 462 if ((path = strdup(arg)) == NULL) 463 return (dt_set_errno(dtp, EDT_NOMEM)); 464 465 free(dp->dir_path); 466 dp->dir_path = path; 467 468 return (0); 469 } 470 471 /*ARGSUSED*/ 472 static int 473 dt_opt_tree(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 474 { 475 int m; 476 477 if (arg == NULL || (m = atoi(arg)) <= 0) 478 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 479 480 dtp->dt_treedump = m; 481 return (0); 482 } 483 484 /*ARGSUSED*/ 485 static int 486 dt_opt_tregs(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 487 { 488 int n; 489 490 if (arg == NULL || (n = atoi(arg)) <= 0) 491 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 492 493 dtp->dt_conf.dtc_diftupregs = n; 494 return (0); 495 } 496 497 /*ARGSUSED*/ 498 static int 499 dt_opt_xlate(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 500 { 501 if (arg == NULL) 502 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 503 504 if (strcmp(arg, "dynamic") == 0) 505 dtp->dt_xlatemode = DT_XL_DYNAMIC; 506 else if (strcmp(arg, "static") == 0) 507 dtp->dt_xlatemode = DT_XL_STATIC; 508 else 509 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 510 511 return (0); 512 } 513 514 /*ARGSUSED*/ 515 static int 516 dt_opt_cflags(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 517 { 518 if (arg != NULL) 519 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 520 521 if (dtp->dt_pcb != NULL) 522 dtp->dt_pcb->pcb_cflags |= option; 523 else 524 dtp->dt_cflags |= option; 525 526 return (0); 527 } 528 529 static int 530 dt_opt_dflags(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 531 { 532 if (arg != NULL) 533 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 534 535 dtp->dt_dflags |= option; 536 return (0); 537 } 538 539 static int 540 dt_opt_invcflags(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 541 { 542 if (arg != NULL) 543 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 544 545 if (dtp->dt_pcb != NULL) 546 dtp->dt_pcb->pcb_cflags &= ~option; 547 else 548 dtp->dt_cflags &= ~option; 549 550 return (0); 551 } 552 553 /*ARGSUSED*/ 554 static int 555 dt_opt_version(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 556 { 557 dt_version_t v; 558 559 if (arg == NULL) 560 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 561 562 if (dt_version_str2num(arg, &v) == -1) 563 return (dt_set_errno(dtp, EDT_VERSINVAL)); 564 565 if (!dt_version_defined(v)) 566 return (dt_set_errno(dtp, EDT_VERSUNDEF)); 567 568 return (dt_reduce(dtp, v)); 569 } 570 571 static int 572 dt_opt_runtime(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 573 { 574 char *end; 575 dtrace_optval_t val = 0; 576 int i; 577 578 const struct { 579 char *positive; 580 char *negative; 581 } couples[] = { 582 { "yes", "no" }, 583 { "enable", "disable" }, 584 { "enabled", "disabled" }, 585 { "true", "false" }, 586 { "on", "off" }, 587 { "set", "unset" }, 588 { NULL } 589 }; 590 591 if (arg != NULL) { 592 if (arg[0] == '\0') { 593 val = DTRACEOPT_UNSET; 594 goto out; 595 } 596 597 for (i = 0; couples[i].positive != NULL; i++) { 598 if (strcasecmp(couples[i].positive, arg) == 0) { 599 val = 1; 600 goto out; 601 } 602 603 if (strcasecmp(couples[i].negative, arg) == 0) { 604 val = DTRACEOPT_UNSET; 605 goto out; 606 } 607 } 608 609 errno = 0; 610 val = strtoull(arg, &end, 0); 611 612 if (*end != '\0' || errno != 0 || val < 0) 613 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 614 } 615 616 out: 617 dtp->dt_options[option] = val; 618 return (0); 619 } 620 621 static int 622 dt_optval_parse(const char *arg, dtrace_optval_t *rval) 623 { 624 dtrace_optval_t mul = 1; 625 size_t len; 626 char *end; 627 628 len = strlen(arg); 629 errno = 0; 630 631 switch (arg[len - 1]) { 632 case 't': 633 case 'T': 634 mul *= 1024; 635 /*FALLTHRU*/ 636 case 'g': 637 case 'G': 638 mul *= 1024; 639 /*FALLTHRU*/ 640 case 'm': 641 case 'M': 642 mul *= 1024; 643 /*FALLTHRU*/ 644 case 'k': 645 case 'K': 646 mul *= 1024; 647 /*FALLTHRU*/ 648 default: 649 break; 650 } 651 652 errno = 0; 653 *rval = strtoull(arg, &end, 0) * mul; 654 655 if ((mul > 1 && end != &arg[len - 1]) || (mul == 1 && *end != '\0') || 656 *rval < 0 || errno != 0) 657 return (-1); 658 659 return (0); 660 } 661 662 static int 663 dt_opt_size(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 664 { 665 dtrace_optval_t val = 0; 666 667 if (arg != NULL && dt_optval_parse(arg, &val) != 0) 668 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 669 670 dtp->dt_options[option] = val; 671 return (0); 672 } 673 674 static int 675 dt_opt_rate(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 676 { 677 char *end; 678 int i; 679 dtrace_optval_t mul = 1, val = 0; 680 681 const struct { 682 char *name; 683 hrtime_t mul; 684 } suffix[] = { 685 { "ns", NANOSEC / NANOSEC }, 686 { "nsec", NANOSEC / NANOSEC }, 687 { "us", NANOSEC / MICROSEC }, 688 { "usec", NANOSEC / MICROSEC }, 689 { "ms", NANOSEC / MILLISEC }, 690 { "msec", NANOSEC / MILLISEC }, 691 { "s", NANOSEC / SEC }, 692 { "sec", NANOSEC / SEC }, 693 { "m", NANOSEC * (hrtime_t)60 }, 694 { "min", NANOSEC * (hrtime_t)60 }, 695 { "h", NANOSEC * (hrtime_t)60 * (hrtime_t)60 }, 696 { "hour", NANOSEC * (hrtime_t)60 * (hrtime_t)60 }, 697 { "d", NANOSEC * (hrtime_t)(24 * 60 * 60) }, 698 { "day", NANOSEC * (hrtime_t)(24 * 60 * 60) }, 699 { "hz", 0 }, 700 { NULL } 701 }; 702 703 if (arg != NULL) { 704 errno = 0; 705 val = strtoull(arg, &end, 0); 706 707 for (i = 0; suffix[i].name != NULL; i++) { 708 if (strcasecmp(suffix[i].name, end) == 0) { 709 mul = suffix[i].mul; 710 break; 711 } 712 } 713 714 if (suffix[i].name == NULL && *end != '\0' || val < 0) 715 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 716 717 if (mul == 0) { 718 /* 719 * The rate has been specified in frequency-per-second. 720 */ 721 if (val != 0) 722 val = NANOSEC / val; 723 } else { 724 val *= mul; 725 } 726 } 727 728 dtp->dt_options[option] = val; 729 return (0); 730 } 731 732 /* 733 * When setting the strsize option, set the option in the dt_options array 734 * using dt_opt_size() as usual, and then update the definition of the CTF 735 * type for the D intrinsic "string" to be an array of the corresponding size. 736 * If any errors occur, reset dt_options[option] to its previous value. 737 */ 738 static int 739 dt_opt_strsize(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 740 { 741 dtrace_optval_t val = dtp->dt_options[option]; 742 ctf_file_t *fp = DT_STR_CTFP(dtp); 743 ctf_id_t type = ctf_type_resolve(fp, DT_STR_TYPE(dtp)); 744 ctf_arinfo_t r; 745 746 if (dt_opt_size(dtp, arg, option) != 0) 747 return (-1); /* dt_errno is set for us */ 748 749 if (dtp->dt_options[option] > UINT_MAX) { 750 dtp->dt_options[option] = val; 751 return (dt_set_errno(dtp, EOVERFLOW)); 752 } 753 754 if (ctf_array_info(fp, type, &r) == CTF_ERR) { 755 dtp->dt_options[option] = val; 756 dtp->dt_ctferr = ctf_errno(fp); 757 return (dt_set_errno(dtp, EDT_CTF)); 758 } 759 760 r.ctr_nelems = (uint_t)dtp->dt_options[option]; 761 762 if (ctf_set_array(fp, type, &r) == CTF_ERR || 763 ctf_update(fp) == CTF_ERR) { 764 dtp->dt_options[option] = val; 765 dtp->dt_ctferr = ctf_errno(fp); 766 return (dt_set_errno(dtp, EDT_CTF)); 767 } 768 769 return (0); 770 } 771 772 static const struct { 773 const char *dtbp_name; 774 int dtbp_policy; 775 } _dtrace_bufpolicies[] = { 776 { "ring", DTRACEOPT_BUFPOLICY_RING }, 777 { "fill", DTRACEOPT_BUFPOLICY_FILL }, 778 { "switch", DTRACEOPT_BUFPOLICY_SWITCH }, 779 { NULL, 0 } 780 }; 781 782 /*ARGSUSED*/ 783 static int 784 dt_opt_bufpolicy(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 785 { 786 dtrace_optval_t policy = DTRACEOPT_UNSET; 787 int i; 788 789 if (arg == NULL) 790 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 791 792 for (i = 0; _dtrace_bufpolicies[i].dtbp_name != NULL; i++) { 793 if (strcmp(_dtrace_bufpolicies[i].dtbp_name, arg) == 0) { 794 policy = _dtrace_bufpolicies[i].dtbp_policy; 795 break; 796 } 797 } 798 799 if (policy == DTRACEOPT_UNSET) 800 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 801 802 dtp->dt_options[DTRACEOPT_BUFPOLICY] = policy; 803 804 return (0); 805 } 806 807 static const struct { 808 const char *dtbr_name; 809 int dtbr_policy; 810 } _dtrace_bufresize[] = { 811 { "auto", DTRACEOPT_BUFRESIZE_AUTO }, 812 { "manual", DTRACEOPT_BUFRESIZE_MANUAL }, 813 { NULL, 0 } 814 }; 815 816 /*ARGSUSED*/ 817 static int 818 dt_opt_bufresize(dtrace_hdl_t *dtp, const char *arg, uintptr_t option) 819 { 820 dtrace_optval_t policy = DTRACEOPT_UNSET; 821 int i; 822 823 if (arg == NULL) 824 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 825 826 for (i = 0; _dtrace_bufresize[i].dtbr_name != NULL; i++) { 827 if (strcmp(_dtrace_bufresize[i].dtbr_name, arg) == 0) { 828 policy = _dtrace_bufresize[i].dtbr_policy; 829 break; 830 } 831 } 832 833 if (policy == DTRACEOPT_UNSET) 834 return (dt_set_errno(dtp, EDT_BADOPTVAL)); 835 836 dtp->dt_options[DTRACEOPT_BUFRESIZE] = policy; 837 838 return (0); 839 } 840 841 int 842 dt_options_load(dtrace_hdl_t *dtp) 843 { 844 dof_hdr_t hdr, *dof; 845 dof_sec_t *sec; 846 size_t offs; 847 int i; 848 849 /* 850 * To load the option values, we need to ask the kernel to provide its 851 * DOF, which we'll sift through to look for OPTDESC sections. 852 */ 853 bzero(&hdr, sizeof (dof_hdr_t)); 854 hdr.dofh_loadsz = sizeof (dof_hdr_t); 855 856 #if defined(sun) 857 if (dt_ioctl(dtp, DTRACEIOC_DOFGET, &hdr) == -1) 858 #else 859 dof = &hdr; 860 if (dt_ioctl(dtp, DTRACEIOC_DOFGET, &dof) == -1) 861 #endif 862 return (dt_set_errno(dtp, errno)); 863 864 if (hdr.dofh_loadsz < sizeof (dof_hdr_t)) 865 return (dt_set_errno(dtp, EINVAL)); 866 867 dof = alloca(hdr.dofh_loadsz); 868 bzero(dof, sizeof (dof_hdr_t)); 869 dof->dofh_loadsz = hdr.dofh_loadsz; 870 871 for (i = 0; i < DTRACEOPT_MAX; i++) 872 dtp->dt_options[i] = DTRACEOPT_UNSET; 873 874 #if defined(sun) 875 if (dt_ioctl(dtp, DTRACEIOC_DOFGET, dof) == -1) 876 #else 877 if (dt_ioctl(dtp, DTRACEIOC_DOFGET, &dof) == -1) 878 #endif 879 return (dt_set_errno(dtp, errno)); 880 881 for (i = 0; i < dof->dofh_secnum; i++) { 882 sec = (dof_sec_t *)(uintptr_t)((uintptr_t)dof + 883 dof->dofh_secoff + i * dof->dofh_secsize); 884 885 if (sec->dofs_type != DOF_SECT_OPTDESC) 886 continue; 887 888 break; 889 } 890 891 for (offs = 0; offs < sec->dofs_size; offs += sec->dofs_entsize) { 892 dof_optdesc_t *opt = (dof_optdesc_t *)(uintptr_t) 893 ((uintptr_t)dof + sec->dofs_offset + offs); 894 895 if (opt->dofo_strtab != DOF_SECIDX_NONE) 896 continue; 897 898 if (opt->dofo_option >= DTRACEOPT_MAX) 899 continue; 900 901 dtp->dt_options[opt->dofo_option] = opt->dofo_value; 902 } 903 904 return (0); 905 } 906 907 typedef struct dt_option { 908 const char *o_name; 909 int (*o_func)(dtrace_hdl_t *, const char *, uintptr_t); 910 uintptr_t o_option; 911 } dt_option_t; 912 913 /* 914 * Compile-time options. 915 */ 916 static const dt_option_t _dtrace_ctoptions[] = { 917 { "aggpercpu", dt_opt_agg, DTRACE_A_PERCPU }, 918 { "amin", dt_opt_amin }, 919 { "argref", dt_opt_cflags, DTRACE_C_ARGREF }, 920 { "core", dt_opt_core }, 921 { "cpp", dt_opt_cflags, DTRACE_C_CPP }, 922 { "cpphdrs", dt_opt_cpp_hdrs }, 923 { "cpppath", dt_opt_cpp_path }, 924 { "ctypes", dt_opt_ctypes }, 925 { "defaultargs", dt_opt_cflags, DTRACE_C_DEFARG }, 926 { "dtypes", dt_opt_dtypes }, 927 { "debug", dt_opt_debug }, 928 { "define", dt_opt_cpp_opts, (uintptr_t)"-D" }, 929 { "droptags", dt_opt_droptags }, 930 { "empty", dt_opt_cflags, DTRACE_C_EMPTY }, 931 { "errtags", dt_opt_cflags, DTRACE_C_ETAGS }, 932 { "evaltime", dt_opt_evaltime }, 933 { "incdir", dt_opt_cpp_opts, (uintptr_t)"-I" }, 934 { "iregs", dt_opt_iregs }, 935 { "kdefs", dt_opt_invcflags, DTRACE_C_KNODEF }, 936 { "knodefs", dt_opt_cflags, DTRACE_C_KNODEF }, 937 { "late", dt_opt_xlate }, 938 { "lazyload", dt_opt_lazyload }, 939 { "ldpath", dt_opt_ld_path }, 940 { "libdir", dt_opt_libdir }, 941 { "linkmode", dt_opt_linkmode }, 942 { "linktype", dt_opt_linktype }, 943 { "nolibs", dt_opt_cflags, DTRACE_C_NOLIBS }, 944 { "pgmax", dt_opt_pgmax }, 945 { "pspec", dt_opt_cflags, DTRACE_C_PSPEC }, 946 { "setenv", dt_opt_setenv, 1 }, 947 { "stdc", dt_opt_stdc }, 948 { "strip", dt_opt_dflags, DTRACE_D_STRIP }, 949 { "syslibdir", dt_opt_syslibdir }, 950 { "tree", dt_opt_tree }, 951 { "tregs", dt_opt_tregs }, 952 { "udefs", dt_opt_invcflags, DTRACE_C_UNODEF }, 953 { "undef", dt_opt_cpp_opts, (uintptr_t)"-U" }, 954 { "unodefs", dt_opt_cflags, DTRACE_C_UNODEF }, 955 { "unsetenv", dt_opt_setenv, 0 }, 956 { "verbose", dt_opt_cflags, DTRACE_C_DIFV }, 957 { "version", dt_opt_version }, 958 { "zdefs", dt_opt_cflags, DTRACE_C_ZDEFS }, 959 { NULL, NULL, 0 } 960 }; 961 962 /* 963 * Run-time options. 964 */ 965 static const dt_option_t _dtrace_rtoptions[] = { 966 { "aggsize", dt_opt_size, DTRACEOPT_AGGSIZE }, 967 { "bufsize", dt_opt_size, DTRACEOPT_BUFSIZE }, 968 { "bufpolicy", dt_opt_bufpolicy, DTRACEOPT_BUFPOLICY }, 969 { "bufresize", dt_opt_bufresize, DTRACEOPT_BUFRESIZE }, 970 { "cleanrate", dt_opt_rate, DTRACEOPT_CLEANRATE }, 971 { "cpu", dt_opt_runtime, DTRACEOPT_CPU }, 972 { "destructive", dt_opt_runtime, DTRACEOPT_DESTRUCTIVE }, 973 { "dynvarsize", dt_opt_size, DTRACEOPT_DYNVARSIZE }, 974 { "grabanon", dt_opt_runtime, DTRACEOPT_GRABANON }, 975 { "jstackframes", dt_opt_runtime, DTRACEOPT_JSTACKFRAMES }, 976 { "jstackstrsize", dt_opt_size, DTRACEOPT_JSTACKSTRSIZE }, 977 { "nspec", dt_opt_runtime, DTRACEOPT_NSPEC }, 978 { "specsize", dt_opt_size, DTRACEOPT_SPECSIZE }, 979 { "stackframes", dt_opt_runtime, DTRACEOPT_STACKFRAMES }, 980 { "statusrate", dt_opt_rate, DTRACEOPT_STATUSRATE }, 981 { "strsize", dt_opt_strsize, DTRACEOPT_STRSIZE }, 982 { "ustackframes", dt_opt_runtime, DTRACEOPT_USTACKFRAMES }, 983 { "temporal", dt_opt_runtime, DTRACEOPT_TEMPORAL }, 984 { NULL, NULL, 0 } 985 }; 986 987 /* 988 * Dynamic run-time options. 989 */ 990 static const dt_option_t _dtrace_drtoptions[] = { 991 { "aggrate", dt_opt_rate, DTRACEOPT_AGGRATE }, 992 { "aggsortkey", dt_opt_runtime, DTRACEOPT_AGGSORTKEY }, 993 { "aggsortkeypos", dt_opt_runtime, DTRACEOPT_AGGSORTKEYPOS }, 994 { "aggsortpos", dt_opt_runtime, DTRACEOPT_AGGSORTPOS }, 995 { "aggsortrev", dt_opt_runtime, DTRACEOPT_AGGSORTREV }, 996 { "flowindent", dt_opt_runtime, DTRACEOPT_FLOWINDENT }, 997 { "quiet", dt_opt_runtime, DTRACEOPT_QUIET }, 998 { "rawbytes", dt_opt_runtime, DTRACEOPT_RAWBYTES }, 999 { "stackindent", dt_opt_runtime, DTRACEOPT_STACKINDENT }, 1000 { "switchrate", dt_opt_rate, DTRACEOPT_SWITCHRATE }, 1001 { NULL, NULL, 0 } 1002 }; 1003 1004 int 1005 dtrace_getopt(dtrace_hdl_t *dtp, const char *opt, dtrace_optval_t *val) 1006 { 1007 const dt_option_t *op; 1008 1009 if (opt == NULL) 1010 return (dt_set_errno(dtp, EINVAL)); 1011 1012 /* 1013 * We only need to search the run-time options -- it's not legal 1014 * to get the values of compile-time options. 1015 */ 1016 for (op = _dtrace_rtoptions; op->o_name != NULL; op++) { 1017 if (strcmp(op->o_name, opt) == 0) { 1018 *val = dtp->dt_options[op->o_option]; 1019 return (0); 1020 } 1021 } 1022 1023 for (op = _dtrace_drtoptions; op->o_name != NULL; op++) { 1024 if (strcmp(op->o_name, opt) == 0) { 1025 *val = dtp->dt_options[op->o_option]; 1026 return (0); 1027 } 1028 } 1029 1030 return (dt_set_errno(dtp, EDT_BADOPTNAME)); 1031 } 1032 1033 int 1034 dtrace_setopt(dtrace_hdl_t *dtp, const char *opt, const char *val) 1035 { 1036 const dt_option_t *op; 1037 1038 if (opt == NULL) 1039 return (dt_set_errno(dtp, EINVAL)); 1040 1041 for (op = _dtrace_ctoptions; op->o_name != NULL; op++) { 1042 if (strcmp(op->o_name, opt) == 0) 1043 return (op->o_func(dtp, val, op->o_option)); 1044 } 1045 1046 for (op = _dtrace_drtoptions; op->o_name != NULL; op++) { 1047 if (strcmp(op->o_name, opt) == 0) 1048 return (op->o_func(dtp, val, op->o_option)); 1049 } 1050 1051 for (op = _dtrace_rtoptions; op->o_name != NULL; op++) { 1052 if (strcmp(op->o_name, opt) == 0) { 1053 /* 1054 * Only dynamic run-time options may be set while 1055 * tracing is active. 1056 */ 1057 if (dtp->dt_active) 1058 return (dt_set_errno(dtp, EDT_ACTIVE)); 1059 1060 return (op->o_func(dtp, val, op->o_option)); 1061 } 1062 } 1063 1064 return (dt_set_errno(dtp, EDT_BADOPTNAME)); 1065 } 1066