dtrace_ioctl.c revision 179237
1179237Sjb/* 2179237Sjb * CDDL HEADER START 3179237Sjb * 4179237Sjb * The contents of this file are subject to the terms of the 5179237Sjb * Common Development and Distribution License (the "License"). 6179237Sjb * You may not use this file except in compliance with the License. 7179237Sjb * 8179237Sjb * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9179237Sjb * or http://www.opensolaris.org/os/licensing. 10179237Sjb * See the License for the specific language governing permissions 11179237Sjb * and limitations under the License. 12179237Sjb * 13179237Sjb * When distributing Covered Code, include this CDDL HEADER in each 14179237Sjb * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15179237Sjb * If applicable, add the following below this CDDL HEADER, with the 16179237Sjb * fields enclosed by brackets "[]" replaced with your own identifying 17179237Sjb * information: Portions Copyright [yyyy] [name of copyright owner] 18179237Sjb * 19179237Sjb * CDDL HEADER END 20179237Sjb * 21179237Sjb * $FreeBSD: head/sys/cddl/dev/dtrace/dtrace_ioctl.c 179237 2008-05-23 05:59:42Z jb $ 22179237Sjb * 23179237Sjb */ 24179237Sjb 25179237Sjbstatic int dtrace_verbose_ioctl; 26179237SjbSYSCTL_INT(_debug_dtrace, OID_AUTO, verbose_ioctl, CTLFLAG_RW, &dtrace_verbose_ioctl, 0, ""); 27179237Sjb 28179237Sjb#define DTRACE_IOCTL_PRINTF(fmt, ...) if (dtrace_verbose_ioctl) printf(fmt, ## __VA_ARGS__ ) 29179237Sjb 30179237Sjb/* ARGSUSED */ 31179237Sjbstatic int 32179237Sjbdtrace_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, 33179237Sjb int flags __unused, struct thread *td) 34179237Sjb{ 35179237Sjb dtrace_state_t *state = dev->si_drv1; 36179237Sjb int error = 0; 37179237Sjb if (state == NULL) 38179237Sjb return (EINVAL); 39179237Sjb 40179237Sjb if (state->dts_anon) { 41179237Sjb ASSERT(dtrace_anon.dta_state == NULL); 42179237Sjb state = state->dts_anon; 43179237Sjb } 44179237Sjb 45179237Sjb switch (cmd) { 46179237Sjb case DTRACEIOC_AGGDESC: { 47179237Sjb dtrace_aggdesc_t **paggdesc = (dtrace_aggdesc_t **) addr; 48179237Sjb dtrace_aggdesc_t aggdesc; 49179237Sjb dtrace_action_t *act; 50179237Sjb dtrace_aggregation_t *agg; 51179237Sjb int nrecs; 52179237Sjb uint32_t offs; 53179237Sjb dtrace_recdesc_t *lrec; 54179237Sjb void *buf; 55179237Sjb size_t size; 56179237Sjb uintptr_t dest; 57179237Sjb 58179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_AGGDESC\n",__func__,__LINE__); 59179237Sjb 60179237Sjb if (copyin((void *) *paggdesc, &aggdesc, sizeof (aggdesc)) != 0) 61179237Sjb return (EFAULT); 62179237Sjb 63179237Sjb mutex_enter(&dtrace_lock); 64179237Sjb 65179237Sjb if ((agg = dtrace_aggid2agg(state, aggdesc.dtagd_id)) == NULL) { 66179237Sjb mutex_exit(&dtrace_lock); 67179237Sjb return (EINVAL); 68179237Sjb } 69179237Sjb 70179237Sjb aggdesc.dtagd_epid = agg->dtag_ecb->dte_epid; 71179237Sjb 72179237Sjb nrecs = aggdesc.dtagd_nrecs; 73179237Sjb aggdesc.dtagd_nrecs = 0; 74179237Sjb 75179237Sjb offs = agg->dtag_base; 76179237Sjb lrec = &agg->dtag_action.dta_rec; 77179237Sjb aggdesc.dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - offs; 78179237Sjb 79179237Sjb for (act = agg->dtag_first; ; act = act->dta_next) { 80179237Sjb ASSERT(act->dta_intuple || 81179237Sjb DTRACEACT_ISAGG(act->dta_kind)); 82179237Sjb 83179237Sjb /* 84179237Sjb * If this action has a record size of zero, it 85179237Sjb * denotes an argument to the aggregating action. 86179237Sjb * Because the presence of this record doesn't (or 87179237Sjb * shouldn't) affect the way the data is interpreted, 88179237Sjb * we don't copy it out to save user-level the 89179237Sjb * confusion of dealing with a zero-length record. 90179237Sjb */ 91179237Sjb if (act->dta_rec.dtrd_size == 0) { 92179237Sjb ASSERT(agg->dtag_hasarg); 93179237Sjb continue; 94179237Sjb } 95179237Sjb 96179237Sjb aggdesc.dtagd_nrecs++; 97179237Sjb 98179237Sjb if (act == &agg->dtag_action) 99179237Sjb break; 100179237Sjb } 101179237Sjb 102179237Sjb /* 103179237Sjb * Now that we have the size, we need to allocate a temporary 104179237Sjb * buffer in which to store the complete description. We need 105179237Sjb * the temporary buffer to be able to drop dtrace_lock() 106179237Sjb * across the copyout(), below. 107179237Sjb */ 108179237Sjb size = sizeof (dtrace_aggdesc_t) + 109179237Sjb (aggdesc.dtagd_nrecs * sizeof (dtrace_recdesc_t)); 110179237Sjb 111179237Sjb buf = kmem_alloc(size, KM_SLEEP); 112179237Sjb dest = (uintptr_t)buf; 113179237Sjb 114179237Sjb bcopy(&aggdesc, (void *)dest, sizeof (aggdesc)); 115179237Sjb dest += offsetof(dtrace_aggdesc_t, dtagd_rec[0]); 116179237Sjb 117179237Sjb for (act = agg->dtag_first; ; act = act->dta_next) { 118179237Sjb dtrace_recdesc_t rec = act->dta_rec; 119179237Sjb 120179237Sjb /* 121179237Sjb * See the comment in the above loop for why we pass 122179237Sjb * over zero-length records. 123179237Sjb */ 124179237Sjb if (rec.dtrd_size == 0) { 125179237Sjb ASSERT(agg->dtag_hasarg); 126179237Sjb continue; 127179237Sjb } 128179237Sjb 129179237Sjb if (nrecs-- == 0) 130179237Sjb break; 131179237Sjb 132179237Sjb rec.dtrd_offset -= offs; 133179237Sjb bcopy(&rec, (void *)dest, sizeof (rec)); 134179237Sjb dest += sizeof (dtrace_recdesc_t); 135179237Sjb 136179237Sjb if (act == &agg->dtag_action) 137179237Sjb break; 138179237Sjb } 139179237Sjb 140179237Sjb mutex_exit(&dtrace_lock); 141179237Sjb 142179237Sjb if (copyout(buf, (void *) *paggdesc, dest - (uintptr_t)buf) != 0) { 143179237Sjb kmem_free(buf, size); 144179237Sjb return (EFAULT); 145179237Sjb } 146179237Sjb 147179237Sjb kmem_free(buf, size); 148179237Sjb return (0); 149179237Sjb } 150179237Sjb case DTRACEIOC_AGGSNAP: 151179237Sjb case DTRACEIOC_BUFSNAP: { 152179237Sjb dtrace_bufdesc_t **pdesc = (dtrace_bufdesc_t **) addr; 153179237Sjb dtrace_bufdesc_t desc; 154179237Sjb caddr_t cached; 155179237Sjb dtrace_buffer_t *buf; 156179237Sjb 157179237Sjb dtrace_debug_output(); 158179237Sjb 159179237Sjb if (copyin((void *) *pdesc, &desc, sizeof (desc)) != 0) 160179237Sjb return (EFAULT); 161179237Sjb 162179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): %s curcpu %d cpu %d\n", 163179237Sjb __func__,__LINE__, 164179237Sjb cmd == DTRACEIOC_AGGSNAP ? 165179237Sjb "DTRACEIOC_AGGSNAP":"DTRACEIOC_BUFSNAP", 166179237Sjb curcpu, desc.dtbd_cpu); 167179237Sjb 168179237Sjb if (desc.dtbd_cpu < 0 || desc.dtbd_cpu >= NCPU) 169179237Sjb return (ENOENT); 170179237Sjb if (pcpu_find(desc.dtbd_cpu) == NULL) 171179237Sjb return (ENOENT); 172179237Sjb 173179237Sjb mutex_enter(&dtrace_lock); 174179237Sjb 175179237Sjb if (cmd == DTRACEIOC_BUFSNAP) { 176179237Sjb buf = &state->dts_buffer[desc.dtbd_cpu]; 177179237Sjb } else { 178179237Sjb buf = &state->dts_aggbuffer[desc.dtbd_cpu]; 179179237Sjb } 180179237Sjb 181179237Sjb if (buf->dtb_flags & (DTRACEBUF_RING | DTRACEBUF_FILL)) { 182179237Sjb size_t sz = buf->dtb_offset; 183179237Sjb 184179237Sjb if (state->dts_activity != DTRACE_ACTIVITY_STOPPED) { 185179237Sjb mutex_exit(&dtrace_lock); 186179237Sjb return (EBUSY); 187179237Sjb } 188179237Sjb 189179237Sjb /* 190179237Sjb * If this buffer has already been consumed, we're 191179237Sjb * going to indicate that there's nothing left here 192179237Sjb * to consume. 193179237Sjb */ 194179237Sjb if (buf->dtb_flags & DTRACEBUF_CONSUMED) { 195179237Sjb mutex_exit(&dtrace_lock); 196179237Sjb 197179237Sjb desc.dtbd_size = 0; 198179237Sjb desc.dtbd_drops = 0; 199179237Sjb desc.dtbd_errors = 0; 200179237Sjb desc.dtbd_oldest = 0; 201179237Sjb sz = sizeof (desc); 202179237Sjb 203179237Sjb if (copyout(&desc, (void *) *pdesc, sz) != 0) 204179237Sjb return (EFAULT); 205179237Sjb 206179237Sjb return (0); 207179237Sjb } 208179237Sjb 209179237Sjb /* 210179237Sjb * If this is a ring buffer that has wrapped, we want 211179237Sjb * to copy the whole thing out. 212179237Sjb */ 213179237Sjb if (buf->dtb_flags & DTRACEBUF_WRAPPED) { 214179237Sjb dtrace_buffer_polish(buf); 215179237Sjb sz = buf->dtb_size; 216179237Sjb } 217179237Sjb 218179237Sjb if (copyout(buf->dtb_tomax, desc.dtbd_data, sz) != 0) { 219179237Sjb mutex_exit(&dtrace_lock); 220179237Sjb return (EFAULT); 221179237Sjb } 222179237Sjb 223179237Sjb desc.dtbd_size = sz; 224179237Sjb desc.dtbd_drops = buf->dtb_drops; 225179237Sjb desc.dtbd_errors = buf->dtb_errors; 226179237Sjb desc.dtbd_oldest = buf->dtb_xamot_offset; 227179237Sjb 228179237Sjb mutex_exit(&dtrace_lock); 229179237Sjb 230179237Sjb if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 231179237Sjb return (EFAULT); 232179237Sjb 233179237Sjb buf->dtb_flags |= DTRACEBUF_CONSUMED; 234179237Sjb 235179237Sjb return (0); 236179237Sjb } 237179237Sjb 238179237Sjb if (buf->dtb_tomax == NULL) { 239179237Sjb ASSERT(buf->dtb_xamot == NULL); 240179237Sjb mutex_exit(&dtrace_lock); 241179237Sjb return (ENOENT); 242179237Sjb } 243179237Sjb 244179237Sjb cached = buf->dtb_tomax; 245179237Sjb ASSERT(!(buf->dtb_flags & DTRACEBUF_NOSWITCH)); 246179237Sjb 247179237Sjb dtrace_xcall(desc.dtbd_cpu, 248179237Sjb (dtrace_xcall_t)dtrace_buffer_switch, buf); 249179237Sjb 250179237Sjb state->dts_errors += buf->dtb_xamot_errors; 251179237Sjb 252179237Sjb /* 253179237Sjb * If the buffers did not actually switch, then the cross call 254179237Sjb * did not take place -- presumably because the given CPU is 255179237Sjb * not in the ready set. If this is the case, we'll return 256179237Sjb * ENOENT. 257179237Sjb */ 258179237Sjb if (buf->dtb_tomax == cached) { 259179237Sjb ASSERT(buf->dtb_xamot != cached); 260179237Sjb mutex_exit(&dtrace_lock); 261179237Sjb return (ENOENT); 262179237Sjb } 263179237Sjb 264179237Sjb ASSERT(cached == buf->dtb_xamot); 265179237Sjb 266179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): copyout the buffer snapshot\n",__func__,__LINE__); 267179237Sjb 268179237Sjb /* 269179237Sjb * We have our snapshot; now copy it out. 270179237Sjb */ 271179237Sjb if (copyout(buf->dtb_xamot, desc.dtbd_data, 272179237Sjb buf->dtb_xamot_offset) != 0) { 273179237Sjb mutex_exit(&dtrace_lock); 274179237Sjb return (EFAULT); 275179237Sjb } 276179237Sjb 277179237Sjb desc.dtbd_size = buf->dtb_xamot_offset; 278179237Sjb desc.dtbd_drops = buf->dtb_xamot_drops; 279179237Sjb desc.dtbd_errors = buf->dtb_xamot_errors; 280179237Sjb desc.dtbd_oldest = 0; 281179237Sjb 282179237Sjb mutex_exit(&dtrace_lock); 283179237Sjb 284179237Sjb 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); 285179237Sjb 286179237Sjb /* 287179237Sjb * Finally, copy out the buffer description. 288179237Sjb */ 289179237Sjb if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 290179237Sjb return (EFAULT); 291179237Sjb 292179237Sjb return (0); 293179237Sjb } 294179237Sjb case DTRACEIOC_CONF: { 295179237Sjb dtrace_conf_t conf; 296179237Sjb 297179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_CONF\n",__func__,__LINE__); 298179237Sjb 299179237Sjb bzero(&conf, sizeof (conf)); 300179237Sjb conf.dtc_difversion = DIF_VERSION; 301179237Sjb conf.dtc_difintregs = DIF_DIR_NREGS; 302179237Sjb conf.dtc_diftupregs = DIF_DTR_NREGS; 303179237Sjb conf.dtc_ctfmodel = CTF_MODEL_NATIVE; 304179237Sjb 305179237Sjb *((dtrace_conf_t *) addr) = conf; 306179237Sjb 307179237Sjb return (0); 308179237Sjb } 309179237Sjb case DTRACEIOC_DOFGET: { 310179237Sjb dof_hdr_t **pdof = (dof_hdr_t **) addr; 311179237Sjb dof_hdr_t hdr, *dof = *pdof; 312179237Sjb int rval; 313179237Sjb uint64_t len; 314179237Sjb 315179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_DOFGET\n",__func__,__LINE__); 316179237Sjb 317179237Sjb if (copyin((void *)dof, &hdr, sizeof (hdr)) != 0) 318179237Sjb return (EFAULT); 319179237Sjb 320179237Sjb mutex_enter(&dtrace_lock); 321179237Sjb dof = dtrace_dof_create(state); 322179237Sjb mutex_exit(&dtrace_lock); 323179237Sjb 324179237Sjb len = MIN(hdr.dofh_loadsz, dof->dofh_loadsz); 325179237Sjb rval = copyout(dof, (void *) *pdof, len); 326179237Sjb dtrace_dof_destroy(dof); 327179237Sjb 328179237Sjb return (rval == 0 ? 0 : EFAULT); 329179237Sjb } 330179237Sjb case DTRACEIOC_ENABLE: { 331179237Sjb dof_hdr_t *dof = NULL; 332179237Sjb dtrace_enabling_t *enab = NULL; 333179237Sjb dtrace_vstate_t *vstate; 334179237Sjb int err = 0; 335179237Sjb int rval; 336179237Sjb dtrace_enable_io_t *p = (dtrace_enable_io_t *) addr; 337179237Sjb 338179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_ENABLE\n",__func__,__LINE__); 339179237Sjb 340179237Sjb /* 341179237Sjb * If a NULL argument has been passed, we take this as our 342179237Sjb * cue to reevaluate our enablings. 343179237Sjb */ 344179237Sjb if (p->dof == NULL) { 345179237Sjb dtrace_enabling_matchall(); 346179237Sjb 347179237Sjb return (0); 348179237Sjb } 349179237Sjb 350179237Sjb if ((dof = dtrace_dof_copyin((uintptr_t) p->dof, &rval)) == NULL) 351179237Sjb return (EINVAL); 352179237Sjb 353179237Sjb mutex_enter(&cpu_lock); 354179237Sjb mutex_enter(&dtrace_lock); 355179237Sjb vstate = &state->dts_vstate; 356179237Sjb 357179237Sjb if (state->dts_activity != DTRACE_ACTIVITY_INACTIVE) { 358179237Sjb mutex_exit(&dtrace_lock); 359179237Sjb mutex_exit(&cpu_lock); 360179237Sjb dtrace_dof_destroy(dof); 361179237Sjb return (EBUSY); 362179237Sjb } 363179237Sjb 364179237Sjb if (dtrace_dof_slurp(dof, vstate, td->td_ucred, &enab, 0, B_TRUE) != 0) { 365179237Sjb mutex_exit(&dtrace_lock); 366179237Sjb mutex_exit(&cpu_lock); 367179237Sjb dtrace_dof_destroy(dof); 368179237Sjb return (EINVAL); 369179237Sjb } 370179237Sjb 371179237Sjb if ((rval = dtrace_dof_options(dof, state)) != 0) { 372179237Sjb dtrace_enabling_destroy(enab); 373179237Sjb mutex_exit(&dtrace_lock); 374179237Sjb mutex_exit(&cpu_lock); 375179237Sjb dtrace_dof_destroy(dof); 376179237Sjb return (rval); 377179237Sjb } 378179237Sjb 379179237Sjb if ((err = dtrace_enabling_match(enab, &p->n_matched)) == 0) { 380179237Sjb err = dtrace_enabling_retain(enab); 381179237Sjb } else { 382179237Sjb dtrace_enabling_destroy(enab); 383179237Sjb } 384179237Sjb 385179237Sjb mutex_exit(&cpu_lock); 386179237Sjb mutex_exit(&dtrace_lock); 387179237Sjb dtrace_dof_destroy(dof); 388179237Sjb 389179237Sjb return (err); 390179237Sjb } 391179237Sjb case DTRACEIOC_EPROBE: { 392179237Sjb dtrace_eprobedesc_t **pepdesc = (dtrace_eprobedesc_t **) addr; 393179237Sjb dtrace_eprobedesc_t epdesc; 394179237Sjb dtrace_ecb_t *ecb; 395179237Sjb dtrace_action_t *act; 396179237Sjb void *buf; 397179237Sjb size_t size; 398179237Sjb uintptr_t dest; 399179237Sjb int nrecs; 400179237Sjb 401179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_EPROBE\n",__func__,__LINE__); 402179237Sjb 403179237Sjb if (copyin((void *)*pepdesc, &epdesc, sizeof (epdesc)) != 0) 404179237Sjb return (EFAULT); 405179237Sjb 406179237Sjb mutex_enter(&dtrace_lock); 407179237Sjb 408179237Sjb if ((ecb = dtrace_epid2ecb(state, epdesc.dtepd_epid)) == NULL) { 409179237Sjb mutex_exit(&dtrace_lock); 410179237Sjb return (EINVAL); 411179237Sjb } 412179237Sjb 413179237Sjb if (ecb->dte_probe == NULL) { 414179237Sjb mutex_exit(&dtrace_lock); 415179237Sjb return (EINVAL); 416179237Sjb } 417179237Sjb 418179237Sjb epdesc.dtepd_probeid = ecb->dte_probe->dtpr_id; 419179237Sjb epdesc.dtepd_uarg = ecb->dte_uarg; 420179237Sjb epdesc.dtepd_size = ecb->dte_size; 421179237Sjb 422179237Sjb nrecs = epdesc.dtepd_nrecs; 423179237Sjb epdesc.dtepd_nrecs = 0; 424179237Sjb for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 425179237Sjb if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 426179237Sjb continue; 427179237Sjb 428179237Sjb epdesc.dtepd_nrecs++; 429179237Sjb } 430179237Sjb 431179237Sjb /* 432179237Sjb * Now that we have the size, we need to allocate a temporary 433179237Sjb * buffer in which to store the complete description. We need 434179237Sjb * the temporary buffer to be able to drop dtrace_lock() 435179237Sjb * across the copyout(), below. 436179237Sjb */ 437179237Sjb size = sizeof (dtrace_eprobedesc_t) + 438179237Sjb (epdesc.dtepd_nrecs * sizeof (dtrace_recdesc_t)); 439179237Sjb 440179237Sjb buf = kmem_alloc(size, KM_SLEEP); 441179237Sjb dest = (uintptr_t)buf; 442179237Sjb 443179237Sjb bcopy(&epdesc, (void *)dest, sizeof (epdesc)); 444179237Sjb dest += offsetof(dtrace_eprobedesc_t, dtepd_rec[0]); 445179237Sjb 446179237Sjb for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 447179237Sjb if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 448179237Sjb continue; 449179237Sjb 450179237Sjb if (nrecs-- == 0) 451179237Sjb break; 452179237Sjb 453179237Sjb bcopy(&act->dta_rec, (void *)dest, 454179237Sjb sizeof (dtrace_recdesc_t)); 455179237Sjb dest += sizeof (dtrace_recdesc_t); 456179237Sjb } 457179237Sjb 458179237Sjb mutex_exit(&dtrace_lock); 459179237Sjb 460179237Sjb if (copyout(buf, (void *) *pepdesc, dest - (uintptr_t)buf) != 0) { 461179237Sjb kmem_free(buf, size); 462179237Sjb return (EFAULT); 463179237Sjb } 464179237Sjb 465179237Sjb kmem_free(buf, size); 466179237Sjb return (0); 467179237Sjb } 468179237Sjb case DTRACEIOC_FORMAT: { 469179237Sjb dtrace_fmtdesc_t *fmt = (dtrace_fmtdesc_t *) addr; 470179237Sjb char *str; 471179237Sjb int len; 472179237Sjb 473179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_FORMAT\n",__func__,__LINE__); 474179237Sjb 475179237Sjb mutex_enter(&dtrace_lock); 476179237Sjb 477179237Sjb if (fmt->dtfd_format == 0 || 478179237Sjb fmt->dtfd_format > state->dts_nformats) { 479179237Sjb mutex_exit(&dtrace_lock); 480179237Sjb return (EINVAL); 481179237Sjb } 482179237Sjb 483179237Sjb /* 484179237Sjb * Format strings are allocated contiguously and they are 485179237Sjb * never freed; if a format index is less than the number 486179237Sjb * of formats, we can assert that the format map is non-NULL 487179237Sjb * and that the format for the specified index is non-NULL. 488179237Sjb */ 489179237Sjb ASSERT(state->dts_formats != NULL); 490179237Sjb str = state->dts_formats[fmt->dtfd_format - 1]; 491179237Sjb ASSERT(str != NULL); 492179237Sjb 493179237Sjb len = strlen(str) + 1; 494179237Sjb 495179237Sjb if (len > fmt->dtfd_length) { 496179237Sjb fmt->dtfd_length = len; 497179237Sjb } else { 498179237Sjb if (copyout(str, fmt->dtfd_string, len) != 0) { 499179237Sjb mutex_exit(&dtrace_lock); 500179237Sjb return (EINVAL); 501179237Sjb } 502179237Sjb } 503179237Sjb 504179237Sjb mutex_exit(&dtrace_lock); 505179237Sjb return (0); 506179237Sjb } 507179237Sjb case DTRACEIOC_GO: { 508179237Sjb int rval; 509179237Sjb processorid_t *cpuid = (processorid_t *) addr; 510179237Sjb 511179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_GO\n",__func__,__LINE__); 512179237Sjb 513179237Sjb rval = dtrace_state_go(state, cpuid); 514179237Sjb 515179237Sjb return (rval); 516179237Sjb } 517179237Sjb case DTRACEIOC_PROBEARG: { 518179237Sjb dtrace_argdesc_t *desc = (dtrace_argdesc_t *) addr; 519179237Sjb dtrace_probe_t *probe; 520179237Sjb dtrace_provider_t *prov; 521179237Sjb 522179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROBEARG\n",__func__,__LINE__); 523179237Sjb 524179237Sjb if (desc->dtargd_id == DTRACE_IDNONE) 525179237Sjb return (EINVAL); 526179237Sjb 527179237Sjb if (desc->dtargd_ndx == DTRACE_ARGNONE) 528179237Sjb return (EINVAL); 529179237Sjb 530179237Sjb mutex_enter(&dtrace_provider_lock); 531179237Sjb mutex_enter(&mod_lock); 532179237Sjb mutex_enter(&dtrace_lock); 533179237Sjb 534179237Sjb if (desc->dtargd_id > dtrace_nprobes) { 535179237Sjb mutex_exit(&dtrace_lock); 536179237Sjb mutex_exit(&mod_lock); 537179237Sjb mutex_exit(&dtrace_provider_lock); 538179237Sjb return (EINVAL); 539179237Sjb } 540179237Sjb 541179237Sjb if ((probe = dtrace_probes[desc->dtargd_id - 1]) == NULL) { 542179237Sjb mutex_exit(&dtrace_lock); 543179237Sjb mutex_exit(&mod_lock); 544179237Sjb mutex_exit(&dtrace_provider_lock); 545179237Sjb return (EINVAL); 546179237Sjb } 547179237Sjb 548179237Sjb mutex_exit(&dtrace_lock); 549179237Sjb 550179237Sjb prov = probe->dtpr_provider; 551179237Sjb 552179237Sjb if (prov->dtpv_pops.dtps_getargdesc == NULL) { 553179237Sjb /* 554179237Sjb * There isn't any typed information for this probe. 555179237Sjb * Set the argument number to DTRACE_ARGNONE. 556179237Sjb */ 557179237Sjb desc->dtargd_ndx = DTRACE_ARGNONE; 558179237Sjb } else { 559179237Sjb desc->dtargd_native[0] = '\0'; 560179237Sjb desc->dtargd_xlate[0] = '\0'; 561179237Sjb desc->dtargd_mapping = desc->dtargd_ndx; 562179237Sjb 563179237Sjb prov->dtpv_pops.dtps_getargdesc(prov->dtpv_arg, 564179237Sjb probe->dtpr_id, probe->dtpr_arg, desc); 565179237Sjb } 566179237Sjb 567179237Sjb mutex_exit(&mod_lock); 568179237Sjb mutex_exit(&dtrace_provider_lock); 569179237Sjb 570179237Sjb return (0); 571179237Sjb } 572179237Sjb case DTRACEIOC_PROBEMATCH: 573179237Sjb case DTRACEIOC_PROBES: { 574179237Sjb dtrace_probedesc_t *p_desc = (dtrace_probedesc_t *) addr; 575179237Sjb dtrace_probe_t *probe = NULL; 576179237Sjb dtrace_probekey_t pkey; 577179237Sjb dtrace_id_t i; 578179237Sjb int m = 0; 579179237Sjb uint32_t priv = 0; 580179237Sjb uid_t uid = 0; 581179237Sjb zoneid_t zoneid = 0; 582179237Sjb 583179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): %s\n",__func__,__LINE__, 584179237Sjb cmd == DTRACEIOC_PROBEMATCH ? 585179237Sjb "DTRACEIOC_PROBEMATCH":"DTRACEIOC_PROBES"); 586179237Sjb 587179237Sjb p_desc->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 588179237Sjb p_desc->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 589179237Sjb p_desc->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 590179237Sjb p_desc->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 591179237Sjb 592179237Sjb /* 593179237Sjb * Before we attempt to match this probe, we want to give 594179237Sjb * all providers the opportunity to provide it. 595179237Sjb */ 596179237Sjb if (p_desc->dtpd_id == DTRACE_IDNONE) { 597179237Sjb mutex_enter(&dtrace_provider_lock); 598179237Sjb dtrace_probe_provide(p_desc, NULL); 599179237Sjb mutex_exit(&dtrace_provider_lock); 600179237Sjb p_desc->dtpd_id++; 601179237Sjb } 602179237Sjb 603179237Sjb if (cmd == DTRACEIOC_PROBEMATCH) { 604179237Sjb dtrace_probekey(p_desc, &pkey); 605179237Sjb pkey.dtpk_id = DTRACE_IDNONE; 606179237Sjb } 607179237Sjb 608179237Sjb dtrace_cred2priv(td->td_ucred, &priv, &uid, &zoneid); 609179237Sjb 610179237Sjb mutex_enter(&dtrace_lock); 611179237Sjb 612179237Sjb if (cmd == DTRACEIOC_PROBEMATCH) { 613179237Sjb for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 614179237Sjb if ((probe = dtrace_probes[i - 1]) != NULL && 615179237Sjb (m = dtrace_match_probe(probe, &pkey, 616179237Sjb priv, uid, zoneid)) != 0) 617179237Sjb break; 618179237Sjb } 619179237Sjb 620179237Sjb if (m < 0) { 621179237Sjb mutex_exit(&dtrace_lock); 622179237Sjb return (EINVAL); 623179237Sjb } 624179237Sjb 625179237Sjb } else { 626179237Sjb for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 627179237Sjb if ((probe = dtrace_probes[i - 1]) != NULL && 628179237Sjb dtrace_match_priv(probe, priv, uid, zoneid)) 629179237Sjb break; 630179237Sjb } 631179237Sjb } 632179237Sjb 633179237Sjb if (probe == NULL) { 634179237Sjb mutex_exit(&dtrace_lock); 635179237Sjb return (ESRCH); 636179237Sjb } 637179237Sjb 638179237Sjb dtrace_probe_description(probe, p_desc); 639179237Sjb mutex_exit(&dtrace_lock); 640179237Sjb 641179237Sjb return (0); 642179237Sjb } 643179237Sjb case DTRACEIOC_PROVIDER: { 644179237Sjb dtrace_providerdesc_t *pvd = (dtrace_providerdesc_t *) addr; 645179237Sjb dtrace_provider_t *pvp; 646179237Sjb 647179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROVIDER\n",__func__,__LINE__); 648179237Sjb 649179237Sjb pvd->dtvd_name[DTRACE_PROVNAMELEN - 1] = '\0'; 650179237Sjb mutex_enter(&dtrace_provider_lock); 651179237Sjb 652179237Sjb for (pvp = dtrace_provider; pvp != NULL; pvp = pvp->dtpv_next) { 653179237Sjb if (strcmp(pvp->dtpv_name, pvd->dtvd_name) == 0) 654179237Sjb break; 655179237Sjb } 656179237Sjb 657179237Sjb mutex_exit(&dtrace_provider_lock); 658179237Sjb 659179237Sjb if (pvp == NULL) 660179237Sjb return (ESRCH); 661179237Sjb 662179237Sjb bcopy(&pvp->dtpv_priv, &pvd->dtvd_priv, sizeof (dtrace_ppriv_t)); 663179237Sjb bcopy(&pvp->dtpv_attr, &pvd->dtvd_attr, sizeof (dtrace_pattr_t)); 664179237Sjb 665179237Sjb return (0); 666179237Sjb } 667179237Sjb case DTRACEIOC_REPLICATE: { 668179237Sjb dtrace_repldesc_t *desc = (dtrace_repldesc_t *) addr; 669179237Sjb dtrace_probedesc_t *match = &desc->dtrpd_match; 670179237Sjb dtrace_probedesc_t *create = &desc->dtrpd_create; 671179237Sjb int err; 672179237Sjb 673179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_REPLICATE\n",__func__,__LINE__); 674179237Sjb 675179237Sjb match->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 676179237Sjb match->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 677179237Sjb match->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 678179237Sjb match->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 679179237Sjb 680179237Sjb create->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 681179237Sjb create->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 682179237Sjb create->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 683179237Sjb create->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 684179237Sjb 685179237Sjb mutex_enter(&dtrace_lock); 686179237Sjb err = dtrace_enabling_replicate(state, match, create); 687179237Sjb mutex_exit(&dtrace_lock); 688179237Sjb 689179237Sjb return (err); 690179237Sjb } 691179237Sjb case DTRACEIOC_STATUS: { 692179237Sjb dtrace_status_t *stat = (dtrace_status_t *) addr; 693179237Sjb dtrace_dstate_t *dstate; 694179237Sjb int i, j; 695179237Sjb uint64_t nerrs; 696179237Sjb 697179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STATUS\n",__func__,__LINE__); 698179237Sjb 699179237Sjb /* 700179237Sjb * See the comment in dtrace_state_deadman() for the reason 701179237Sjb * for setting dts_laststatus to INT64_MAX before setting 702179237Sjb * it to the correct value. 703179237Sjb */ 704179237Sjb state->dts_laststatus = INT64_MAX; 705179237Sjb dtrace_membar_producer(); 706179237Sjb state->dts_laststatus = dtrace_gethrtime(); 707179237Sjb 708179237Sjb bzero(stat, sizeof (*stat)); 709179237Sjb 710179237Sjb mutex_enter(&dtrace_lock); 711179237Sjb 712179237Sjb if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 713179237Sjb mutex_exit(&dtrace_lock); 714179237Sjb return (ENOENT); 715179237Sjb } 716179237Sjb 717179237Sjb if (state->dts_activity == DTRACE_ACTIVITY_DRAINING) 718179237Sjb stat->dtst_exiting = 1; 719179237Sjb 720179237Sjb nerrs = state->dts_errors; 721179237Sjb dstate = &state->dts_vstate.dtvs_dynvars; 722179237Sjb 723179237Sjb for (i = 0; i < NCPU; i++) { 724179237Sjb#if !defined(sun) 725179237Sjb if (pcpu_find(i) == NULL) 726179237Sjb continue; 727179237Sjb#endif 728179237Sjb dtrace_dstate_percpu_t *dcpu = &dstate->dtds_percpu[i]; 729179237Sjb 730179237Sjb stat->dtst_dyndrops += dcpu->dtdsc_drops; 731179237Sjb stat->dtst_dyndrops_dirty += dcpu->dtdsc_dirty_drops; 732179237Sjb stat->dtst_dyndrops_rinsing += dcpu->dtdsc_rinsing_drops; 733179237Sjb 734179237Sjb if (state->dts_buffer[i].dtb_flags & DTRACEBUF_FULL) 735179237Sjb stat->dtst_filled++; 736179237Sjb 737179237Sjb nerrs += state->dts_buffer[i].dtb_errors; 738179237Sjb 739179237Sjb for (j = 0; j < state->dts_nspeculations; j++) { 740179237Sjb dtrace_speculation_t *spec; 741179237Sjb dtrace_buffer_t *buf; 742179237Sjb 743179237Sjb spec = &state->dts_speculations[j]; 744179237Sjb buf = &spec->dtsp_buffer[i]; 745179237Sjb stat->dtst_specdrops += buf->dtb_xamot_drops; 746179237Sjb } 747179237Sjb } 748179237Sjb 749179237Sjb stat->dtst_specdrops_busy = state->dts_speculations_busy; 750179237Sjb stat->dtst_specdrops_unavail = state->dts_speculations_unavail; 751179237Sjb stat->dtst_stkstroverflows = state->dts_stkstroverflows; 752179237Sjb stat->dtst_dblerrors = state->dts_dblerrors; 753179237Sjb stat->dtst_killed = 754179237Sjb (state->dts_activity == DTRACE_ACTIVITY_KILLED); 755179237Sjb stat->dtst_errors = nerrs; 756179237Sjb 757179237Sjb mutex_exit(&dtrace_lock); 758179237Sjb 759179237Sjb return (0); 760179237Sjb } 761179237Sjb case DTRACEIOC_STOP: { 762179237Sjb int rval; 763179237Sjb processorid_t *cpuid = (processorid_t *) addr; 764179237Sjb 765179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STOP\n",__func__,__LINE__); 766179237Sjb 767179237Sjb mutex_enter(&dtrace_lock); 768179237Sjb rval = dtrace_state_stop(state, cpuid); 769179237Sjb mutex_exit(&dtrace_lock); 770179237Sjb 771179237Sjb return (rval); 772179237Sjb } 773179237Sjb default: 774179237Sjb error = ENOTTY; 775179237Sjb } 776179237Sjb return (error); 777179237Sjb} 778