cddl/contrib/opensolaris/lib/libdtrace/common/dt_provider.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
  22 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 /*
  27  * Copyright (c) 2013, Joyent, Inc.  All rights reserved.
  28  */
  29
  30 #include <sys/types.h>
  31 #if defined(sun)
  32 #include <sys/sysmacros.h>
  33 #endif
  34
  35 #include <assert.h>
  36 #include <limits.h>
  37 #include <strings.h>
  38 #include <stdlib.h>
  39 #if defined(sun)
  40 #include <alloca.h>
  41 #endif
  42 #include <unistd.h>
  43 #include <errno.h>
  44
  45 #include <dt_provider.h>
  46 #include <dt_module.h>
  47 #include <dt_string.h>
  48 #include <dt_list.h>
  49 #include <dt_pid.h>
  50 #include <dtrace.h>
  51
  52 static dt_provider_t *
  53 dt_provider_insert(dtrace_hdl_t *dtp, dt_provider_t *pvp, uint_t h)
  54 {
  55         dt_list_append(&dtp->dt_provlist, pvp);
  56
  57         pvp->pv_next = dtp->dt_provs[h];
  58         dtp->dt_provs[h] = pvp;
  59         dtp->dt_nprovs++;
  60
  61         return (pvp);
  62 }
  63
  64 dt_provider_t *
  65 dt_provider_lookup(dtrace_hdl_t *dtp, const char *name)
  66 {
  67         uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_provbuckets;
  68         dtrace_providerdesc_t desc;
  69         dt_provider_t *pvp;
  70
  71         for (pvp = dtp->dt_provs[h]; pvp != NULL; pvp = pvp->pv_next) {
  72                 if (strcmp(pvp->pv_desc.dtvd_name, name) == 0)
  73                         return (pvp);
  74         }
  75
  76         if (strisglob(name) || name[0] == '\0') {
  77                 (void) dt_set_errno(dtp, EDT_NOPROV);
  78                 return (NULL);
  79         }
  80
  81         bzero(&desc, sizeof (desc));
  82         (void) strlcpy(desc.dtvd_name, name, DTRACE_PROVNAMELEN);
  83
  84         if (dt_ioctl(dtp, DTRACEIOC_PROVIDER, &desc) == -1) {
  85                 (void) dt_set_errno(dtp, errno == ESRCH ? EDT_NOPROV : errno);
  86                 return (NULL);
  87         }
  88
  89         if ((pvp = dt_provider_create(dtp, name)) == NULL)
  90                 return (NULL); /* dt_errno is set for us */
  91
  92         bcopy(&desc, &pvp->pv_desc, sizeof (desc));
  93         pvp->pv_flags |= DT_PROVIDER_IMPL;
  94         return (pvp);
  95 }
  96
  97 dt_provider_t *
  98 dt_provider_create(dtrace_hdl_t *dtp, const char *name)
  99 {
 100         dt_provider_t *pvp;
 101
 102         if ((pvp = dt_zalloc(dtp, sizeof (dt_provider_t))) == NULL)
 103                 return (NULL);
 104
 105         (void) strlcpy(pvp->pv_desc.dtvd_name, name, DTRACE_PROVNAMELEN);
 106         pvp->pv_probes = dt_idhash_create(pvp->pv_desc.dtvd_name, NULL, 0, 0);
 107         pvp->pv_gen = dtp->dt_gen;
 108         pvp->pv_hdl = dtp;
 109
 110         if (pvp->pv_probes == NULL) {
 111                 dt_free(dtp, pvp);
 112                 (void) dt_set_errno(dtp, EDT_NOMEM);
 113                 return (NULL);
 114         }
 115
 116         pvp->pv_desc.dtvd_attr.dtpa_provider = _dtrace_prvattr;
 117         pvp->pv_desc.dtvd_attr.dtpa_mod = _dtrace_prvattr;
 118         pvp->pv_desc.dtvd_attr.dtpa_func = _dtrace_prvattr;
 119         pvp->pv_desc.dtvd_attr.dtpa_name = _dtrace_prvattr;
 120         pvp->pv_desc.dtvd_attr.dtpa_args = _dtrace_prvattr;
 121
 122         return (dt_provider_insert(dtp, pvp,
 123             dt_strtab_hash(name, NULL) % dtp->dt_provbuckets));
 124 }
 125
 126 void
 127 dt_provider_destroy(dtrace_hdl_t *dtp, dt_provider_t *pvp)
 128 {
 129         dt_provider_t **pp;
 130         uint_t h;
 131
 132         assert(pvp->pv_hdl == dtp);
 133
 134         h = dt_strtab_hash(pvp->pv_desc.dtvd_name, NULL) % dtp->dt_provbuckets;
 135         pp = &dtp->dt_provs[h];
 136
 137         while (*pp != NULL && *pp != pvp)
 138                 pp = &(*pp)->pv_next;
 139
 140         assert(*pp != NULL && *pp == pvp);
 141         *pp = pvp->pv_next;
 142
 143         dt_list_delete(&dtp->dt_provlist, pvp);
 144         dtp->dt_nprovs--;
 145
 146         if (pvp->pv_probes != NULL)
 147                 dt_idhash_destroy(pvp->pv_probes);
 148
 149         dt_node_link_free(&pvp->pv_nodes);
 150         dt_free(dtp, pvp->pv_xrefs);
 151         dt_free(dtp, pvp);
 152 }
 153
 154 int
 155 dt_provider_xref(dtrace_hdl_t *dtp, dt_provider_t *pvp, id_t id)
 156 {
 157         size_t oldsize = BT_SIZEOFMAP(pvp->pv_xrmax);
 158         size_t newsize = BT_SIZEOFMAP(dtp->dt_xlatorid);
 159
 160         assert(id >= 0 && id < dtp->dt_xlatorid);
 161
 162         if (newsize > oldsize) {
 163                 ulong_t *xrefs = dt_zalloc(dtp, newsize);
 164
 165                 if (xrefs == NULL)
 166                         return (-1);
 167
 168                 bcopy(pvp->pv_xrefs, xrefs, oldsize);
 169                 dt_free(dtp, pvp->pv_xrefs);
 170
 171                 pvp->pv_xrefs = xrefs;
 172                 pvp->pv_xrmax = dtp->dt_xlatorid;
 173         }
 174
 175         BT_SET(pvp->pv_xrefs, id);
 176         return (0);
 177 }
 178
 179 static uint8_t
 180 dt_probe_argmap(dt_node_t *xnp, dt_node_t *nnp)
 181 {
 182         uint8_t i;
 183
 184         for (i = 0; nnp != NULL; i++) {
 185                 if (nnp->dn_string != NULL &&
 186                     strcmp(nnp->dn_string, xnp->dn_string) == 0)
 187                         break;
 188                 else
 189                         nnp = nnp->dn_list;
 190         }
 191
 192         return (i);
 193 }
 194
 195 static dt_node_t *
 196 dt_probe_alloc_args(dt_provider_t *pvp, int argc)
 197 {
 198         dt_node_t *args = NULL, *pnp = NULL, *dnp;
 199         int i;
 200
 201         for (i = 0; i < argc; i++, pnp = dnp) {
 202                 if ((dnp = dt_node_xalloc(pvp->pv_hdl, DT_NODE_TYPE)) == NULL)
 203                         return (NULL);
 204
 205                 dnp->dn_link = pvp->pv_nodes;
 206                 pvp->pv_nodes = dnp;
 207
 208                 if (args == NULL)
 209                         args = dnp;
 210                 else
 211                         pnp->dn_list = dnp;
 212         }
 213
 214         return (args);
 215 }
 216
 217 static size_t
 218 dt_probe_keylen(const dtrace_probedesc_t *pdp)
 219 {
 220         return (strlen(pdp->dtpd_mod) + 1 +
 221             strlen(pdp->dtpd_func) + 1 + strlen(pdp->dtpd_name) + 1);
 222 }
 223
 224 static char *
 225 dt_probe_key(const dtrace_probedesc_t *pdp, char *s)
 226 {
 227         (void) snprintf(s, INT_MAX, "%s:%s:%s",
 228             pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name);
 229         return (s);
 230 }
 231
 232 /*
 233  * If a probe was discovered from the kernel, ask dtrace(7D) for a description
 234  * of each of its arguments, including native and translated types.
 235  */
 236 static dt_probe_t *
 237 dt_probe_discover(dt_provider_t *pvp, const dtrace_probedesc_t *pdp)
 238 {
 239         dtrace_hdl_t *dtp = pvp->pv_hdl;
 240         char *name = dt_probe_key(pdp, alloca(dt_probe_keylen(pdp)));
 241
 242         dt_node_t *xargs, *nargs;
 243         dt_ident_t *idp;
 244         dt_probe_t *prp;
 245
 246         dtrace_typeinfo_t dtt;
 247         int i, nc, xc;
 248
 249         int adc = _dtrace_argmax;
 250         dtrace_argdesc_t *adv = alloca(sizeof (dtrace_argdesc_t) * adc);
 251         dtrace_argdesc_t *adp = adv;
 252
 253         assert(strcmp(pvp->pv_desc.dtvd_name, pdp->dtpd_provider) == 0);
 254         assert(pdp->dtpd_id != DTRACE_IDNONE);
 255
 256         dt_dprintf("discovering probe %s:%s id=%d\n",
 257             pvp->pv_desc.dtvd_name, name, pdp->dtpd_id);
 258
 259         for (nc = -1, i = 0; i < adc; i++, adp++) {
 260                 bzero(adp, sizeof (dtrace_argdesc_t));
 261                 adp->dtargd_ndx = i;
 262                 adp->dtargd_id = pdp->dtpd_id;
 263
 264                 if (dt_ioctl(dtp, DTRACEIOC_PROBEARG, adp) != 0) {
 265                         (void) dt_set_errno(dtp, errno);
 266                         return (NULL);
 267                 }
 268
 269                 if (adp->dtargd_ndx == DTRACE_ARGNONE)
 270                         break; /* all argument descs have been retrieved */
 271
 272                 nc = MAX(nc, adp->dtargd_mapping);
 273         }
 274
 275         xc = i;
 276         nc++;
 277
 278         /*
 279          * The pid provider believes in giving the kernel a break. No reason to
 280          * give the kernel all the ctf containers that we're keeping ourselves
 281          * just to get it back from it. So if we're coming from a pid provider
 282          * probe and the kernel gave us no argument information we'll get some
 283          * here. If for some crazy reason the kernel knows about our userland
 284          * types then we just ignore this.
 285          */
 286         if (xc == 0 && nc == 0 &&
 287             strncmp(pvp->pv_desc.dtvd_name, "pid", 3) == 0) {
 288                 nc = adc;
 289                 dt_pid_get_types(dtp, pdp, adv, &nc);
 290                 xc = nc;
 291         }
 292
 293         /*
 294          * Now that we have discovered the number of native and translated
 295          * arguments from the argument descriptions, allocate a new probe ident
 296          * and corresponding dt_probe_t and hash it into the provider.
 297          */
 298         xargs = dt_probe_alloc_args(pvp, xc);
 299         nargs = dt_probe_alloc_args(pvp, nc);
 300
 301         if ((xc != 0 && xargs == NULL) || (nc != 0 && nargs == NULL))
 302                 return (NULL); /* dt_errno is set for us */
 303
 304         idp = dt_ident_create(name, DT_IDENT_PROBE,
 305             DT_IDFLG_ORPHAN, pdp->dtpd_id, _dtrace_defattr, 0,
 306             &dt_idops_probe, NULL, dtp->dt_gen);
 307
 308         if (idp == NULL) {
 309                 (void) dt_set_errno(dtp, EDT_NOMEM);
 310                 return (NULL);
 311         }
 312
 313         if ((prp = dt_probe_create(dtp, idp, 2,
 314             nargs, nc, xargs, xc)) == NULL) {
 315                 dt_ident_destroy(idp);
 316                 return (NULL);
 317         }
 318
 319         dt_probe_declare(pvp, prp);
 320
 321         /*
 322          * Once our new dt_probe_t is fully constructed, iterate over the
 323          * cached argument descriptions and assign types to prp->pr_nargv[]
 324          * and prp->pr_xargv[] and assign mappings to prp->pr_mapping[].
 325          */
 326         for (adp = adv, i = 0; i < xc; i++, adp++) {
 327                 if (dtrace_type_strcompile(dtp,
 328                     adp->dtargd_native, &dtt) != 0) {
 329                         dt_dprintf("failed to resolve input type %s "
 330                             "for %s:%s arg #%d: %s\n", adp->dtargd_native,
 331                             pvp->pv_desc.dtvd_name, name, i + 1,
 332                             dtrace_errmsg(dtp, dtrace_errno(dtp)));
 333
 334                         dtt.dtt_object = NULL;
 335                         dtt.dtt_ctfp = NULL;
 336                         dtt.dtt_type = CTF_ERR;
 337                 } else {
 338                         dt_node_type_assign(prp->pr_nargv[adp->dtargd_mapping],
 339                             dtt.dtt_ctfp, dtt.dtt_type,
 340                             dtt.dtt_flags & DTT_FL_USER ? B_TRUE : B_FALSE);
 341                 }
 342
 343                 if (dtt.dtt_type != CTF_ERR && (adp->dtargd_xlate[0] == '\0' ||
 344                     strcmp(adp->dtargd_native, adp->dtargd_xlate) == 0)) {
 345                         dt_node_type_propagate(prp->pr_nargv[
 346                             adp->dtargd_mapping], prp->pr_xargv[i]);
 347                 } else if (dtrace_type_strcompile(dtp,
 348                     adp->dtargd_xlate, &dtt) != 0) {
 349                         dt_dprintf("failed to resolve output type %s "
 350                             "for %s:%s arg #%d: %s\n", adp->dtargd_xlate,
 351                             pvp->pv_desc.dtvd_name, name, i + 1,
 352                             dtrace_errmsg(dtp, dtrace_errno(dtp)));
 353
 354                         dtt.dtt_object = NULL;
 355                         dtt.dtt_ctfp = NULL;
 356                         dtt.dtt_type = CTF_ERR;
 357                 } else {
 358                         dt_node_type_assign(prp->pr_xargv[i],
 359                             dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
 360                 }
 361
 362                 prp->pr_mapping[i] = adp->dtargd_mapping;
 363                 prp->pr_argv[i] = dtt;
 364         }
 365
 366         return (prp);
 367 }
 368
 369 /*
 370  * Lookup a probe declaration based on a known provider and full or partially
 371  * specified module, function, and name.  If the probe is not known to us yet,
 372  * ask dtrace(7D) to match the description and then cache any useful results.
 373  */
 374 dt_probe_t *
 375 dt_probe_lookup(dt_provider_t *pvp, const char *s)
 376 {
 377         dtrace_hdl_t *dtp = pvp->pv_hdl;
 378         dtrace_probedesc_t pd;
 379         dt_ident_t *idp;
 380         size_t keylen;
 381         char *key;
 382
 383         if (dtrace_str2desc(dtp, DTRACE_PROBESPEC_NAME, s, &pd) != 0)
 384                 return (NULL); /* dt_errno is set for us */
 385
 386         keylen = dt_probe_keylen(&pd);
 387         key = dt_probe_key(&pd, alloca(keylen));
 388
 389         /*
 390          * If the probe is already declared, then return the dt_probe_t from
 391          * the existing identifier.  This could come from a static declaration
 392          * or it could have been cached from an earlier call to this function.
 393          */
 394         if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL)
 395                 return (idp->di_data);
 396
 397         /*
 398          * If the probe isn't known, use the probe description computed above
 399          * to ask dtrace(7D) to find the first matching probe.
 400          */
 401         if (dt_ioctl(dtp, DTRACEIOC_PROBEMATCH, &pd) == 0)
 402                 return (dt_probe_discover(pvp, &pd));
 403
 404         if (errno == ESRCH || errno == EBADF)
 405                 (void) dt_set_errno(dtp, EDT_NOPROBE);
 406         else
 407                 (void) dt_set_errno(dtp, errno);
 408
 409         return (NULL);
 410 }
 411
 412 dt_probe_t *
 413 dt_probe_create(dtrace_hdl_t *dtp, dt_ident_t *idp, int protoc,
 414     dt_node_t *nargs, uint_t nargc, dt_node_t *xargs, uint_t xargc)
 415 {
 416         dt_module_t *dmp;
 417         dt_probe_t *prp;
 418         const char *p;
 419         uint_t i;
 420
 421         assert(idp->di_kind == DT_IDENT_PROBE);
 422         assert(idp->di_data == NULL);
 423
 424         /*
 425          * If only a single prototype is given, set xargc/s to nargc/s to
 426          * simplify subsequent use.  Note that we can have one or both of nargs
 427          * and xargs be specified but set to NULL, indicating a void prototype.
 428          */
 429         if (protoc < 2) {
 430                 assert(xargs == NULL);
 431                 assert(xargc == 0);
 432                 xargs = nargs;
 433                 xargc = nargc;
 434         }
 435
 436         if ((prp = dt_alloc(dtp, sizeof (dt_probe_t))) == NULL)
 437                 return (NULL);
 438
 439         prp->pr_pvp = NULL;
 440         prp->pr_ident = idp;
 441
 442         p = strrchr(idp->di_name, ':');
 443         assert(p != NULL);
 444         prp->pr_name = p + 1;
 445
 446         prp->pr_nargs = nargs;
 447         prp->pr_nargv = dt_alloc(dtp, sizeof (dt_node_t *) * nargc);
 448         prp->pr_nargc = nargc;
 449         prp->pr_xargs = xargs;
 450         prp->pr_xargv = dt_alloc(dtp, sizeof (dt_node_t *) * xargc);
 451         prp->pr_xargc = xargc;
 452         prp->pr_mapping = dt_alloc(dtp, sizeof (uint8_t) * xargc);
 453         prp->pr_inst = NULL;
 454         prp->pr_argv = dt_alloc(dtp, sizeof (dtrace_typeinfo_t) * xargc);
 455         prp->pr_argc = xargc;
 456
 457         if ((prp->pr_nargc != 0 && prp->pr_nargv == NULL) ||
 458             (prp->pr_xargc != 0 && prp->pr_xargv == NULL) ||
 459             (prp->pr_xargc != 0 && prp->pr_mapping == NULL) ||
 460             (prp->pr_argc != 0 && prp->pr_argv == NULL)) {
 461                 dt_probe_destroy(prp);
 462                 return (NULL);
 463         }
 464
 465         for (i = 0; i < xargc; i++, xargs = xargs->dn_list) {
 466                 if (xargs->dn_string != NULL)
 467                         prp->pr_mapping[i] = dt_probe_argmap(xargs, nargs);
 468                 else
 469                         prp->pr_mapping[i] = i;
 470
 471                 prp->pr_xargv[i] = xargs;
 472
 473                 if ((dmp = dt_module_lookup_by_ctf(dtp,
 474                     xargs->dn_ctfp)) != NULL)
 475                         prp->pr_argv[i].dtt_object = dmp->dm_name;
 476                 else
 477                         prp->pr_argv[i].dtt_object = NULL;
 478
 479                 prp->pr_argv[i].dtt_ctfp = xargs->dn_ctfp;
 480                 prp->pr_argv[i].dtt_type = xargs->dn_type;
 481         }
 482
 483         for (i = 0; i < nargc; i++, nargs = nargs->dn_list)
 484                 prp->pr_nargv[i] = nargs;
 485
 486         idp->di_data = prp;
 487         return (prp);
 488 }
 489
 490 void
 491 dt_probe_declare(dt_provider_t *pvp, dt_probe_t *prp)
 492 {
 493         assert(prp->pr_ident->di_kind == DT_IDENT_PROBE);
 494         assert(prp->pr_ident->di_data == prp);
 495         assert(prp->pr_pvp == NULL);
 496
 497         if (prp->pr_xargs != prp->pr_nargs)
 498                 pvp->pv_flags &= ~DT_PROVIDER_INTF;
 499
 500         prp->pr_pvp = pvp;
 501         dt_idhash_xinsert(pvp->pv_probes, prp->pr_ident);
 502 }
 503
 504 void
 505 dt_probe_destroy(dt_probe_t *prp)
 506 {
 507         dt_probe_instance_t *pip, *pip_next;
 508         dtrace_hdl_t *dtp;
 509
 510         if (prp->pr_pvp != NULL)
 511                 dtp = prp->pr_pvp->pv_hdl;
 512         else
 513                 dtp = yypcb->pcb_hdl;
 514
 515         dt_node_list_free(&prp->pr_nargs);
 516         dt_node_list_free(&prp->pr_xargs);
 517
 518         dt_free(dtp, prp->pr_nargv);
 519         dt_free(dtp, prp->pr_xargv);
 520
 521         for (pip = prp->pr_inst; pip != NULL; pip = pip_next) {
 522                 pip_next = pip->pi_next;
 523                 dt_free(dtp, pip->pi_offs);
 524                 dt_free(dtp, pip->pi_enoffs);
 525                 dt_free(dtp, pip);
 526         }
 527
 528         dt_free(dtp, prp->pr_mapping);
 529         dt_free(dtp, prp->pr_argv);
 530         dt_free(dtp, prp);
 531 }
 532
 533 int
 534 dt_probe_define(dt_provider_t *pvp, dt_probe_t *prp,
 535     const char *fname, const char *rname, uint32_t offset, int isenabled)
 536 {
 537         dtrace_hdl_t *dtp = pvp->pv_hdl;
 538         dt_probe_instance_t *pip;
 539         uint32_t **offs;
 540         uint_t *noffs, *maxoffs;
 541
 542         assert(fname != NULL);
 543
 544         for (pip = prp->pr_inst; pip != NULL; pip = pip->pi_next) {
 545                 if (strcmp(pip->pi_fname, fname) == 0 &&
 546                     ((rname == NULL && pip->pi_rname[0] == '\0') ||
 547                     (rname != NULL && strcmp(pip->pi_rname, rname)) == 0))
 548                         break;
 549         }
 550
 551         if (pip == NULL) {
 552                 if ((pip = dt_zalloc(dtp, sizeof (*pip))) == NULL)
 553                         return (-1);
 554
 555                 if ((pip->pi_offs = dt_zalloc(dtp,
 556                     sizeof (uint32_t))) == NULL) {
 557                         dt_free(dtp, pip);
 558                         return (-1);
 559                 }
 560
 561                 if ((pip->pi_enoffs = dt_zalloc(dtp,
 562                     sizeof (uint32_t))) == NULL) {
 563                         dt_free(dtp, pip->pi_offs);
 564                         dt_free(dtp, pip);
 565                         return (-1);
 566                 }
 567
 568                 (void) strlcpy(pip->pi_fname, fname, sizeof (pip->pi_fname));
 569                 if (rname != NULL) {
 570                         if (strlen(rname) + 1 > sizeof (pip->pi_rname)) {
 571                                 dt_free(dtp, pip->pi_offs);
 572                                 dt_free(dtp, pip);
 573                                 return (dt_set_errno(dtp, EDT_COMPILER));
 574                         }
 575                         (void) strcpy(pip->pi_rname, rname);
 576                 }
 577
 578                 pip->pi_noffs = 0;
 579                 pip->pi_maxoffs = 1;
 580                 pip->pi_nenoffs = 0;
 581                 pip->pi_maxenoffs = 1;
 582
 583                 pip->pi_next = prp->pr_inst;
 584
 585                 prp->pr_inst = pip;
 586         }
 587
 588         if (isenabled) {
 589                 offs = &pip->pi_enoffs;
 590                 noffs = &pip->pi_nenoffs;
 591                 maxoffs = &pip->pi_maxenoffs;
 592         } else {
 593                 offs = &pip->pi_offs;
 594                 noffs = &pip->pi_noffs;
 595                 maxoffs = &pip->pi_maxoffs;
 596         }
 597
 598         if (*noffs == *maxoffs) {
 599                 uint_t new_max = *maxoffs * 2;
 600                 uint32_t *new_offs = dt_alloc(dtp, sizeof (uint32_t) * new_max);
 601
 602                 if (new_offs == NULL)
 603                         return (-1);
 604
 605                 bcopy(*offs, new_offs, sizeof (uint32_t) * *maxoffs);
 606
 607                 dt_free(dtp, *offs);
 608                 *maxoffs = new_max;
 609                 *offs = new_offs;
 610         }
 611
 612         dt_dprintf("defined probe %s %s:%s %s() +0x%x (%s)\n",
 613             isenabled ? "(is-enabled)" : "",
 614             pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, fname, offset,
 615             rname != NULL ? rname : fname);
 616
 617         assert(*noffs < *maxoffs);
 618         (*offs)[(*noffs)++] = offset;
 619
 620         return (0);
 621 }
 622
 623 /*
 624  * Lookup the dynamic translator type tag for the specified probe argument and
 625  * assign the type to the specified node.  If the type is not yet defined, add
 626  * it to the "D" module's type container as a typedef for an unknown type.
 627  */
 628 dt_node_t *
 629 dt_probe_tag(dt_probe_t *prp, uint_t argn, dt_node_t *dnp)
 630 {
 631         dtrace_hdl_t *dtp = prp->pr_pvp->pv_hdl;
 632         dtrace_typeinfo_t dtt;
 633         size_t len;
 634         char *tag;
 635
 636         len = snprintf(NULL, 0, "__dtrace_%s___%s_arg%u",
 637             prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
 638
 639         tag = alloca(len + 1);
 640
 641         (void) snprintf(tag, len + 1, "__dtrace_%s___%s_arg%u",
 642             prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
 643
 644         if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, tag, &dtt) != 0) {
 645                 dtt.dtt_object = DTRACE_OBJ_DDEFS;
 646                 dtt.dtt_ctfp = DT_DYN_CTFP(dtp);
 647                 dtt.dtt_type = ctf_add_typedef(DT_DYN_CTFP(dtp),
 648                     CTF_ADD_ROOT, tag, DT_DYN_TYPE(dtp));
 649
 650                 if (dtt.dtt_type == CTF_ERR ||
 651                     ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
 652                         xyerror(D_UNKNOWN, "cannot define type %s: %s\n",
 653                             tag, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
 654                 }
 655         }
 656
 657         bzero(dnp, sizeof (dt_node_t));
 658         dnp->dn_kind = DT_NODE_TYPE;
 659
 660         dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
 661         dt_node_attr_assign(dnp, _dtrace_defattr);
 662
 663         return (dnp);
 664 }
 665
 666 /*ARGSUSED*/
 667 static int
 668 dt_probe_desc(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg)
 669 {
 670         if (((dtrace_probedesc_t *)arg)->dtpd_id == DTRACE_IDNONE) {
 671                 bcopy(pdp, arg, sizeof (dtrace_probedesc_t));
 672                 return (0);
 673         }
 674
 675         return (1);
 676 }
 677
 678 dt_probe_t *
 679 dt_probe_info(dtrace_hdl_t *dtp,
 680     const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip)
 681 {
 682         int m_is_glob = pdp->dtpd_mod[0] == '\0' || strisglob(pdp->dtpd_mod);
 683         int f_is_glob = pdp->dtpd_func[0] == '\0' || strisglob(pdp->dtpd_func);
 684         int n_is_glob = pdp->dtpd_name[0] == '\0' || strisglob(pdp->dtpd_name);
 685
 686         dt_probe_t *prp = NULL;
 687         const dtrace_pattr_t *pap;
 688         dt_provider_t *pvp;
 689         dt_ident_t *idp;
 690
 691         /*
 692          * Attempt to lookup the probe in our existing cache for this provider.
 693          * If none is found and an explicit probe ID was specified, discover
 694          * that specific probe and cache its description and arguments.
 695          */
 696         if ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) != NULL) {
 697                 size_t keylen = dt_probe_keylen(pdp);
 698                 char *key = dt_probe_key(pdp, alloca(keylen));
 699
 700                 if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL)
 701                         prp = idp->di_data;
 702                 else if (pdp->dtpd_id != DTRACE_IDNONE)
 703                         prp = dt_probe_discover(pvp, pdp);
 704         }
 705
 706         /*
 707          * If no probe was found in our cache, convert the caller's partial
 708          * probe description into a fully-formed matching probe description by
 709          * iterating over up to at most two probes that match 'pdp'.  We then
 710          * call dt_probe_discover() on the resulting probe identifier.
 711          */
 712         if (prp == NULL) {
 713                 dtrace_probedesc_t pd;
 714                 int m;
 715
 716                 bzero(&pd, sizeof (pd));
 717                 pd.dtpd_id = DTRACE_IDNONE;
 718
 719                 /*
 720                  * Call dtrace_probe_iter() to find matching probes.  Our
 721                  * dt_probe_desc() callback will produce the following results:
 722                  *
 723                  * m < 0 dtrace_probe_iter() found zero matches (or failed).
 724                  * m > 0 dtrace_probe_iter() found more than one match.
 725                  * m = 0 dtrace_probe_iter() found exactly one match.
 726                  */
 727                 if ((m = dtrace_probe_iter(dtp, pdp, dt_probe_desc, &pd)) < 0)
 728                         return (NULL); /* dt_errno is set for us */
 729
 730                 if ((pvp = dt_provider_lookup(dtp, pd.dtpd_provider)) == NULL)
 731                         return (NULL); /* dt_errno is set for us */
 732
 733                 /*
 734                  * If more than one probe was matched, then do not report probe
 735                  * information if either of the following conditions is true:
 736                  *
 737                  * (a) The Arguments Data stability of the matched provider is
 738                  *      less than Evolving.
 739                  *
 740                  * (b) Any description component that is at least Evolving is
 741                  *      empty or is specified using a globbing expression.
 742                  *
 743                  * These conditions imply that providers that provide Evolving
 744                  * or better Arguments Data stability must guarantee that all
 745                  * probes with identical field names in a field of Evolving or
 746                  * better Name stability have identical argument signatures.
 747                  */
 748                 if (m > 0) {
 749                         if (pvp->pv_desc.dtvd_attr.dtpa_args.dtat_data <
 750                             DTRACE_STABILITY_EVOLVING) {
 751                                 (void) dt_set_errno(dtp, EDT_UNSTABLE);
 752                                 return (NULL);
 753                         }
 754
 755
 756                         if (pvp->pv_desc.dtvd_attr.dtpa_mod.dtat_name >=
 757                             DTRACE_STABILITY_EVOLVING && m_is_glob) {
 758                                 (void) dt_set_errno(dtp, EDT_UNSTABLE);
 759                                 return (NULL);
 760                         }
 761
 762                         if (pvp->pv_desc.dtvd_attr.dtpa_func.dtat_name >=
 763                             DTRACE_STABILITY_EVOLVING && f_is_glob) {
 764                                 (void) dt_set_errno(dtp, EDT_UNSTABLE);
 765                                 return (NULL);
 766                         }
 767
 768                         if (pvp->pv_desc.dtvd_attr.dtpa_name.dtat_name >=
 769                             DTRACE_STABILITY_EVOLVING && n_is_glob) {
 770                                 (void) dt_set_errno(dtp, EDT_UNSTABLE);
 771                                 return (NULL);
 772                         }
 773                 }
 774
 775                 /*
 776                  * If we matched a probe exported by dtrace(7D), then discover
 777                  * the real attributes.  Otherwise grab the static declaration.
 778                  */
 779                 if (pd.dtpd_id != DTRACE_IDNONE)
 780                         prp = dt_probe_discover(pvp, &pd);
 781                 else
 782                         prp = dt_probe_lookup(pvp, pd.dtpd_name);
 783
 784                 if (prp == NULL)
 785                         return (NULL); /* dt_errno is set for us */
 786         }
 787
 788         assert(pvp != NULL && prp != NULL);
 789
 790         /*
 791          * Compute the probe description attributes by taking the minimum of
 792          * the attributes of the specified fields.  If no provider is specified
 793          * or a glob pattern is used for the provider, use Unstable attributes.
 794          */
 795         if (pdp->dtpd_provider[0] == '\0' || strisglob(pdp->dtpd_provider))
 796                 pap = &_dtrace_prvdesc;
 797         else
 798                 pap = &pvp->pv_desc.dtvd_attr;
 799
 800         pip->dtp_attr = pap->dtpa_provider;
 801
 802         if (!m_is_glob)
 803                 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_mod);
 804         if (!f_is_glob)
 805                 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_func);
 806         if (!n_is_glob)
 807                 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_name);
 808
 809         pip->dtp_arga = pap->dtpa_args;
 810         pip->dtp_argv = prp->pr_argv;
 811         pip->dtp_argc = prp->pr_argc;
 812
 813         return (prp);
 814 }
 815
 816 int
 817 dtrace_probe_info(dtrace_hdl_t *dtp,
 818     const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip)
 819 {
 820         return (dt_probe_info(dtp, pdp, pip) != NULL ? 0 : -1);
 821 }
 822
 823 /*ARGSUSED*/
 824 static int
 825 dt_probe_iter(dt_idhash_t *ihp, dt_ident_t *idp, dt_probe_iter_t *pit)
 826 {
 827         const dt_probe_t *prp = idp->di_data;
 828
 829         if (!dt_gmatch(prp->pr_name, pit->pit_pat))
 830                 return (0); /* continue on and examine next probe in hash */
 831
 832         (void) strlcpy(pit->pit_desc.dtpd_name, prp->pr_name, DTRACE_NAMELEN);
 833         pit->pit_desc.dtpd_id = idp->di_id;
 834         pit->pit_matches++;
 835
 836         return (pit->pit_func(pit->pit_hdl, &pit->pit_desc, pit->pit_arg));
 837 }
 838
 839 int
 840 dtrace_probe_iter(dtrace_hdl_t *dtp,
 841     const dtrace_probedesc_t *pdp, dtrace_probe_f *func, void *arg)
 842 {
 843         const char *provider = pdp ? pdp->dtpd_provider : NULL;
 844         dtrace_id_t id = DTRACE_IDNONE;
 845
 846         dtrace_probedesc_t pd;
 847         dt_probe_iter_t pit;
 848         int cmd, rv;
 849
 850         bzero(&pit, sizeof (pit));
 851         pit.pit_hdl = dtp;
 852         pit.pit_func = func;
 853         pit.pit_arg = arg;
 854         pit.pit_pat = pdp ? pdp->dtpd_name : NULL;
 855
 856         for (pit.pit_pvp = dt_list_next(&dtp->dt_provlist);
 857             pit.pit_pvp != NULL; pit.pit_pvp = dt_list_next(pit.pit_pvp)) {
 858
 859                 if (pit.pit_pvp->pv_flags & DT_PROVIDER_IMPL)
 860                         continue; /* we'll get these later using dt_ioctl() */
 861
 862                 if (!dt_gmatch(pit.pit_pvp->pv_desc.dtvd_name, provider))
 863                         continue;
 864
 865                 (void) strlcpy(pit.pit_desc.dtpd_provider,
 866                     pit.pit_pvp->pv_desc.dtvd_name, DTRACE_PROVNAMELEN);
 867
 868                 if ((rv = dt_idhash_iter(pit.pit_pvp->pv_probes,
 869                     (dt_idhash_f *)dt_probe_iter, &pit)) != 0)
 870                         return (rv);
 871         }
 872
 873         if (pdp != NULL)
 874                 cmd = DTRACEIOC_PROBEMATCH;
 875         else
 876                 cmd = DTRACEIOC_PROBES;
 877
 878         for (;;) {
 879                 if (pdp != NULL)
 880                         bcopy(pdp, &pd, sizeof (pd));
 881
 882                 pd.dtpd_id = id;
 883
 884                 if (dt_ioctl(dtp, cmd, &pd) != 0)
 885                         break;
 886                 else if ((rv = func(dtp, &pd, arg)) != 0)
 887                         return (rv);
 888
 889                 pit.pit_matches++;
 890                 id = pd.dtpd_id + 1;
 891         }
 892
 893         switch (errno) {
 894         case ESRCH:
 895         case EBADF:
 896                 return (pit.pit_matches ? 0 : dt_set_errno(dtp, EDT_NOPROBE));
 897         case EINVAL:
 898                 return (dt_set_errno(dtp, EDT_BADPGLOB));
 899         default:
 900                 return (dt_set_errno(dtp, errno));
 901         }
 902 }