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: releng/10.3/sys/cddl/dev/dtrace/dtrace_ioctl.c 273110 2014-10-14 23:16:52Z pfg $ 22179237Sjb * 23179237Sjb */ 24179237Sjb 25179237Sjbstatic int dtrace_verbose_ioctl; 26266102SmarkjSYSCTL_INT(_debug_dtrace, OID_AUTO, verbose_ioctl, CTLFLAG_RW, 27266102Smarkj &dtrace_verbose_ioctl, 0, "log DTrace ioctls"); 28179237Sjb 29179237Sjb#define DTRACE_IOCTL_PRINTF(fmt, ...) if (dtrace_verbose_ioctl) printf(fmt, ## __VA_ARGS__ ) 30179237Sjb 31211608Srpaulostatic int 32211608Srpaulodtrace_ioctl_helper(struct cdev *dev, u_long cmd, caddr_t addr, int flags, 33211608Srpaulo struct thread *td) 34211608Srpaulo{ 35211608Srpaulo int rval; 36211608Srpaulo dof_helper_t *dhp = NULL; 37211608Srpaulo dof_hdr_t *dof = NULL; 38211608Srpaulo 39211608Srpaulo switch (cmd) { 40211608Srpaulo case DTRACEHIOC_ADDDOF: 41211608Srpaulo dhp = (dof_helper_t *)addr; 42211608Srpaulo /* XXX all because dofhp_dof is 64 bit */ 43233521Sgonzo addr = (caddr_t)(vm_offset_t)dhp->dofhp_dof; 44211608Srpaulo /* FALLTHROUGH */ 45211608Srpaulo case DTRACEHIOC_ADD: 46211608Srpaulo dof = dtrace_dof_copyin((intptr_t)addr, &rval); 47211608Srpaulo 48211608Srpaulo if (dof == NULL) 49211608Srpaulo return (rval); 50211608Srpaulo 51211608Srpaulo mutex_enter(&dtrace_lock); 52211608Srpaulo if ((rval = dtrace_helper_slurp((dof_hdr_t *)dof, dhp)) != -1) { 53211608Srpaulo if (dhp) { 54211608Srpaulo dhp->gen = rval; 55211608Srpaulo copyout(dhp, addr, sizeof(*dhp)); 56211608Srpaulo } 57211608Srpaulo rval = 0; 58211608Srpaulo } else { 59211608Srpaulo rval = EINVAL; 60211608Srpaulo } 61211608Srpaulo mutex_exit(&dtrace_lock); 62211608Srpaulo return (rval); 63211608Srpaulo case DTRACEHIOC_REMOVE: 64211608Srpaulo mutex_enter(&dtrace_lock); 65211608Srpaulo rval = dtrace_helper_destroygen((int)*addr); 66211608Srpaulo mutex_exit(&dtrace_lock); 67211608Srpaulo 68211608Srpaulo return (rval); 69211608Srpaulo default: 70211608Srpaulo break; 71211608Srpaulo } 72211608Srpaulo 73211608Srpaulo return (ENOTTY); 74211608Srpaulo} 75211608Srpaulo 76179237Sjb/* ARGSUSED */ 77179237Sjbstatic int 78179237Sjbdtrace_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, 79179237Sjb int flags __unused, struct thread *td) 80179237Sjb{ 81184698Srodrigc dtrace_state_t *state; 82184698Srodrigc devfs_get_cdevpriv((void **) &state); 83273110Spfg 84179237Sjb int error = 0; 85179237Sjb if (state == NULL) 86179237Sjb return (EINVAL); 87179237Sjb 88179237Sjb if (state->dts_anon) { 89179237Sjb ASSERT(dtrace_anon.dta_state == NULL); 90179237Sjb state = state->dts_anon; 91179237Sjb } 92179237Sjb 93179237Sjb switch (cmd) { 94179237Sjb case DTRACEIOC_AGGDESC: { 95179237Sjb dtrace_aggdesc_t **paggdesc = (dtrace_aggdesc_t **) addr; 96179237Sjb dtrace_aggdesc_t aggdesc; 97179237Sjb dtrace_action_t *act; 98179237Sjb dtrace_aggregation_t *agg; 99179237Sjb int nrecs; 100179237Sjb uint32_t offs; 101179237Sjb dtrace_recdesc_t *lrec; 102179237Sjb void *buf; 103179237Sjb size_t size; 104179237Sjb uintptr_t dest; 105179237Sjb 106179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_AGGDESC\n",__func__,__LINE__); 107179237Sjb 108179237Sjb if (copyin((void *) *paggdesc, &aggdesc, sizeof (aggdesc)) != 0) 109179237Sjb return (EFAULT); 110179237Sjb 111179237Sjb mutex_enter(&dtrace_lock); 112179237Sjb 113179237Sjb if ((agg = dtrace_aggid2agg(state, aggdesc.dtagd_id)) == NULL) { 114179237Sjb mutex_exit(&dtrace_lock); 115179237Sjb return (EINVAL); 116179237Sjb } 117179237Sjb 118179237Sjb aggdesc.dtagd_epid = agg->dtag_ecb->dte_epid; 119179237Sjb 120179237Sjb nrecs = aggdesc.dtagd_nrecs; 121179237Sjb aggdesc.dtagd_nrecs = 0; 122179237Sjb 123179237Sjb offs = agg->dtag_base; 124179237Sjb lrec = &agg->dtag_action.dta_rec; 125179237Sjb aggdesc.dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - offs; 126179237Sjb 127179237Sjb for (act = agg->dtag_first; ; act = act->dta_next) { 128179237Sjb ASSERT(act->dta_intuple || 129179237Sjb DTRACEACT_ISAGG(act->dta_kind)); 130179237Sjb 131179237Sjb /* 132179237Sjb * If this action has a record size of zero, it 133179237Sjb * denotes an argument to the aggregating action. 134179237Sjb * Because the presence of this record doesn't (or 135179237Sjb * shouldn't) affect the way the data is interpreted, 136179237Sjb * we don't copy it out to save user-level the 137179237Sjb * confusion of dealing with a zero-length record. 138179237Sjb */ 139179237Sjb if (act->dta_rec.dtrd_size == 0) { 140179237Sjb ASSERT(agg->dtag_hasarg); 141179237Sjb continue; 142179237Sjb } 143179237Sjb 144179237Sjb aggdesc.dtagd_nrecs++; 145179237Sjb 146179237Sjb if (act == &agg->dtag_action) 147179237Sjb break; 148179237Sjb } 149179237Sjb 150179237Sjb /* 151179237Sjb * Now that we have the size, we need to allocate a temporary 152179237Sjb * buffer in which to store the complete description. We need 153179237Sjb * the temporary buffer to be able to drop dtrace_lock() 154179237Sjb * across the copyout(), below. 155179237Sjb */ 156179237Sjb size = sizeof (dtrace_aggdesc_t) + 157179237Sjb (aggdesc.dtagd_nrecs * sizeof (dtrace_recdesc_t)); 158179237Sjb 159179237Sjb buf = kmem_alloc(size, KM_SLEEP); 160179237Sjb dest = (uintptr_t)buf; 161179237Sjb 162179237Sjb bcopy(&aggdesc, (void *)dest, sizeof (aggdesc)); 163179237Sjb dest += offsetof(dtrace_aggdesc_t, dtagd_rec[0]); 164179237Sjb 165179237Sjb for (act = agg->dtag_first; ; act = act->dta_next) { 166179237Sjb dtrace_recdesc_t rec = act->dta_rec; 167179237Sjb 168179237Sjb /* 169179237Sjb * See the comment in the above loop for why we pass 170179237Sjb * over zero-length records. 171179237Sjb */ 172179237Sjb if (rec.dtrd_size == 0) { 173179237Sjb ASSERT(agg->dtag_hasarg); 174179237Sjb continue; 175179237Sjb } 176179237Sjb 177179237Sjb if (nrecs-- == 0) 178179237Sjb break; 179179237Sjb 180179237Sjb rec.dtrd_offset -= offs; 181179237Sjb bcopy(&rec, (void *)dest, sizeof (rec)); 182179237Sjb dest += sizeof (dtrace_recdesc_t); 183179237Sjb 184179237Sjb if (act == &agg->dtag_action) 185179237Sjb break; 186179237Sjb } 187179237Sjb 188179237Sjb mutex_exit(&dtrace_lock); 189179237Sjb 190179237Sjb if (copyout(buf, (void *) *paggdesc, dest - (uintptr_t)buf) != 0) { 191179237Sjb kmem_free(buf, size); 192179237Sjb return (EFAULT); 193179237Sjb } 194179237Sjb 195179237Sjb kmem_free(buf, size); 196179237Sjb return (0); 197179237Sjb } 198179237Sjb case DTRACEIOC_AGGSNAP: 199179237Sjb case DTRACEIOC_BUFSNAP: { 200179237Sjb dtrace_bufdesc_t **pdesc = (dtrace_bufdesc_t **) addr; 201179237Sjb dtrace_bufdesc_t desc; 202179237Sjb caddr_t cached; 203179237Sjb dtrace_buffer_t *buf; 204179237Sjb 205179237Sjb dtrace_debug_output(); 206179237Sjb 207179237Sjb if (copyin((void *) *pdesc, &desc, sizeof (desc)) != 0) 208179237Sjb return (EFAULT); 209179237Sjb 210179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): %s curcpu %d cpu %d\n", 211179237Sjb __func__,__LINE__, 212179237Sjb cmd == DTRACEIOC_AGGSNAP ? 213179237Sjb "DTRACEIOC_AGGSNAP":"DTRACEIOC_BUFSNAP", 214179237Sjb curcpu, desc.dtbd_cpu); 215179237Sjb 216246538Spluknet if (desc.dtbd_cpu >= NCPU) 217179237Sjb return (ENOENT); 218179237Sjb if (pcpu_find(desc.dtbd_cpu) == NULL) 219179237Sjb return (ENOENT); 220179237Sjb 221179237Sjb mutex_enter(&dtrace_lock); 222179237Sjb 223179237Sjb if (cmd == DTRACEIOC_BUFSNAP) { 224179237Sjb buf = &state->dts_buffer[desc.dtbd_cpu]; 225179237Sjb } else { 226179237Sjb buf = &state->dts_aggbuffer[desc.dtbd_cpu]; 227179237Sjb } 228179237Sjb 229179237Sjb if (buf->dtb_flags & (DTRACEBUF_RING | DTRACEBUF_FILL)) { 230179237Sjb size_t sz = buf->dtb_offset; 231179237Sjb 232179237Sjb if (state->dts_activity != DTRACE_ACTIVITY_STOPPED) { 233179237Sjb mutex_exit(&dtrace_lock); 234179237Sjb return (EBUSY); 235179237Sjb } 236179237Sjb 237179237Sjb /* 238179237Sjb * If this buffer has already been consumed, we're 239179237Sjb * going to indicate that there's nothing left here 240179237Sjb * to consume. 241179237Sjb */ 242179237Sjb if (buf->dtb_flags & DTRACEBUF_CONSUMED) { 243179237Sjb mutex_exit(&dtrace_lock); 244179237Sjb 245179237Sjb desc.dtbd_size = 0; 246179237Sjb desc.dtbd_drops = 0; 247179237Sjb desc.dtbd_errors = 0; 248179237Sjb desc.dtbd_oldest = 0; 249179237Sjb sz = sizeof (desc); 250179237Sjb 251179237Sjb if (copyout(&desc, (void *) *pdesc, sz) != 0) 252179237Sjb return (EFAULT); 253179237Sjb 254179237Sjb return (0); 255179237Sjb } 256179237Sjb 257179237Sjb /* 258179237Sjb * If this is a ring buffer that has wrapped, we want 259179237Sjb * to copy the whole thing out. 260179237Sjb */ 261179237Sjb if (buf->dtb_flags & DTRACEBUF_WRAPPED) { 262179237Sjb dtrace_buffer_polish(buf); 263179237Sjb sz = buf->dtb_size; 264179237Sjb } 265179237Sjb 266179237Sjb if (copyout(buf->dtb_tomax, desc.dtbd_data, sz) != 0) { 267179237Sjb mutex_exit(&dtrace_lock); 268179237Sjb return (EFAULT); 269179237Sjb } 270179237Sjb 271179237Sjb desc.dtbd_size = sz; 272179237Sjb desc.dtbd_drops = buf->dtb_drops; 273179237Sjb desc.dtbd_errors = buf->dtb_errors; 274179237Sjb desc.dtbd_oldest = buf->dtb_xamot_offset; 275250574Smarkj desc.dtbd_timestamp = dtrace_gethrtime(); 276179237Sjb 277179237Sjb mutex_exit(&dtrace_lock); 278179237Sjb 279179237Sjb if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 280179237Sjb return (EFAULT); 281179237Sjb 282179237Sjb buf->dtb_flags |= DTRACEBUF_CONSUMED; 283179237Sjb 284179237Sjb return (0); 285179237Sjb } 286179237Sjb 287179237Sjb if (buf->dtb_tomax == NULL) { 288179237Sjb ASSERT(buf->dtb_xamot == NULL); 289179237Sjb mutex_exit(&dtrace_lock); 290179237Sjb return (ENOENT); 291179237Sjb } 292179237Sjb 293179237Sjb cached = buf->dtb_tomax; 294179237Sjb ASSERT(!(buf->dtb_flags & DTRACEBUF_NOSWITCH)); 295179237Sjb 296179237Sjb dtrace_xcall(desc.dtbd_cpu, 297179237Sjb (dtrace_xcall_t)dtrace_buffer_switch, buf); 298179237Sjb 299179237Sjb state->dts_errors += buf->dtb_xamot_errors; 300179237Sjb 301179237Sjb /* 302179237Sjb * If the buffers did not actually switch, then the cross call 303179237Sjb * did not take place -- presumably because the given CPU is 304179237Sjb * not in the ready set. If this is the case, we'll return 305179237Sjb * ENOENT. 306179237Sjb */ 307179237Sjb if (buf->dtb_tomax == cached) { 308179237Sjb ASSERT(buf->dtb_xamot != cached); 309179237Sjb mutex_exit(&dtrace_lock); 310179237Sjb return (ENOENT); 311179237Sjb } 312179237Sjb 313179237Sjb ASSERT(cached == buf->dtb_xamot); 314179237Sjb 315179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): copyout the buffer snapshot\n",__func__,__LINE__); 316179237Sjb 317179237Sjb /* 318179237Sjb * We have our snapshot; now copy it out. 319179237Sjb */ 320179237Sjb if (copyout(buf->dtb_xamot, desc.dtbd_data, 321179237Sjb buf->dtb_xamot_offset) != 0) { 322179237Sjb mutex_exit(&dtrace_lock); 323179237Sjb return (EFAULT); 324179237Sjb } 325179237Sjb 326179237Sjb desc.dtbd_size = buf->dtb_xamot_offset; 327179237Sjb desc.dtbd_drops = buf->dtb_xamot_drops; 328179237Sjb desc.dtbd_errors = buf->dtb_xamot_errors; 329179237Sjb desc.dtbd_oldest = 0; 330250574Smarkj desc.dtbd_timestamp = buf->dtb_switched; 331179237Sjb 332179237Sjb mutex_exit(&dtrace_lock); 333179237Sjb 334179237Sjb 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); 335179237Sjb 336179237Sjb /* 337179237Sjb * Finally, copy out the buffer description. 338179237Sjb */ 339179237Sjb if (copyout(&desc, (void *) *pdesc, sizeof (desc)) != 0) 340179237Sjb return (EFAULT); 341179237Sjb 342179237Sjb return (0); 343179237Sjb } 344179237Sjb case DTRACEIOC_CONF: { 345179237Sjb dtrace_conf_t conf; 346179237Sjb 347179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_CONF\n",__func__,__LINE__); 348179237Sjb 349179237Sjb bzero(&conf, sizeof (conf)); 350179237Sjb conf.dtc_difversion = DIF_VERSION; 351179237Sjb conf.dtc_difintregs = DIF_DIR_NREGS; 352179237Sjb conf.dtc_diftupregs = DIF_DTR_NREGS; 353179237Sjb conf.dtc_ctfmodel = CTF_MODEL_NATIVE; 354179237Sjb 355179237Sjb *((dtrace_conf_t *) addr) = conf; 356179237Sjb 357179237Sjb return (0); 358179237Sjb } 359179237Sjb case DTRACEIOC_DOFGET: { 360179237Sjb dof_hdr_t **pdof = (dof_hdr_t **) addr; 361179237Sjb dof_hdr_t hdr, *dof = *pdof; 362179237Sjb int rval; 363179237Sjb uint64_t len; 364179237Sjb 365179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_DOFGET\n",__func__,__LINE__); 366179237Sjb 367179237Sjb if (copyin((void *)dof, &hdr, sizeof (hdr)) != 0) 368179237Sjb return (EFAULT); 369179237Sjb 370179237Sjb mutex_enter(&dtrace_lock); 371179237Sjb dof = dtrace_dof_create(state); 372179237Sjb mutex_exit(&dtrace_lock); 373179237Sjb 374179237Sjb len = MIN(hdr.dofh_loadsz, dof->dofh_loadsz); 375179237Sjb rval = copyout(dof, (void *) *pdof, len); 376179237Sjb dtrace_dof_destroy(dof); 377179237Sjb 378179237Sjb return (rval == 0 ? 0 : EFAULT); 379179237Sjb } 380179237Sjb case DTRACEIOC_ENABLE: { 381179237Sjb dof_hdr_t *dof = NULL; 382179237Sjb dtrace_enabling_t *enab = NULL; 383179237Sjb dtrace_vstate_t *vstate; 384179237Sjb int err = 0; 385179237Sjb int rval; 386179237Sjb dtrace_enable_io_t *p = (dtrace_enable_io_t *) addr; 387179237Sjb 388179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_ENABLE\n",__func__,__LINE__); 389179237Sjb 390179237Sjb /* 391179237Sjb * If a NULL argument has been passed, we take this as our 392179237Sjb * cue to reevaluate our enablings. 393179237Sjb */ 394179237Sjb if (p->dof == NULL) { 395179237Sjb dtrace_enabling_matchall(); 396179237Sjb 397179237Sjb return (0); 398179237Sjb } 399179237Sjb 400179237Sjb if ((dof = dtrace_dof_copyin((uintptr_t) p->dof, &rval)) == NULL) 401179237Sjb return (EINVAL); 402179237Sjb 403179237Sjb mutex_enter(&cpu_lock); 404179237Sjb mutex_enter(&dtrace_lock); 405179237Sjb vstate = &state->dts_vstate; 406179237Sjb 407179237Sjb if (state->dts_activity != DTRACE_ACTIVITY_INACTIVE) { 408179237Sjb mutex_exit(&dtrace_lock); 409179237Sjb mutex_exit(&cpu_lock); 410179237Sjb dtrace_dof_destroy(dof); 411179237Sjb return (EBUSY); 412179237Sjb } 413179237Sjb 414179237Sjb if (dtrace_dof_slurp(dof, vstate, td->td_ucred, &enab, 0, B_TRUE) != 0) { 415179237Sjb mutex_exit(&dtrace_lock); 416179237Sjb mutex_exit(&cpu_lock); 417179237Sjb dtrace_dof_destroy(dof); 418179237Sjb return (EINVAL); 419179237Sjb } 420179237Sjb 421179237Sjb if ((rval = dtrace_dof_options(dof, state)) != 0) { 422179237Sjb dtrace_enabling_destroy(enab); 423179237Sjb mutex_exit(&dtrace_lock); 424179237Sjb mutex_exit(&cpu_lock); 425179237Sjb dtrace_dof_destroy(dof); 426179237Sjb return (rval); 427179237Sjb } 428179237Sjb 429179237Sjb if ((err = dtrace_enabling_match(enab, &p->n_matched)) == 0) { 430179237Sjb err = dtrace_enabling_retain(enab); 431179237Sjb } else { 432179237Sjb dtrace_enabling_destroy(enab); 433179237Sjb } 434179237Sjb 435179237Sjb mutex_exit(&cpu_lock); 436179237Sjb mutex_exit(&dtrace_lock); 437179237Sjb dtrace_dof_destroy(dof); 438179237Sjb 439179237Sjb return (err); 440179237Sjb } 441179237Sjb case DTRACEIOC_EPROBE: { 442179237Sjb dtrace_eprobedesc_t **pepdesc = (dtrace_eprobedesc_t **) addr; 443179237Sjb dtrace_eprobedesc_t epdesc; 444179237Sjb dtrace_ecb_t *ecb; 445179237Sjb dtrace_action_t *act; 446179237Sjb void *buf; 447179237Sjb size_t size; 448179237Sjb uintptr_t dest; 449179237Sjb int nrecs; 450179237Sjb 451179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_EPROBE\n",__func__,__LINE__); 452179237Sjb 453179237Sjb if (copyin((void *)*pepdesc, &epdesc, sizeof (epdesc)) != 0) 454179237Sjb return (EFAULT); 455179237Sjb 456179237Sjb mutex_enter(&dtrace_lock); 457179237Sjb 458179237Sjb if ((ecb = dtrace_epid2ecb(state, epdesc.dtepd_epid)) == NULL) { 459179237Sjb mutex_exit(&dtrace_lock); 460179237Sjb return (EINVAL); 461179237Sjb } 462179237Sjb 463179237Sjb if (ecb->dte_probe == NULL) { 464179237Sjb mutex_exit(&dtrace_lock); 465179237Sjb return (EINVAL); 466179237Sjb } 467179237Sjb 468179237Sjb epdesc.dtepd_probeid = ecb->dte_probe->dtpr_id; 469179237Sjb epdesc.dtepd_uarg = ecb->dte_uarg; 470179237Sjb epdesc.dtepd_size = ecb->dte_size; 471179237Sjb 472179237Sjb nrecs = epdesc.dtepd_nrecs; 473179237Sjb epdesc.dtepd_nrecs = 0; 474179237Sjb for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 475179237Sjb if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 476179237Sjb continue; 477179237Sjb 478179237Sjb epdesc.dtepd_nrecs++; 479179237Sjb } 480179237Sjb 481179237Sjb /* 482179237Sjb * Now that we have the size, we need to allocate a temporary 483179237Sjb * buffer in which to store the complete description. We need 484179237Sjb * the temporary buffer to be able to drop dtrace_lock() 485179237Sjb * across the copyout(), below. 486179237Sjb */ 487179237Sjb size = sizeof (dtrace_eprobedesc_t) + 488179237Sjb (epdesc.dtepd_nrecs * sizeof (dtrace_recdesc_t)); 489179237Sjb 490179237Sjb buf = kmem_alloc(size, KM_SLEEP); 491179237Sjb dest = (uintptr_t)buf; 492179237Sjb 493179237Sjb bcopy(&epdesc, (void *)dest, sizeof (epdesc)); 494179237Sjb dest += offsetof(dtrace_eprobedesc_t, dtepd_rec[0]); 495179237Sjb 496179237Sjb for (act = ecb->dte_action; act != NULL; act = act->dta_next) { 497179237Sjb if (DTRACEACT_ISAGG(act->dta_kind) || act->dta_intuple) 498179237Sjb continue; 499179237Sjb 500179237Sjb if (nrecs-- == 0) 501179237Sjb break; 502179237Sjb 503179237Sjb bcopy(&act->dta_rec, (void *)dest, 504179237Sjb sizeof (dtrace_recdesc_t)); 505179237Sjb dest += sizeof (dtrace_recdesc_t); 506179237Sjb } 507179237Sjb 508179237Sjb mutex_exit(&dtrace_lock); 509179237Sjb 510179237Sjb if (copyout(buf, (void *) *pepdesc, dest - (uintptr_t)buf) != 0) { 511179237Sjb kmem_free(buf, size); 512179237Sjb return (EFAULT); 513179237Sjb } 514179237Sjb 515179237Sjb kmem_free(buf, size); 516179237Sjb return (0); 517179237Sjb } 518179237Sjb case DTRACEIOC_FORMAT: { 519179237Sjb dtrace_fmtdesc_t *fmt = (dtrace_fmtdesc_t *) addr; 520179237Sjb char *str; 521179237Sjb int len; 522179237Sjb 523179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_FORMAT\n",__func__,__LINE__); 524179237Sjb 525179237Sjb mutex_enter(&dtrace_lock); 526179237Sjb 527179237Sjb if (fmt->dtfd_format == 0 || 528179237Sjb fmt->dtfd_format > state->dts_nformats) { 529179237Sjb mutex_exit(&dtrace_lock); 530179237Sjb return (EINVAL); 531179237Sjb } 532179237Sjb 533179237Sjb /* 534179237Sjb * Format strings are allocated contiguously and they are 535179237Sjb * never freed; if a format index is less than the number 536179237Sjb * of formats, we can assert that the format map is non-NULL 537179237Sjb * and that the format for the specified index is non-NULL. 538179237Sjb */ 539179237Sjb ASSERT(state->dts_formats != NULL); 540179237Sjb str = state->dts_formats[fmt->dtfd_format - 1]; 541179237Sjb ASSERT(str != NULL); 542179237Sjb 543179237Sjb len = strlen(str) + 1; 544179237Sjb 545179237Sjb if (len > fmt->dtfd_length) { 546179237Sjb fmt->dtfd_length = len; 547179237Sjb } else { 548179237Sjb if (copyout(str, fmt->dtfd_string, len) != 0) { 549179237Sjb mutex_exit(&dtrace_lock); 550179237Sjb return (EINVAL); 551179237Sjb } 552179237Sjb } 553179237Sjb 554179237Sjb mutex_exit(&dtrace_lock); 555179237Sjb return (0); 556179237Sjb } 557179237Sjb case DTRACEIOC_GO: { 558179237Sjb int rval; 559179237Sjb processorid_t *cpuid = (processorid_t *) addr; 560179237Sjb 561179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_GO\n",__func__,__LINE__); 562179237Sjb 563179237Sjb rval = dtrace_state_go(state, cpuid); 564179237Sjb 565179237Sjb return (rval); 566179237Sjb } 567179237Sjb case DTRACEIOC_PROBEARG: { 568179237Sjb dtrace_argdesc_t *desc = (dtrace_argdesc_t *) addr; 569179237Sjb dtrace_probe_t *probe; 570179237Sjb dtrace_provider_t *prov; 571179237Sjb 572179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROBEARG\n",__func__,__LINE__); 573179237Sjb 574179237Sjb if (desc->dtargd_id == DTRACE_IDNONE) 575179237Sjb return (EINVAL); 576179237Sjb 577179237Sjb if (desc->dtargd_ndx == DTRACE_ARGNONE) 578179237Sjb return (EINVAL); 579179237Sjb 580179237Sjb mutex_enter(&dtrace_provider_lock); 581252850Smarkj#if defined(sun) 582179237Sjb mutex_enter(&mod_lock); 583252850Smarkj#endif 584179237Sjb mutex_enter(&dtrace_lock); 585179237Sjb 586179237Sjb if (desc->dtargd_id > dtrace_nprobes) { 587179237Sjb mutex_exit(&dtrace_lock); 588252850Smarkj#if defined(sun) 589179237Sjb mutex_exit(&mod_lock); 590252850Smarkj#endif 591179237Sjb mutex_exit(&dtrace_provider_lock); 592179237Sjb return (EINVAL); 593179237Sjb } 594179237Sjb 595179237Sjb if ((probe = dtrace_probes[desc->dtargd_id - 1]) == NULL) { 596179237Sjb mutex_exit(&dtrace_lock); 597252850Smarkj#if defined(sun) 598179237Sjb mutex_exit(&mod_lock); 599252850Smarkj#endif 600179237Sjb mutex_exit(&dtrace_provider_lock); 601179237Sjb return (EINVAL); 602179237Sjb } 603179237Sjb 604179237Sjb mutex_exit(&dtrace_lock); 605179237Sjb 606179237Sjb prov = probe->dtpr_provider; 607179237Sjb 608179237Sjb if (prov->dtpv_pops.dtps_getargdesc == NULL) { 609179237Sjb /* 610179237Sjb * There isn't any typed information for this probe. 611179237Sjb * Set the argument number to DTRACE_ARGNONE. 612179237Sjb */ 613179237Sjb desc->dtargd_ndx = DTRACE_ARGNONE; 614179237Sjb } else { 615179237Sjb desc->dtargd_native[0] = '\0'; 616179237Sjb desc->dtargd_xlate[0] = '\0'; 617179237Sjb desc->dtargd_mapping = desc->dtargd_ndx; 618179237Sjb 619179237Sjb prov->dtpv_pops.dtps_getargdesc(prov->dtpv_arg, 620179237Sjb probe->dtpr_id, probe->dtpr_arg, desc); 621179237Sjb } 622179237Sjb 623252850Smarkj#if defined(sun) 624179237Sjb mutex_exit(&mod_lock); 625252850Smarkj#endif 626179237Sjb mutex_exit(&dtrace_provider_lock); 627179237Sjb 628179237Sjb return (0); 629179237Sjb } 630179237Sjb case DTRACEIOC_PROBEMATCH: 631179237Sjb case DTRACEIOC_PROBES: { 632179237Sjb dtrace_probedesc_t *p_desc = (dtrace_probedesc_t *) addr; 633179237Sjb dtrace_probe_t *probe = NULL; 634179237Sjb dtrace_probekey_t pkey; 635179237Sjb dtrace_id_t i; 636179237Sjb int m = 0; 637179237Sjb uint32_t priv = 0; 638179237Sjb uid_t uid = 0; 639179237Sjb zoneid_t zoneid = 0; 640179237Sjb 641179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): %s\n",__func__,__LINE__, 642179237Sjb cmd == DTRACEIOC_PROBEMATCH ? 643179237Sjb "DTRACEIOC_PROBEMATCH":"DTRACEIOC_PROBES"); 644179237Sjb 645179237Sjb p_desc->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 646179237Sjb p_desc->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 647179237Sjb p_desc->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 648179237Sjb p_desc->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 649179237Sjb 650179237Sjb /* 651179237Sjb * Before we attempt to match this probe, we want to give 652179237Sjb * all providers the opportunity to provide it. 653179237Sjb */ 654179237Sjb if (p_desc->dtpd_id == DTRACE_IDNONE) { 655179237Sjb mutex_enter(&dtrace_provider_lock); 656179237Sjb dtrace_probe_provide(p_desc, NULL); 657179237Sjb mutex_exit(&dtrace_provider_lock); 658179237Sjb p_desc->dtpd_id++; 659179237Sjb } 660179237Sjb 661179237Sjb if (cmd == DTRACEIOC_PROBEMATCH) { 662179237Sjb dtrace_probekey(p_desc, &pkey); 663179237Sjb pkey.dtpk_id = DTRACE_IDNONE; 664179237Sjb } 665179237Sjb 666179237Sjb dtrace_cred2priv(td->td_ucred, &priv, &uid, &zoneid); 667179237Sjb 668179237Sjb mutex_enter(&dtrace_lock); 669179237Sjb 670179237Sjb if (cmd == DTRACEIOC_PROBEMATCH) { 671179237Sjb for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 672179237Sjb if ((probe = dtrace_probes[i - 1]) != NULL && 673179237Sjb (m = dtrace_match_probe(probe, &pkey, 674179237Sjb priv, uid, zoneid)) != 0) 675179237Sjb break; 676179237Sjb } 677179237Sjb 678179237Sjb if (m < 0) { 679179237Sjb mutex_exit(&dtrace_lock); 680179237Sjb return (EINVAL); 681179237Sjb } 682179237Sjb 683179237Sjb } else { 684179237Sjb for (i = p_desc->dtpd_id; i <= dtrace_nprobes; i++) { 685179237Sjb if ((probe = dtrace_probes[i - 1]) != NULL && 686179237Sjb dtrace_match_priv(probe, priv, uid, zoneid)) 687179237Sjb break; 688179237Sjb } 689179237Sjb } 690179237Sjb 691179237Sjb if (probe == NULL) { 692179237Sjb mutex_exit(&dtrace_lock); 693179237Sjb return (ESRCH); 694179237Sjb } 695179237Sjb 696179237Sjb dtrace_probe_description(probe, p_desc); 697179237Sjb mutex_exit(&dtrace_lock); 698179237Sjb 699179237Sjb return (0); 700179237Sjb } 701179237Sjb case DTRACEIOC_PROVIDER: { 702179237Sjb dtrace_providerdesc_t *pvd = (dtrace_providerdesc_t *) addr; 703179237Sjb dtrace_provider_t *pvp; 704179237Sjb 705179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_PROVIDER\n",__func__,__LINE__); 706179237Sjb 707179237Sjb pvd->dtvd_name[DTRACE_PROVNAMELEN - 1] = '\0'; 708179237Sjb mutex_enter(&dtrace_provider_lock); 709179237Sjb 710179237Sjb for (pvp = dtrace_provider; pvp != NULL; pvp = pvp->dtpv_next) { 711179237Sjb if (strcmp(pvp->dtpv_name, pvd->dtvd_name) == 0) 712179237Sjb break; 713179237Sjb } 714179237Sjb 715179237Sjb mutex_exit(&dtrace_provider_lock); 716179237Sjb 717179237Sjb if (pvp == NULL) 718179237Sjb return (ESRCH); 719179237Sjb 720179237Sjb bcopy(&pvp->dtpv_priv, &pvd->dtvd_priv, sizeof (dtrace_ppriv_t)); 721179237Sjb bcopy(&pvp->dtpv_attr, &pvd->dtvd_attr, sizeof (dtrace_pattr_t)); 722179237Sjb 723179237Sjb return (0); 724179237Sjb } 725179237Sjb case DTRACEIOC_REPLICATE: { 726179237Sjb dtrace_repldesc_t *desc = (dtrace_repldesc_t *) addr; 727179237Sjb dtrace_probedesc_t *match = &desc->dtrpd_match; 728179237Sjb dtrace_probedesc_t *create = &desc->dtrpd_create; 729179237Sjb int err; 730179237Sjb 731179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_REPLICATE\n",__func__,__LINE__); 732179237Sjb 733179237Sjb match->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 734179237Sjb match->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 735179237Sjb match->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 736179237Sjb match->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 737179237Sjb 738179237Sjb create->dtpd_provider[DTRACE_PROVNAMELEN - 1] = '\0'; 739179237Sjb create->dtpd_mod[DTRACE_MODNAMELEN - 1] = '\0'; 740179237Sjb create->dtpd_func[DTRACE_FUNCNAMELEN - 1] = '\0'; 741179237Sjb create->dtpd_name[DTRACE_NAMELEN - 1] = '\0'; 742179237Sjb 743179237Sjb mutex_enter(&dtrace_lock); 744179237Sjb err = dtrace_enabling_replicate(state, match, create); 745179237Sjb mutex_exit(&dtrace_lock); 746179237Sjb 747179237Sjb return (err); 748179237Sjb } 749179237Sjb case DTRACEIOC_STATUS: { 750179237Sjb dtrace_status_t *stat = (dtrace_status_t *) addr; 751179237Sjb dtrace_dstate_t *dstate; 752179237Sjb int i, j; 753179237Sjb uint64_t nerrs; 754179237Sjb 755179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STATUS\n",__func__,__LINE__); 756179237Sjb 757179237Sjb /* 758179237Sjb * See the comment in dtrace_state_deadman() for the reason 759179237Sjb * for setting dts_laststatus to INT64_MAX before setting 760179237Sjb * it to the correct value. 761179237Sjb */ 762179237Sjb state->dts_laststatus = INT64_MAX; 763179237Sjb dtrace_membar_producer(); 764179237Sjb state->dts_laststatus = dtrace_gethrtime(); 765179237Sjb 766179237Sjb bzero(stat, sizeof (*stat)); 767179237Sjb 768179237Sjb mutex_enter(&dtrace_lock); 769179237Sjb 770179237Sjb if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 771179237Sjb mutex_exit(&dtrace_lock); 772179237Sjb return (ENOENT); 773179237Sjb } 774179237Sjb 775179237Sjb if (state->dts_activity == DTRACE_ACTIVITY_DRAINING) 776179237Sjb stat->dtst_exiting = 1; 777179237Sjb 778179237Sjb nerrs = state->dts_errors; 779179237Sjb dstate = &state->dts_vstate.dtvs_dynvars; 780179237Sjb 781179237Sjb for (i = 0; i < NCPU; i++) { 782179237Sjb#if !defined(sun) 783179237Sjb if (pcpu_find(i) == NULL) 784179237Sjb continue; 785179237Sjb#endif 786179237Sjb dtrace_dstate_percpu_t *dcpu = &dstate->dtds_percpu[i]; 787179237Sjb 788179237Sjb stat->dtst_dyndrops += dcpu->dtdsc_drops; 789179237Sjb stat->dtst_dyndrops_dirty += dcpu->dtdsc_dirty_drops; 790179237Sjb stat->dtst_dyndrops_rinsing += dcpu->dtdsc_rinsing_drops; 791179237Sjb 792179237Sjb if (state->dts_buffer[i].dtb_flags & DTRACEBUF_FULL) 793179237Sjb stat->dtst_filled++; 794179237Sjb 795179237Sjb nerrs += state->dts_buffer[i].dtb_errors; 796179237Sjb 797179237Sjb for (j = 0; j < state->dts_nspeculations; j++) { 798179237Sjb dtrace_speculation_t *spec; 799179237Sjb dtrace_buffer_t *buf; 800179237Sjb 801179237Sjb spec = &state->dts_speculations[j]; 802179237Sjb buf = &spec->dtsp_buffer[i]; 803179237Sjb stat->dtst_specdrops += buf->dtb_xamot_drops; 804179237Sjb } 805179237Sjb } 806179237Sjb 807179237Sjb stat->dtst_specdrops_busy = state->dts_speculations_busy; 808179237Sjb stat->dtst_specdrops_unavail = state->dts_speculations_unavail; 809179237Sjb stat->dtst_stkstroverflows = state->dts_stkstroverflows; 810179237Sjb stat->dtst_dblerrors = state->dts_dblerrors; 811179237Sjb stat->dtst_killed = 812179237Sjb (state->dts_activity == DTRACE_ACTIVITY_KILLED); 813179237Sjb stat->dtst_errors = nerrs; 814179237Sjb 815179237Sjb mutex_exit(&dtrace_lock); 816179237Sjb 817179237Sjb return (0); 818179237Sjb } 819179237Sjb case DTRACEIOC_STOP: { 820179237Sjb int rval; 821179237Sjb processorid_t *cpuid = (processorid_t *) addr; 822179237Sjb 823179237Sjb DTRACE_IOCTL_PRINTF("%s(%d): DTRACEIOC_STOP\n",__func__,__LINE__); 824179237Sjb 825179237Sjb mutex_enter(&dtrace_lock); 826179237Sjb rval = dtrace_state_stop(state, cpuid); 827179237Sjb mutex_exit(&dtrace_lock); 828179237Sjb 829179237Sjb return (rval); 830179237Sjb } 831179237Sjb default: 832179237Sjb error = ENOTTY; 833179237Sjb } 834179237Sjb return (error); 835179237Sjb} 836