sys/cddl/dev/dtrace/dtrace_ioctl.c

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