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