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 * $FreeBSD$ 22 * 23 */ 24 25 static int dtrace_verbose_ioctl; 26 SYSCTL_INT(_debug_dtrace, OID_AUTO, verbose_ioctl, CTLFLAG_RW, &dtrace_verbose_ioctl, 0, ""); 27 28 #define DTRACE_IOCTL_PRINTF(fmt, ...) if (dtrace_verbose_ioctl) printf(fmt, ## __VA_ARGS__ ) 29 30 static int 31 dtrace_ioctl_helper(struct cdev *dev, u_long cmd, caddr_t addr, int flags, 32 struct thread *td) 33 { 34 int rval; 35 dof_helper_t *dhp = NULL; 36 dof_hdr_t *dof = NULL; 37 38 switch (cmd) { 39 case DTRACEHIOC_ADDDOF: 40 dhp = (dof_helper_t *)addr; 41 /* XXX all because dofhp_dof is 64 bit */ 42 #ifdef __i386 43 addr = (caddr_t)(uint32_t)dhp->dofhp_dof; 44 #else 45 addr = (caddr_t)dhp->dofhp_dof; 46 #endif 47 /* FALLTHROUGH */ 48 case DTRACEHIOC_ADD: 49 dof = dtrace_dof_copyin((intptr_t)addr, &rval); 50 51 if (dof == NULL) 52 return (rval); 53 54 mutex_enter(&dtrace_lock); 55 if ((rval = dtrace_helper_slurp((dof_hdr_t *)dof, dhp)) != -1) { 56 if (dhp) { 57 dhp->gen = rval; 58 copyout(dhp, addr, sizeof(*dhp)); 59 } 60 rval = 0; 61 } else { 62 rval = EINVAL; 63 } 64 mutex_exit(&dtrace_lock); 65 return (rval); 66 case DTRACEHIOC_REMOVE: 67 mutex_enter(&dtrace_lock); 68 rval = dtrace_helper_destroygen((int)*addr); 69 mutex_exit(&dtrace_lock); 70 71 return (rval); 72 default: 73 break; 74 } 75 76 return (ENOTTY); 77 } 78 79 /* ARGSUSED */ 80 static int 81 dtrace_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, 82 int flags __unused, struct thread *td) 83 { 84 #if __FreeBSD_version < 800039 85 dtrace_state_t *state = dev->si_drv1; 86 #else 87 dtrace_state_t *state; 88 devfs_get_cdevpriv((void **) &state); 89 #endif 90 int error = 0; 91 if (state == NULL) 92 return (EINVAL); 93 94 if (state->dts_anon) { 95 ASSERT(dtrace_anon.dta_state == NULL); 96 state = state->dts_anon; 97 } 98 99 switch (cmd) { 100 case DTRACEIOC_AGGDESC: { 101 dtrace_aggdesc_t **paggdesc = (dtrace_aggdesc_t **) addr; 102 dtrace_aggdesc_t aggdesc; 103 dtrace_action_t *act; 104 dtrace_aggregation_t *agg; 105 int nrecs; 106 uint32_t offs; 107 dtrace_recdesc_t *lrec; 108 void *buf; 109 size_t size; 110 uintptr_t dest; 111 112 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_AGGDESC\n",__func__,__LINE__); 113 114 if (copyin((void *) *paggdesc, &aggdesc, sizeof (aggdesc)) != 0) 115 return (EFAULT); 116 117 mutex_enter(&dtrace_lock); 118 119 if ((agg = dtrace_aggid2agg(state, aggdesc.dtagd_id)) == NULL) { 120 mutex_exit(&dtrace_lock); 121 return (EINVAL); 122 } 123 124 aggdesc.dtagd_epid = agg->dtag_ecb->dte_epid; 125 126 nrecs = aggdesc.dtagd_nrecs; 127 aggdesc.dtagd_nrecs = 0; 128 129 offs = agg->dtag_base; 130 lrec = &agg->dtag_action.dta_rec; 131 aggdesc.dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - offs; 132 133 for (act = agg->dtag_first; ; act = act->dta_next) { 134 ASSERT(act->dta_intuple || 135 DTRACEACT_ISAGG(act->dta_kind)); 136 137 /* 138 * If this action has a record size of zero, it 139 * denotes an argument to the aggregating action. 140 * Because the presence of this record doesn't (or 141 * shouldn't) affect the way the data is interpreted, 142 * we don't copy it out to save user-level the 143 * confusion of dealing with a zero-length record. 144 */ 145 if (act->dta_rec.dtrd_size == 0) { 146 ASSERT(agg->dtag_hasarg); 147 continue; 148 } 149 150 aggdesc.dtagd_nrecs++; 151 152 if (act == &agg->dtag_action) 153 break; 154 } 155 156 /* 157 * Now that we have the size, we need to allocate a temporary 158 * buffer in which to store the complete description. We need 159 * the temporary buffer to be able to drop dtrace_lock() 160 * across the copyout(), below. 161 */ 162 size = sizeof (dtrace_aggdesc_t) + 163 (aggdesc.dtagd_nrecs * sizeof (dtrace_recdesc_t)); 164 165 buf = kmem_alloc(size, KM_SLEEP); 166 dest = (uintptr_t)buf; 167 168 bcopy(&aggdesc, (void *)dest, sizeof (aggdesc)); 169 dest += offsetof(dtrace_aggdesc_t, dtagd_rec[0]); 170 171 for (act = agg->dtag_first; ; act = act->dta_next) { 172 dtrace_recdesc_t rec = act->dta_rec; 173 174 /* 175 * See the comment in the above loop for why we pass 176 * over zero-length records. 177 */ 178 if (rec.dtrd_size == 0) { 179 ASSERT(agg->dtag_hasarg); 180 continue; 181 } 182 183 if (nrecs-- == 0) 184 break; 185 186 rec.dtrd_offset -= offs; 187 bcopy(&rec, (void *)dest, sizeof (rec)); 188 dest += sizeof (dtrace_recdesc_t); 189 190 if (act == &agg->dtag_action) 191 break; 192 } 193 194 mutex_exit(&dtrace_lock); 195 196 if (copyout(buf, (void *) *paggdesc, dest - (uintptr_t)buf) != 0) { 197 kmem_free(buf, size); 198 return (EFAULT); 199 } 200 201 kmem_free(buf, size); 202 return (0); 203 } 204 case DTRACEIOC_AGGSNAP: 205 case DTRACEIOC_BUFSNAP: { 206 dtrace_bufdesc_t **pdesc = (dtrace_bufdesc_t **) addr; 207 dtrace_bufdesc_t desc; 208 caddr_t cached; 209 dtrace_buffer_t *buf; 210 211 dtrace_debug_output(); 212 213 if (copyin((void *) *pdesc, &desc, sizeof (desc)) != 0) 214 return (EFAULT); 215 216 DTRACE_IOCTL_PRINTF("%s(%d): %s curcpu %d cpu %d\n", 217 __func__,__LINE__, 218 cmd == DTRACEIOC_AGGSNAP ? 219 "DTRACEIOC_AGGSNAP":"DTRACEIOC_BUFSNAP", 220 curcpu, desc.dtbd_cpu); 221 222 if (desc.dtbd_cpu < 0 || desc.dtbd_cpu >= NCPU) 223 return (ENOENT); 224 if (pcpu_find(desc.dtbd_cpu) == NULL) 225 return (ENOENT); 226 227 mutex_enter(&dtrace_lock); 228 229 if (cmd == DTRACEIOC_BUFSNAP) { 230 buf = &state->dts_buffer[desc.dtbd_cpu]; 231 } else { 232 buf = &state->dts_aggbuffer[desc.dtbd_cpu]; 233 } 234 235 if (buf->dtb_flags & (DTRACEBUF_RING | DTRACEBUF_FILL)) { 236 size_t sz = buf->dtb_offset; 237 238 if (state->dts_activity != DTRACE_ACTIVITY_STOPPED) { 239 mutex_exit(&dtrace_lock); 240 return (EBUSY); 241 } 242 243 /* 244 * If this buffer has already been consumed, we're 245 * going to indicate that there's nothing left here 246 * to consume. 247 */ 248 if (buf->dtb_flags & DTRACEBUF_CONSUMED) { 249 mutex_exit(&dtrace_lock); 250 251 desc.dtbd_size = 0; 252 desc.dtbd_drops = 0; 253 desc.dtbd_errors = 0; 254 desc.dtbd_oldest = 0; 255 sz = sizeof (desc); 256 257 if (copyout(&desc, (void *) *pdesc, sz) != 0) 258 return (EFAULT); 259 260 return (0); 261 } 262 263 /* 264 * If this is a ring buffer that has wrapped, we want 265 * to copy the whole thing out. 266 */ 267 if (buf->dtb_flags & DTRACEBUF_WRAPPED) { 268 dtrace_buffer_polish(buf); 269 sz = buf->dtb_size; 270 } 271 272 if (copyout(buf->dtb_tomax, desc.dtbd_data, sz) != 0) { 273 mutex_exit(&dtrace_lock); 274 return (EFAULT); 275 } 276 277 desc.dtbd_size = sz; 278 desc.dtbd_drops = buf->dtb_drops; 279 desc.dtbd_errors = buf->dtb_errors; 280 desc.dtbd_oldest = buf->dtb_xamot_offset; 281 282 mutex_exit(&dtrace_lock); 283 284 if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 285 return (EFAULT); 286 287 buf->dtb_flags |= DTRACEBUF_CONSUMED; 288 289 return (0); 290 } 291 292 if (buf->dtb_tomax == NULL) { 293 ASSERT(buf->dtb_xamot == NULL); 294 mutex_exit(&dtrace_lock); 295 return (ENOENT); 296 } 297 298 cached = buf->dtb_tomax; 299 ASSERT(!(buf->dtb_flags & DTRACEBUF_NOSWITCH)); 300 301 dtrace_xcall(desc.dtbd_cpu, 302 (dtrace_xcall_t)dtrace_buffer_switch, buf); 303 304 state->dts_errors += buf->dtb_xamot_errors; 305 306 /* 307 * If the buffers did not actually switch, then the cross call 308 * did not take place -- presumably because the given CPU is 309 * not in the ready set. If this is the case, we'll return 310 * ENOENT. 311 */ 312 if (buf->dtb_tomax == cached) { 313 ASSERT(buf->dtb_xamot != cached); 314 mutex_exit(&dtrace_lock); 315 return (ENOENT); 316 } 317 318 ASSERT(cached == buf->dtb_xamot); 319 320 DTRACE_IOCTL_PRINTF("%s(%d): copyout the buffer snapshot\n",__func__,__LINE__); 321 322 /* 323 * We have our snapshot; now copy it out. 324 */ 325 if (copyout(buf->dtb_xamot, desc.dtbd_data, 326 buf->dtb_xamot_offset) != 0) { 327 mutex_exit(&dtrace_lock); 328 return (EFAULT); 329 } 330 331 desc.dtbd_size = buf->dtb_xamot_offset; 332 desc.dtbd_drops = buf->dtb_xamot_drops; 333 desc.dtbd_errors = buf->dtb_xamot_errors; 334 desc.dtbd_oldest = 0; 335 336 mutex_exit(&dtrace_lock); 337 338 DTRACE_IOCTL_PRINTF("%s(%d): copyout buffer desc: size %zd drops %lu errors %lu\n",__func__,__LINE__,(size_t) desc.dtbd_size,(u_long) desc.dtbd_drops,(u_long) desc.dtbd_errors); 339 340 /* 341 * Finally, copy out the buffer description. 342 */ 343 if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 344 return (EFAULT); 345 346 return (0); 347 } 348 case DTRACEIOC_CONF: { 349 dtrace_conf_t conf; 350 351 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_CONF\n",__func__,__LINE__); 352 353 bzero(&conf, sizeof (conf)); 354 conf.dtc_difversion = DIF_VERSION; 355 conf.dtc_difintregs = DIF_DIR_NREGS; 356 conf.dtc_diftupregs = DIF_DTR_NREGS; 357 conf.dtc_ctfmodel = CTF_MODEL_NATIVE; 358 359 *((dtrace_conf_t *) addr) = conf; 360 361 return (0); 362 } 363 case DTRACEIOC_DOFGET: { 364 dof_hdr_t **pdof = (dof_hdr_t **) addr; 365 dof_hdr_t hdr, *dof = *pdof; 366 int rval; 367 uint64_t len; 368 369 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_DOFGET\n",__func__,__LINE__); 370 371 if (copyin((void *)dof, &hdr, sizeof (hdr)) != 0) 372 return (EFAULT); 373 374 mutex_enter(&dtrace_lock); 375 dof = dtrace_dof_create(state); 376 mutex_exit(&dtrace_lock); 377 378 len = MIN(hdr.dofh_loadsz, dof->dofh_loadsz); 379 rval = copyout(dof, (void *) *pdof, len); 380 dtrace_dof_destroy(dof); 381 382 return (rval == 0 ? 0 : EFAULT); 383 } 384 case DTRACEIOC_ENABLE: { 385 dof_hdr_t *dof = NULL; 386 dtrace_enabling_t *enab = NULL; 387 dtrace_vstate_t *vstate; 388 int err = 0; 389 int rval; 390 dtrace_enable_io_t *p = (dtrace_enable_io_t *) addr; 391 392 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_ENABLE\n",__func__,__LINE__); 393 394 /* 395 * If a NULL argument has been passed, we take this as our 396 * cue to reevaluate our enablings. 397 */ 398 if (p->dof == NULL) { 399 dtrace_enabling_matchall(); 400 401 return (0); 402 } 403 404 if ((dof = dtrace_dof_copyin((uintptr_t) p->dof, &rval)) == NULL) 405 return (EINVAL); 406 407 mutex_enter(&cpu_lock); 408 mutex_enter(&dtrace_lock); 409 vstate = &state->dts_vstate; 410 411 if (state->dts_activity != DTRACE_ACTIVITY_INACTIVE) { 412 mutex_exit(&dtrace_lock); 413 mutex_exit(&cpu_lock); 414 dtrace_dof_destroy(dof); 415 return (EBUSY); 416 } 417 418 if (dtrace_dof_slurp(dof, vstate, td->td_ucred, &enab, 0, B_TRUE) != 0) { 419 mutex_exit(&dtrace_lock); 420 mutex_exit(&cpu_lock); 421 dtrace_dof_destroy(dof); 422 return (EINVAL); 423 } 424 425 if ((rval = dtrace_dof_options(dof, state)) != 0) { 426 dtrace_enabling_destroy(enab); 427 mutex_exit(&dtrace_lock); 428 mutex_exit(&cpu_lock); 429 dtrace_dof_destroy(dof); 430 return (rval); 431 } 432 433 if ((err = dtrace_enabling_match(enab, &p->n_matched)) == 0) { 434 err = dtrace_enabling_retain(enab); 435 } else { 436 dtrace_enabling_destroy(enab); 437 } 438 439 mutex_exit(&cpu_lock); 440 mutex_exit(&dtrace_lock); 441 dtrace_dof_destroy(dof); 442 443 return (err); 444 } 445 case DTRACEIOC_EPROBE: { 446 dtrace_eprobedesc_t **pepdesc = (dtrace_eprobedesc_t **) addr; 447 dtrace_eprobedesc_t epdesc; 448 dtrace_ecb_t *ecb; 449 dtrace_action_t *act; 450 void *buf; 451 size_t size; 452 uintptr_t dest; 453 int nrecs; 454 455 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_EPROBE\n",__func__,__LINE__); 456 457 if (copyin((void *)*pepdesc, &epdesc, sizeof (epdesc)) != 0) 458 return (EFAULT); 459 460 mutex_enter(&dtrace_lock); 461 462 if ((ecb = dtrace_epid2ecb(state, epdesc.dtepd_epid)) == NULL) { 463 mutex_exit(&dtrace_lock); 464 return (EINVAL); 465 } 466 467 if (ecb->dte_probe == NULL) { 468 mutex_exit(&dtrace_lock); 469 return (EINVAL); 470 } 471 472 epdesc.dtepd_probeid = ecb->dte_probe->dtpr_id; 473 epdesc.dtepd_uarg = ecb->dte_uarg; 474 epdesc.dtepd_size = ecb->dte_size; 475 476 nrecs = epdesc.dtepd_nrecs; 477 epdesc.dtepd_nrecs = 0; 478 for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 479 if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 480 continue; 481 482 epdesc.dtepd_nrecs++; 483 } 484 485 /* 486 * Now that we have the size, we need to allocate a temporary 487 * buffer in which to store the complete description. We need 488 * the temporary buffer to be able to drop dtrace_lock() 489 * across the copyout(), below. 490 */ 491 size = sizeof (dtrace_eprobedesc_t) + 492 (epdesc.dtepd_nrecs * sizeof (dtrace_recdesc_t)); 493 494 buf = kmem_alloc(size, KM_SLEEP); 495 dest = (uintptr_t)buf; 496 497 bcopy(&epdesc, (void *)dest, sizeof (epdesc)); 498 dest += offsetof(dtrace_eprobedesc_t, dtepd_rec[0]); 499 500 for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 501 if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 502 continue; 503 504 if (nrecs-- == 0) 505 break; 506 507 bcopy(&act->dta_rec, (void *)dest, 508 sizeof (dtrace_recdesc_t)); 509 dest += sizeof (dtrace_recdesc_t); 510 } 511 512 mutex_exit(&dtrace_lock); 513 514 if (copyout(buf, (void *) *pepdesc, dest - (uintptr_t)buf) != 0) { 515 kmem_free(buf, size); 516 return (EFAULT); 517 } 518 519 kmem_free(buf, size); 520 return (0); 521 } 522 case DTRACEIOC_FORMAT: { 523 dtrace_fmtdesc_t *fmt = (dtrace_fmtdesc_t *) addr; 524 char *str; 525 int len; 526 527 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_FORMAT\n",__func__,__LINE__); 528 529 mutex_enter(&dtrace_lock); 530 531 if (fmt->dtfd_format == 0 || 532 fmt->dtfd_format > state->dts_nformats) { 533 mutex_exit(&dtrace_lock); 534 return (EINVAL); 535 } 536 537 /* 538 * Format strings are allocated contiguously and they are 539 * never freed; if a format index is less than the number 540 * of formats, we can assert that the format map is non-NULL 541 * and that the format for the specified index is non-NULL. 542 */ 543 ASSERT(state->dts_formats != NULL); 544 str = state->dts_formats[fmt->dtfd_format - 1]; 545 ASSERT(str != NULL); 546 547 len = strlen(str) + 1; 548 549 if (len > fmt->dtfd_length) { 550 fmt->dtfd_length = len; 551 } else { 552 if (copyout(str, fmt->dtfd_string, len) != 0) { 553 mutex_exit(&dtrace_lock); 554 return (EINVAL); 555 } 556 } 557 558 mutex_exit(&dtrace_lock); 559 return (0); 560 } 561 case DTRACEIOC_GO: { 562 int rval; 563 processorid_t *cpuid = (processorid_t *) addr; 564 565 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_GO\n",__func__,__LINE__); 566 567 rval = dtrace_state_go(state, cpuid); 568 569 return (rval); 570 } 571 case DTRACEIOC_PROBEARG: { 572 dtrace_argdesc_t *desc = (dtrace_argdesc_t *) addr; 573 dtrace_probe_t *probe; 574 dtrace_provider_t *prov; 575 576 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROBEARG\n",__func__,__LINE__); 577 578 if (desc->dtargd_id == DTRACE_IDNONE) 579 return (EINVAL); 580 581 if (desc->dtargd_ndx == DTRACE_ARGNONE) 582 return (EINVAL); 583 584 mutex_enter(&dtrace_provider_lock); 585 mutex_enter(&mod_lock); 586 mutex_enter(&dtrace_lock); 587 588 if (desc->dtargd_id > dtrace_nprobes) { 589 mutex_exit(&dtrace_lock); 590 mutex_exit(&mod_lock); 591 mutex_exit(&dtrace_provider_lock); 592 return (EINVAL); 593 } 594 595 if ((probe = dtrace_probes[desc->dtargd_id - 1]) == NULL) { 596 mutex_exit(&dtrace_lock); 597 mutex_exit(&mod_lock); 598 mutex_exit(&dtrace_provider_lock); 599 return (EINVAL); 600 } 601 602 mutex_exit(&dtrace_lock); 603 604 prov = probe->dtpr_provider; 605 606 if (prov->dtpv_pops.dtps_getargdesc == NULL) { 607 /* 608 * There isn't any typed information for this probe. 609 * Set the argument number to DTRACE_ARGNONE. 610 */ 611 desc->dtargd_ndx = DTRACE_ARGNONE; 612 } else { 613 desc->dtargd_native[0] = '\0'; 614 desc->dtargd_xlate[0] = '\0'; 615 desc->dtargd_mapping = desc->dtargd_ndx; 616 617 prov->dtpv_pops.dtps_getargdesc(prov->dtpv_arg, 618 probe->dtpr_id, probe->dtpr_arg, desc); 619 } 620 621 mutex_exit(&mod_lock); 622 mutex_exit(&dtrace_provider_lock); 623 624 return (0); 625 } 626 case DTRACEIOC_PROBEMATCH: 627 case DTRACEIOC_PROBES: { 628 dtrace_probedesc_t *p_desc = (dtrace_probedesc_t *) addr; 629 dtrace_probe_t *probe = NULL; 630 dtrace_probekey_t pkey; 631 dtrace_id_t i; 632 int m = 0; 633 uint32_t priv = 0; 634 uid_t uid = 0; 635 zoneid_t zoneid = 0; 636 637 DTRACE_IOCTL_PRINTF("%s(%d): %s\n",__func__,__LINE__, 638 cmd == DTRACEIOC_PROBEMATCH ? 639 "DTRACEIOC_PROBEMATCH":"DTRACEIOC_PROBES"); 640 641 p_desc->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 642 p_desc->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 643 p_desc->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 644 p_desc->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 645 646 /* 647 * Before we attempt to match this probe, we want to give 648 * all providers the opportunity to provide it. 649 */ 650 if (p_desc->dtpd_id == DTRACE_IDNONE) { 651 mutex_enter(&dtrace_provider_lock); 652 dtrace_probe_provide(p_desc, NULL); 653 mutex_exit(&dtrace_provider_lock); 654 p_desc->dtpd_id++; 655 } 656 657 if (cmd == DTRACEIOC_PROBEMATCH) { 658 dtrace_probekey(p_desc, &pkey); 659 pkey.dtpk_id = DTRACE_IDNONE; 660 } 661 662 dtrace_cred2priv(td->td_ucred, &priv, &uid, &zoneid); 663 664 mutex_enter(&dtrace_lock); 665 666 if (cmd == DTRACEIOC_PROBEMATCH) { 667 for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 668 if ((probe = dtrace_probes[i - 1]) != NULL && 669 (m = dtrace_match_probe(probe, &pkey, 670 priv, uid, zoneid)) != 0) 671 break; 672 } 673 674 if (m < 0) { 675 mutex_exit(&dtrace_lock); 676 return (EINVAL); 677 } 678 679 } else { 680 for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 681 if ((probe = dtrace_probes[i - 1]) != NULL && 682 dtrace_match_priv(probe, priv, uid, zoneid)) 683 break; 684 } 685 } 686 687 if (probe == NULL) { 688 mutex_exit(&dtrace_lock); 689 return (ESRCH); 690 } 691 692 dtrace_probe_description(probe, p_desc); 693 mutex_exit(&dtrace_lock); 694 695 return (0); 696 } 697 case DTRACEIOC_PROVIDER: { 698 dtrace_providerdesc_t *pvd = (dtrace_providerdesc_t *) addr; 699 dtrace_provider_t *pvp; 700 701 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROVIDER\n",__func__,__LINE__); 702 703 pvd->dtvd_name[DTRACE_PROVNAMELEN - 1] = '\0'; 704 mutex_enter(&dtrace_provider_lock); 705 706 for (pvp = dtrace_provider; pvp != NULL; pvp = pvp->dtpv_next) { 707 if (strcmp(pvp->dtpv_name, pvd->dtvd_name) == 0) 708 break; 709 } 710 711 mutex_exit(&dtrace_provider_lock); 712 713 if (pvp == NULL) 714 return (ESRCH); 715 716 bcopy(&pvp->dtpv_priv, &pvd->dtvd_priv, sizeof (dtrace_ppriv_t)); 717 bcopy(&pvp->dtpv_attr, &pvd->dtvd_attr, sizeof (dtrace_pattr_t)); 718 719 return (0); 720 } 721 case DTRACEIOC_REPLICATE: { 722 dtrace_repldesc_t *desc = (dtrace_repldesc_t *) addr; 723 dtrace_probedesc_t *match = &desc->dtrpd_match; 724 dtrace_probedesc_t *create = &desc->dtrpd_create; 725 int err; 726 727 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_REPLICATE\n",__func__,__LINE__); 728 729 match->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 730 match->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 731 match->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 732 match->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 733 734 create->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 735 create->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 736 create->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 737 create->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 738 739 mutex_enter(&dtrace_lock); 740 err = dtrace_enabling_replicate(state, match, create); 741 mutex_exit(&dtrace_lock); 742 743 return (err); 744 } 745 case DTRACEIOC_STATUS: { 746 dtrace_status_t *stat = (dtrace_status_t *) addr; 747 dtrace_dstate_t *dstate; 748 int i, j; 749 uint64_t nerrs; 750 751 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STATUS\n",__func__,__LINE__); 752 753 /* 754 * See the comment in dtrace_state_deadman() for the reason 755 * for setting dts_laststatus to INT64_MAX before setting 756 * it to the correct value. 757 */ 758 state->dts_laststatus = INT64_MAX; 759 dtrace_membar_producer(); 760 state->dts_laststatus = dtrace_gethrtime(); 761 762 bzero(stat, sizeof (*stat)); 763 764 mutex_enter(&dtrace_lock); 765 766 if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 767 mutex_exit(&dtrace_lock); 768 return (ENOENT); 769 } 770 771 if (state->dts_activity == DTRACE_ACTIVITY_DRAINING) 772 stat->dtst_exiting = 1; 773 774 nerrs = state->dts_errors; 775 dstate = &state->dts_vstate.dtvs_dynvars; 776 777 for (i = 0; i < NCPU; i++) { 778 #if !defined(sun) 779 if (pcpu_find(i) == NULL) 780 continue; 781 #endif 782 dtrace_dstate_percpu_t *dcpu = &dstate->dtds_percpu[i]; 783 784 stat->dtst_dyndrops += dcpu->dtdsc_drops; 785 stat->dtst_dyndrops_dirty += dcpu->dtdsc_dirty_drops; 786 stat->dtst_dyndrops_rinsing += dcpu->dtdsc_rinsing_drops; 787 788 if (state->dts_buffer[i].dtb_flags & DTRACEBUF_FULL) 789 stat->dtst_filled++; 790 791 nerrs += state->dts_buffer[i].dtb_errors; 792 793 for (j = 0; j < state->dts_nspeculations; j++) { 794 dtrace_speculation_t *spec; 795 dtrace_buffer_t *buf; 796 797 spec = &state->dts_speculations[j]; 798 buf = &spec->dtsp_buffer[i]; 799 stat->dtst_specdrops += buf->dtb_xamot_drops; 800 } 801 } 802 803 stat->dtst_specdrops_busy = state->dts_speculations_busy; 804 stat->dtst_specdrops_unavail = state->dts_speculations_unavail; 805 stat->dtst_stkstroverflows = state->dts_stkstroverflows; 806 stat->dtst_dblerrors = state->dts_dblerrors; 807 stat->dtst_killed = 808 (state->dts_activity == DTRACE_ACTIVITY_KILLED); 809 stat->dtst_errors = nerrs; 810 811 mutex_exit(&dtrace_lock); 812 813 return (0); 814 } 815 case DTRACEIOC_STOP: { 816 int rval; 817 processorid_t *cpuid = (processorid_t *) addr; 818 819 DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STOP\n",__func__,__LINE__); 820 821 mutex_enter(&dtrace_lock); 822 rval = dtrace_state_stop(state, cpuid); 823 mutex_exit(&dtrace_lock); 824 825 return (rval); 826 } 827 default: 828 error = ENOTTY; 829 } 830 return (error); 831 } 832