2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A
2N/A/*
2N/A * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
2N/A * Use is subject to license terms.
2N/A */
2N/A
2N/A#pragma ident "%Z%%M% %I% %E% SMI"
2N/A
2N/A#include <sys/types.h>
2N/A#include <sys/sysmacros.h>
2N/A
2N/A#include <assert.h>
2N/A#include <limits.h>
2N/A#include <strings.h>
2N/A#include <stdlib.h>
2N/A#include <alloca.h>
2N/A#include <unistd.h>
2N/A#include <errno.h>
2N/A
2N/A#include <dt_provider.h>
2N/A#include <dt_module.h>
2N/A#include <dt_string.h>
2N/A#include <dt_list.h>
2N/A
2N/Astatic dt_provider_t *
2N/Adt_provider_insert(dtrace_hdl_t *dtp, dt_provider_t *pvp, uint_t h)
2N/A{
2N/A dt_list_append(&dtp->dt_provlist, pvp);
2N/A
2N/A pvp->pv_next = dtp->dt_provs[h];
2N/A dtp->dt_provs[h] = pvp;
2N/A dtp->dt_nprovs++;
2N/A
2N/A return (pvp);
2N/A}
2N/A
2N/Adt_provider_t *
2N/Adt_provider_lookup(dtrace_hdl_t *dtp, const char *name)
2N/A{
2N/A uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_provbuckets;
2N/A dtrace_providerdesc_t desc;
2N/A dt_provider_t *pvp;
2N/A
2N/A for (pvp = dtp->dt_provs[h]; pvp != NULL; pvp = pvp->pv_next) {
2N/A if (strcmp(pvp->pv_desc.dtvd_name, name) == 0)
2N/A return (pvp);
2N/A }
2N/A
2N/A if (strisglob(name) || name[0] == '\0') {
2N/A (void) dt_set_errno(dtp, EDT_NOPROV);
2N/A return (NULL);
2N/A }
2N/A
2N/A bzero(&desc, sizeof (desc));
2N/A (void) strlcpy(desc.dtvd_name, name, DTRACE_PROVNAMELEN);
2N/A
2N/A if (dt_ioctl(dtp, DTRACEIOC_PROVIDER, &desc) == -1) {
2N/A (void) dt_set_errno(dtp, errno == ESRCH ? EDT_NOPROV : errno);
2N/A return (NULL);
2N/A }
2N/A
2N/A if ((pvp = dt_provider_create(dtp, name)) == NULL)
2N/A return (NULL); /* dt_errno is set for us */
2N/A
2N/A bcopy(&desc, &pvp->pv_desc, sizeof (desc));
2N/A pvp->pv_flags |= DT_PROVIDER_IMPL;
2N/A return (pvp);
2N/A}
2N/A
2N/Adt_provider_t *
2N/Adt_provider_create(dtrace_hdl_t *dtp, const char *name)
2N/A{
2N/A dt_provider_t *pvp;
2N/A
2N/A if ((pvp = dt_zalloc(dtp, sizeof (dt_provider_t))) == NULL)
2N/A return (NULL);
2N/A
2N/A (void) strlcpy(pvp->pv_desc.dtvd_name, name, DTRACE_PROVNAMELEN);
2N/A pvp->pv_probes = dt_idhash_create(pvp->pv_desc.dtvd_name, NULL, 0, 0);
2N/A pvp->pv_gen = dtp->dt_gen;
2N/A pvp->pv_hdl = dtp;
2N/A
2N/A if (pvp->pv_probes == NULL) {
2N/A dt_free(dtp, pvp);
2N/A (void) dt_set_errno(dtp, EDT_NOMEM);
2N/A return (NULL);
2N/A }
2N/A
2N/A pvp->pv_desc.dtvd_attr.dtpa_provider = _dtrace_prvattr;
2N/A pvp->pv_desc.dtvd_attr.dtpa_mod = _dtrace_prvattr;
2N/A pvp->pv_desc.dtvd_attr.dtpa_func = _dtrace_prvattr;
2N/A pvp->pv_desc.dtvd_attr.dtpa_name = _dtrace_prvattr;
2N/A pvp->pv_desc.dtvd_attr.dtpa_args = _dtrace_prvattr;
2N/A
2N/A return (dt_provider_insert(dtp, pvp,
2N/A dt_strtab_hash(name, NULL) % dtp->dt_provbuckets));
2N/A}
2N/A
2N/Avoid
2N/Adt_provider_destroy(dtrace_hdl_t *dtp, dt_provider_t *pvp)
2N/A{
2N/A dt_provider_t **pp;
2N/A uint_t h;
2N/A
2N/A assert(pvp->pv_hdl == dtp);
2N/A
2N/A h = dt_strtab_hash(pvp->pv_desc.dtvd_name, NULL) % dtp->dt_provbuckets;
2N/A pp = &dtp->dt_provs[h];
2N/A
2N/A while (*pp != NULL && *pp != pvp)
2N/A pp = &(*pp)->pv_next;
2N/A
2N/A assert(*pp != NULL && *pp == pvp);
2N/A *pp = pvp->pv_next;
2N/A
2N/A dt_list_delete(&dtp->dt_provlist, pvp);
2N/A dtp->dt_nprovs--;
2N/A
2N/A if (pvp->pv_probes != NULL)
2N/A dt_idhash_destroy(pvp->pv_probes);
2N/A
2N/A dt_node_link_free(&pvp->pv_nodes);
2N/A dt_free(dtp, pvp->pv_xrefs);
2N/A dt_free(dtp, pvp);
2N/A}
2N/A
2N/Aint
2N/Adt_provider_xref(dtrace_hdl_t *dtp, dt_provider_t *pvp, id_t id)
2N/A{
2N/A size_t oldsize = BT_SIZEOFMAP(pvp->pv_xrmax);
2N/A size_t newsize = BT_SIZEOFMAP(dtp->dt_xlatorid);
2N/A
2N/A assert(id >= 0 && id < dtp->dt_xlatorid);
2N/A
2N/A if (newsize > oldsize) {
2N/A ulong_t *xrefs = dt_zalloc(dtp, newsize);
2N/A
2N/A if (xrefs == NULL)
2N/A return (-1);
2N/A
2N/A bcopy(pvp->pv_xrefs, xrefs, oldsize);
2N/A dt_free(dtp, pvp->pv_xrefs);
2N/A
2N/A pvp->pv_xrefs = xrefs;
2N/A pvp->pv_xrmax = dtp->dt_xlatorid;
2N/A }
2N/A
2N/A BT_SET(pvp->pv_xrefs, id);
2N/A return (0);
2N/A}
2N/A
2N/Astatic uint8_t
2N/Adt_probe_argmap(dt_node_t *xnp, dt_node_t *nnp)
2N/A{
2N/A uint8_t i;
2N/A
2N/A for (i = 0; nnp != NULL; i++) {
2N/A if (nnp->dn_string != NULL &&
2N/A strcmp(nnp->dn_string, xnp->dn_string) == 0)
2N/A break;
2N/A else
2N/A nnp = nnp->dn_list;
2N/A }
2N/A
2N/A return (i);
2N/A}
2N/A
2N/Astatic dt_node_t *
2N/Adt_probe_alloc_args(dt_provider_t *pvp, int argc)
2N/A{
2N/A dt_node_t *args = NULL, *pnp = NULL, *dnp;
2N/A int i;
2N/A
2N/A for (i = 0; i < argc; i++, pnp = dnp) {
2N/A if ((dnp = dt_node_xalloc(pvp->pv_hdl, DT_NODE_TYPE)) == NULL)
2N/A return (NULL);
2N/A
2N/A dnp->dn_link = pvp->pv_nodes;
2N/A pvp->pv_nodes = dnp;
2N/A
2N/A if (args == NULL)
2N/A args = dnp;
2N/A else
2N/A pnp->dn_list = dnp;
2N/A }
2N/A
2N/A return (args);
2N/A}
2N/A
2N/Astatic size_t
2N/Adt_probe_keylen(const dtrace_probedesc_t *pdp)
2N/A{
2N/A return (strlen(pdp->dtpd_mod) + 1 +
2N/A strlen(pdp->dtpd_func) + 1 + strlen(pdp->dtpd_name) + 1);
2N/A}
2N/A
2N/Astatic char *
2N/Adt_probe_key(const dtrace_probedesc_t *pdp, char *s)
2N/A{
2N/A (void) snprintf(s, INT_MAX, "%s:%s:%s",
2N/A pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name);
2N/A return (s);
2N/A}
2N/A
2N/A/*
2N/A * If a probe was discovered from the kernel, ask dtrace(7D) for a description
2N/A * of each of its arguments, including native and translated types.
2N/A */
2N/Astatic dt_probe_t *
2N/Adt_probe_discover(dt_provider_t *pvp, const dtrace_probedesc_t *pdp)
2N/A{
2N/A dtrace_hdl_t *dtp = pvp->pv_hdl;
2N/A char *name = dt_probe_key(pdp, alloca(dt_probe_keylen(pdp)));
2N/A
2N/A dt_node_t *xargs, *nargs;
2N/A dt_ident_t *idp;
2N/A dt_probe_t *prp;
2N/A
2N/A dtrace_typeinfo_t dtt;
2N/A int i, nc, xc;
2N/A
2N/A int adc = _dtrace_argmax;
2N/A dtrace_argdesc_t *adv = alloca(sizeof (dtrace_argdesc_t) * adc);
2N/A dtrace_argdesc_t *adp = adv;
2N/A
2N/A assert(strcmp(pvp->pv_desc.dtvd_name, pdp->dtpd_provider) == 0);
2N/A assert(pdp->dtpd_id != DTRACE_IDNONE);
2N/A
2N/A dt_dprintf("discovering probe %s:%s id=%d\n",
2N/A pvp->pv_desc.dtvd_name, name, pdp->dtpd_id);
2N/A
2N/A for (nc = -1, i = 0; i < adc; i++, adp++) {
2N/A bzero(adp, sizeof (dtrace_argdesc_t));
2N/A adp->dtargd_ndx = i;
2N/A adp->dtargd_id = pdp->dtpd_id;
2N/A
2N/A if (dt_ioctl(dtp, DTRACEIOC_PROBEARG, adp) != 0) {
2N/A (void) dt_set_errno(dtp, errno);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (adp->dtargd_ndx == DTRACE_ARGNONE)
2N/A break; /* all argument descs have been retrieved */
2N/A
2N/A nc = MAX(nc, adp->dtargd_mapping);
2N/A }
2N/A
2N/A xc = i;
2N/A nc++;
2N/A
2N/A /*
2N/A * Now that we have discovered the number of native and translated
2N/A * arguments from the argument descriptions, allocate a new probe ident
2N/A * and corresponding dt_probe_t and hash it into the provider.
2N/A */
2N/A xargs = dt_probe_alloc_args(pvp, xc);
2N/A nargs = dt_probe_alloc_args(pvp, nc);
2N/A
2N/A if ((xc != 0 && xargs == NULL) || (nc != 0 && nargs == NULL))
2N/A return (NULL); /* dt_errno is set for us */
2N/A
2N/A idp = dt_ident_create(name, DT_IDENT_PROBE,
2N/A DT_IDFLG_ORPHAN, pdp->dtpd_id, _dtrace_defattr, 0,
2N/A &dt_idops_probe, NULL, dtp->dt_gen);
2N/A
2N/A if (idp == NULL) {
2N/A (void) dt_set_errno(dtp, EDT_NOMEM);
2N/A return (NULL);
2N/A }
2N/A
2N/A if ((prp = dt_probe_create(dtp, idp, 2,
2N/A nargs, nc, xargs, xc)) == NULL) {
2N/A dt_ident_destroy(idp);
2N/A return (NULL);
2N/A }
2N/A
2N/A dt_probe_declare(pvp, prp);
2N/A
2N/A /*
2N/A * Once our new dt_probe_t is fully constructed, iterate over the
2N/A * cached argument descriptions and assign types to prp->pr_nargv[]
2N/A * and prp->pr_xargv[] and assign mappings to prp->pr_mapping[].
2N/A */
2N/A for (adp = adv, i = 0; i < xc; i++, adp++) {
2N/A if (dtrace_type_strcompile(dtp,
2N/A adp->dtargd_native, &dtt) != 0) {
2N/A dt_dprintf("failed to resolve input type %s "
2N/A "for %s:%s arg #%d: %s\n", adp->dtargd_native,
2N/A pvp->pv_desc.dtvd_name, name, i + 1,
2N/A dtrace_errmsg(dtp, dtrace_errno(dtp)));
2N/A
2N/A dtt.dtt_object = NULL;
2N/A dtt.dtt_ctfp = NULL;
2N/A dtt.dtt_type = CTF_ERR;
2N/A } else {
2N/A dt_node_type_assign(prp->pr_nargv[adp->dtargd_mapping],
2N/A dtt.dtt_ctfp, dtt.dtt_type);
2N/A }
2N/A
2N/A if (dtt.dtt_type != CTF_ERR && (adp->dtargd_xlate[0] == '\0' ||
2N/A strcmp(adp->dtargd_native, adp->dtargd_xlate) == 0)) {
2N/A dt_node_type_propagate(prp->pr_nargv[
2N/A adp->dtargd_mapping], prp->pr_xargv[i]);
2N/A } else if (dtrace_type_strcompile(dtp,
2N/A adp->dtargd_xlate, &dtt) != 0) {
2N/A dt_dprintf("failed to resolve output type %s "
2N/A "for %s:%s arg #%d: %s\n", adp->dtargd_xlate,
2N/A pvp->pv_desc.dtvd_name, name, i + 1,
2N/A dtrace_errmsg(dtp, dtrace_errno(dtp)));
2N/A
2N/A dtt.dtt_object = NULL;
2N/A dtt.dtt_ctfp = NULL;
2N/A dtt.dtt_type = CTF_ERR;
2N/A } else {
2N/A dt_node_type_assign(prp->pr_xargv[i],
2N/A dtt.dtt_ctfp, dtt.dtt_type);
2N/A }
2N/A
2N/A prp->pr_mapping[i] = adp->dtargd_mapping;
2N/A prp->pr_argv[i] = dtt;
2N/A }
2N/A
2N/A return (prp);
2N/A}
2N/A
2N/A/*
2N/A * Lookup a probe declaration based on a known provider and full or partially
2N/A * specified module, function, and name. If the probe is not known to us yet,
2N/A * ask dtrace(7D) to match the description and then cache any useful results.
2N/A */
2N/Adt_probe_t *
2N/Adt_probe_lookup(dt_provider_t *pvp, const char *s)
2N/A{
2N/A dtrace_hdl_t *dtp = pvp->pv_hdl;
2N/A dtrace_probedesc_t pd;
2N/A dt_ident_t *idp;
2N/A size_t keylen;
2N/A char *key;
2N/A
2N/A if (dtrace_str2desc(dtp, DTRACE_PROBESPEC_NAME, s, &pd) != 0)
2N/A return (NULL); /* dt_errno is set for us */
2N/A
2N/A keylen = dt_probe_keylen(&pd);
2N/A key = dt_probe_key(&pd, alloca(keylen));
2N/A
2N/A /*
2N/A * If the probe is already declared, then return the dt_probe_t from
2N/A * the existing identifier. This could come from a static declaration
2N/A * or it could have been cached from an earlier call to this function.
2N/A */
2N/A if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL)
2N/A return (idp->di_data);
2N/A
2N/A /*
2N/A * If the probe isn't known, use the probe description computed above
2N/A * to ask dtrace(7D) to find the first matching probe.
2N/A */
2N/A if (dt_ioctl(dtp, DTRACEIOC_PROBEMATCH, &pd) == 0)
2N/A return (dt_probe_discover(pvp, &pd));
2N/A
2N/A if (errno == ESRCH || errno == EBADF)
2N/A (void) dt_set_errno(dtp, EDT_NOPROBE);
2N/A else
2N/A (void) dt_set_errno(dtp, errno);
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/Adt_probe_t *
2N/Adt_probe_create(dtrace_hdl_t *dtp, dt_ident_t *idp, int protoc,
2N/A dt_node_t *nargs, uint_t nargc, dt_node_t *xargs, uint_t xargc)
2N/A{
2N/A dt_module_t *dmp;
2N/A dt_probe_t *prp;
2N/A const char *p;
2N/A uint_t i;
2N/A
2N/A assert(idp->di_kind == DT_IDENT_PROBE);
2N/A assert(idp->di_data == NULL);
2N/A
2N/A /*
2N/A * If only a single prototype is given, set xargc/s to nargc/s to
2N/A * simplify subsequent use. Note that we can have one or both of nargs
2N/A * and xargs be specified but set to NULL, indicating a void prototype.
2N/A */
2N/A if (protoc < 2) {
2N/A assert(xargs == NULL);
2N/A assert(xargc == 0);
2N/A xargs = nargs;
2N/A xargc = nargc;
2N/A }
2N/A
2N/A if ((prp = dt_alloc(dtp, sizeof (dt_probe_t))) == NULL)
2N/A return (NULL);
2N/A
2N/A prp->pr_pvp = NULL;
2N/A prp->pr_ident = idp;
2N/A
2N/A p = strrchr(idp->di_name, ':');
2N/A assert(p != NULL);
2N/A prp->pr_name = p + 1;
2N/A
2N/A prp->pr_nargs = nargs;
2N/A prp->pr_nargv = dt_alloc(dtp, sizeof (dt_node_t *) * nargc);
2N/A prp->pr_nargc = nargc;
2N/A prp->pr_xargs = xargs;
2N/A prp->pr_xargv = dt_alloc(dtp, sizeof (dt_node_t *) * xargc);
2N/A prp->pr_xargc = xargc;
2N/A prp->pr_mapping = dt_alloc(dtp, sizeof (uint8_t) * xargc);
2N/A prp->pr_inst = NULL;
2N/A prp->pr_argv = dt_alloc(dtp, sizeof (dtrace_typeinfo_t) * xargc);
2N/A prp->pr_argc = xargc;
2N/A
2N/A if ((prp->pr_nargc != 0 && prp->pr_nargv == NULL) ||
2N/A (prp->pr_xargc != 0 && prp->pr_xargv == NULL) ||
2N/A (prp->pr_xargc != 0 && prp->pr_mapping == NULL) ||
2N/A (prp->pr_argc != 0 && prp->pr_argv == NULL)) {
2N/A dt_probe_destroy(prp);
2N/A return (NULL);
2N/A }
2N/A
2N/A for (i = 0; i < xargc; i++, xargs = xargs->dn_list) {
2N/A if (xargs->dn_string != NULL)
2N/A prp->pr_mapping[i] = dt_probe_argmap(xargs, nargs);
2N/A else
2N/A prp->pr_mapping[i] = i;
2N/A
2N/A prp->pr_xargv[i] = xargs;
2N/A
2N/A if ((dmp = dt_module_lookup_by_ctf(dtp,
2N/A xargs->dn_ctfp)) != NULL)
2N/A prp->pr_argv[i].dtt_object = dmp->dm_name;
2N/A else
2N/A prp->pr_argv[i].dtt_object = NULL;
2N/A
2N/A prp->pr_argv[i].dtt_ctfp = xargs->dn_ctfp;
2N/A prp->pr_argv[i].dtt_type = xargs->dn_type;
2N/A }
2N/A
2N/A for (i = 0; i < nargc; i++, nargs = nargs->dn_list)
2N/A prp->pr_nargv[i] = nargs;
2N/A
2N/A idp->di_data = prp;
2N/A return (prp);
2N/A}
2N/A
2N/Avoid
2N/Adt_probe_declare(dt_provider_t *pvp, dt_probe_t *prp)
2N/A{
2N/A assert(prp->pr_ident->di_kind == DT_IDENT_PROBE);
2N/A assert(prp->pr_ident->di_data == prp);
2N/A assert(prp->pr_pvp == NULL);
2N/A
2N/A if (prp->pr_xargs != prp->pr_nargs)
2N/A pvp->pv_flags &= ~DT_PROVIDER_INTF;
2N/A
2N/A prp->pr_pvp = pvp;
2N/A dt_idhash_xinsert(pvp->pv_probes, prp->pr_ident);
2N/A}
2N/A
2N/Avoid
2N/Adt_probe_destroy(dt_probe_t *prp)
2N/A{
2N/A dt_probe_instance_t *pip, *pip_next;
2N/A dtrace_hdl_t *dtp;
2N/A
2N/A if (prp->pr_pvp != NULL)
2N/A dtp = prp->pr_pvp->pv_hdl;
2N/A else
2N/A dtp = yypcb->pcb_hdl;
2N/A
2N/A dt_node_list_free(&prp->pr_nargs);
2N/A dt_node_list_free(&prp->pr_xargs);
2N/A
2N/A dt_free(dtp, prp->pr_nargv);
2N/A dt_free(dtp, prp->pr_xargv);
2N/A
2N/A for (pip = prp->pr_inst; pip != NULL; pip = pip_next) {
2N/A pip_next = pip->pi_next;
2N/A dt_free(dtp, pip->pi_offs);
2N/A dt_free(dtp, pip->pi_enoffs);
2N/A dt_free(dtp, pip);
2N/A }
2N/A
2N/A dt_free(dtp, prp->pr_mapping);
2N/A dt_free(dtp, prp->pr_argv);
2N/A dt_free(dtp, prp);
2N/A}
2N/A
2N/Aint
2N/Adt_probe_define(dt_provider_t *pvp, dt_probe_t *prp,
2N/A const char *fname, const char *rname, uint32_t offset, int isenabled)
2N/A{
2N/A dtrace_hdl_t *dtp = pvp->pv_hdl;
2N/A dt_probe_instance_t *pip;
2N/A uint32_t **offs;
2N/A uint_t *noffs, *maxoffs;
2N/A
2N/A assert(fname != NULL);
2N/A
2N/A for (pip = prp->pr_inst; pip != NULL; pip = pip->pi_next) {
2N/A if (strcmp(pip->pi_fname, fname) == 0 &&
2N/A ((rname == NULL && pip->pi_rname[0] == '\0') ||
2N/A (rname != NULL && strcmp(pip->pi_rname, rname)) == 0))
2N/A break;
2N/A }
2N/A
2N/A if (pip == NULL) {
2N/A if ((pip = dt_zalloc(dtp, sizeof (*pip))) == NULL)
2N/A return (-1);
2N/A
2N/A if ((pip->pi_offs = dt_zalloc(dtp,
2N/A sizeof (uint32_t))) == NULL) {
2N/A dt_free(dtp, pip);
2N/A return (-1);
2N/A }
2N/A
2N/A if ((pip->pi_enoffs = dt_zalloc(dtp,
2N/A sizeof (uint32_t))) == NULL) {
2N/A dt_free(dtp, pip->pi_offs);
2N/A dt_free(dtp, pip);
2N/A return (-1);
2N/A }
2N/A
2N/A (void) strlcpy(pip->pi_fname, fname, sizeof (pip->pi_fname));
2N/A if (rname != NULL) {
2N/A if (strlen(rname) + 1 > sizeof (pip->pi_rname)) {
2N/A dt_free(dtp, pip->pi_offs);
2N/A dt_free(dtp, pip);
2N/A return (dt_set_errno(dtp, EDT_COMPILER));
2N/A }
2N/A (void) strcpy(pip->pi_rname, rname);
2N/A }
2N/A
2N/A pip->pi_noffs = 0;
2N/A pip->pi_maxoffs = 1;
2N/A pip->pi_nenoffs = 0;
2N/A pip->pi_maxenoffs = 1;
2N/A
2N/A pip->pi_next = prp->pr_inst;
2N/A
2N/A prp->pr_inst = pip;
2N/A }
2N/A
2N/A if (isenabled) {
2N/A offs = &pip->pi_enoffs;
2N/A noffs = &pip->pi_nenoffs;
2N/A maxoffs = &pip->pi_maxenoffs;
2N/A } else {
2N/A offs = &pip->pi_offs;
2N/A noffs = &pip->pi_noffs;
2N/A maxoffs = &pip->pi_maxoffs;
2N/A }
2N/A
2N/A if (*noffs == *maxoffs) {
2N/A uint_t new_max = *maxoffs * 2;
2N/A uint32_t *new_offs = dt_alloc(dtp, sizeof (uint32_t) * new_max);
2N/A
2N/A if (new_offs == NULL)
2N/A return (-1);
2N/A
2N/A bcopy(*offs, new_offs, sizeof (uint32_t) * *maxoffs);
2N/A
2N/A dt_free(dtp, *offs);
2N/A *maxoffs = new_max;
2N/A *offs = new_offs;
2N/A }
2N/A
2N/A dt_dprintf("defined probe %s %s:%s %s() +0x%x (%s)\n",
2N/A isenabled ? "(is-enabled)" : "",
2N/A pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, fname, offset,
2N/A rname != NULL ? rname : fname);
2N/A
2N/A assert(*noffs < *maxoffs);
2N/A (*offs)[(*noffs)++] = offset;
2N/A
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Lookup the dynamic translator type tag for the specified probe argument and
2N/A * assign the type to the specified node. If the type is not yet defined, add
2N/A * it to the "D" module's type container as a typedef for an unknown type.
2N/A */
2N/Adt_node_t *
2N/Adt_probe_tag(dt_probe_t *prp, uint_t argn, dt_node_t *dnp)
2N/A{
2N/A dtrace_hdl_t *dtp = prp->pr_pvp->pv_hdl;
2N/A dtrace_typeinfo_t dtt;
2N/A size_t len;
2N/A char *tag;
2N/A
2N/A len = snprintf(NULL, 0, "__dtrace_%s___%s_arg%u",
2N/A prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
2N/A
2N/A tag = alloca(len + 1);
2N/A
2N/A (void) snprintf(tag, len + 1, "__dtrace_%s___%s_arg%u",
2N/A prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
2N/A
2N/A if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, tag, &dtt) != 0) {
2N/A dtt.dtt_object = DTRACE_OBJ_DDEFS;
2N/A dtt.dtt_ctfp = DT_DYN_CTFP(dtp);
2N/A dtt.dtt_type = ctf_add_typedef(DT_DYN_CTFP(dtp),
2N/A CTF_ADD_ROOT, tag, DT_DYN_TYPE(dtp));
2N/A
2N/A if (dtt.dtt_type == CTF_ERR ||
2N/A ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
2N/A xyerror(D_UNKNOWN, "cannot define type %s: %s\n",
2N/A tag, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
2N/A }
2N/A }
2N/A
2N/A bzero(dnp, sizeof (dt_node_t));
2N/A dnp->dn_kind = DT_NODE_TYPE;
2N/A
2N/A dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
2N/A dt_node_attr_assign(dnp, _dtrace_defattr);
2N/A
2N/A return (dnp);
2N/A}
2N/A
2N/A/*ARGSUSED*/
2N/Astatic int
2N/Adt_probe_desc(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg)
2N/A{
2N/A if (((dtrace_probedesc_t *)arg)->dtpd_id == DTRACE_IDNONE) {
2N/A bcopy(pdp, arg, sizeof (dtrace_probedesc_t));
2N/A return (0);
2N/A }
2N/A
2N/A return (1);
2N/A}
2N/A
2N/Adt_probe_t *
2N/Adt_probe_info(dtrace_hdl_t *dtp,
2N/A const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip)
2N/A{
2N/A int m_is_glob = pdp->dtpd_mod[0] == '\0' || strisglob(pdp->dtpd_mod);
2N/A int f_is_glob = pdp->dtpd_func[0] == '\0' || strisglob(pdp->dtpd_func);
2N/A int n_is_glob = pdp->dtpd_name[0] == '\0' || strisglob(pdp->dtpd_name);
2N/A
2N/A dt_probe_t *prp = NULL;
2N/A const dtrace_pattr_t *pap;
2N/A dt_provider_t *pvp;
2N/A dt_ident_t *idp;
2N/A
2N/A /*
2N/A * Attempt to lookup the probe in our existing cache for this provider.
2N/A * If none is found and an explicit probe ID was specified, discover
2N/A * that specific probe and cache its description and arguments.
2N/A */
2N/A if ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) != NULL) {
2N/A size_t keylen = dt_probe_keylen(pdp);
2N/A char *key = dt_probe_key(pdp, alloca(keylen));
2N/A
2N/A if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL)
2N/A prp = idp->di_data;
2N/A else if (pdp->dtpd_id != DTRACE_IDNONE)
2N/A prp = dt_probe_discover(pvp, pdp);
2N/A }
2N/A
2N/A /*
2N/A * If no probe was found in our cache, convert the caller's partial
2N/A * probe description into a fully-formed matching probe description by
2N/A * iterating over up to at most two probes that match 'pdp'. We then
2N/A * call dt_probe_discover() on the resulting probe identifier.
2N/A */
2N/A if (prp == NULL) {
2N/A dtrace_probedesc_t pd;
2N/A int m;
2N/A
2N/A bzero(&pd, sizeof (pd));
2N/A pd.dtpd_id = DTRACE_IDNONE;
2N/A
2N/A /*
2N/A * Call dtrace_probe_iter() to find matching probes. Our
2N/A * dt_probe_desc() callback will produce the following results:
2N/A *
2N/A * m < 0 dtrace_probe_iter() found zero matches (or failed).
2N/A * m > 0 dtrace_probe_iter() found more than one match.
2N/A * m = 0 dtrace_probe_iter() found exactly one match.
2N/A */
2N/A if ((m = dtrace_probe_iter(dtp, pdp, dt_probe_desc, &pd)) < 0)
2N/A return (NULL); /* dt_errno is set for us */
2N/A
2N/A if ((pvp = dt_provider_lookup(dtp, pd.dtpd_provider)) == NULL)
2N/A return (NULL); /* dt_errno is set for us */
2N/A
2N/A /*
2N/A * If more than one probe was matched, then do not report probe
2N/A * information if either of the following conditions is true:
2N/A *
2N/A * (a) The Arguments Data stability of the matched provider is
2N/A * less than Evolving.
2N/A *
2N/A * (b) Any description component that is at least Evolving is
2N/A * empty or is specified using a globbing expression.
2N/A *
2N/A * These conditions imply that providers that provide Evolving
2N/A * or better Arguments Data stability must guarantee that all
2N/A * probes with identical field names in a field of Evolving or
2N/A * better Name stability have identical argument signatures.
2N/A */
2N/A if (m > 0) {
2N/A if (pvp->pv_desc.dtvd_attr.dtpa_args.dtat_data <
2N/A DTRACE_STABILITY_EVOLVING) {
2N/A (void) dt_set_errno(dtp, EDT_UNSTABLE);
2N/A return (NULL);
2N/A }
2N/A
2N/A
2N/A if (pvp->pv_desc.dtvd_attr.dtpa_mod.dtat_name >=
2N/A DTRACE_STABILITY_EVOLVING && m_is_glob) {
2N/A (void) dt_set_errno(dtp, EDT_UNSTABLE);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (pvp->pv_desc.dtvd_attr.dtpa_func.dtat_name >=
2N/A DTRACE_STABILITY_EVOLVING && f_is_glob) {
2N/A (void) dt_set_errno(dtp, EDT_UNSTABLE);
2N/A return (NULL);
2N/A }
2N/A
2N/A if (pvp->pv_desc.dtvd_attr.dtpa_name.dtat_name >=
2N/A DTRACE_STABILITY_EVOLVING && n_is_glob) {
2N/A (void) dt_set_errno(dtp, EDT_UNSTABLE);
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * If we matched a probe exported by dtrace(7D), then discover
2N/A * the real attributes. Otherwise grab the static declaration.
2N/A */
2N/A if (pd.dtpd_id != DTRACE_IDNONE)
2N/A prp = dt_probe_discover(pvp, &pd);
2N/A else
2N/A prp = dt_probe_lookup(pvp, pd.dtpd_name);
2N/A
2N/A if (prp == NULL)
2N/A return (NULL); /* dt_errno is set for us */
2N/A }
2N/A
2N/A assert(pvp != NULL && prp != NULL);
2N/A
2N/A /*
2N/A * Compute the probe description attributes by taking the minimum of
2N/A * the attributes of the specified fields. If no provider is specified
2N/A * or a glob pattern is used for the provider, use Unstable attributes.
2N/A */
2N/A if (pdp->dtpd_provider[0] == '\0' || strisglob(pdp->dtpd_provider))
2N/A pap = &_dtrace_prvdesc;
2N/A else
2N/A pap = &pvp->pv_desc.dtvd_attr;
2N/A
2N/A pip->dtp_attr = pap->dtpa_provider;
2N/A
2N/A if (!m_is_glob)
2N/A pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_mod);
2N/A if (!f_is_glob)
2N/A pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_func);
2N/A if (!n_is_glob)
2N/A pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_name);
2N/A
2N/A pip->dtp_arga = pap->dtpa_args;
2N/A pip->dtp_argv = prp->pr_argv;
2N/A pip->dtp_argc = prp->pr_argc;
2N/A
2N/A return (prp);
2N/A}
2N/A
2N/Aint
2N/Adtrace_probe_info(dtrace_hdl_t *dtp,
2N/A const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip)
2N/A{
2N/A return (dt_probe_info(dtp, pdp, pip) != NULL ? 0 : -1);
2N/A}
2N/A
2N/A/*ARGSUSED*/
2N/Astatic int
2N/Adt_probe_iter(dt_idhash_t *ihp, dt_ident_t *idp, dt_probe_iter_t *pit)
2N/A{
2N/A const dt_probe_t *prp = idp->di_data;
2N/A
2N/A if (!dt_gmatch(prp->pr_name, pit->pit_pat))
2N/A return (0); /* continue on and examine next probe in hash */
2N/A
2N/A (void) strlcpy(pit->pit_desc.dtpd_name, prp->pr_name, DTRACE_NAMELEN);
2N/A pit->pit_desc.dtpd_id = idp->di_id;
2N/A pit->pit_matches++;
2N/A
2N/A return (pit->pit_func(pit->pit_hdl, &pit->pit_desc, pit->pit_arg));
2N/A}
2N/A
2N/Aint
2N/Adtrace_probe_iter(dtrace_hdl_t *dtp,
2N/A const dtrace_probedesc_t *pdp, dtrace_probe_f *func, void *arg)
2N/A{
2N/A const char *provider = pdp ? pdp->dtpd_provider : NULL;
2N/A dtrace_id_t id = DTRACE_IDNONE;
2N/A
2N/A dtrace_probedesc_t pd;
2N/A dt_probe_iter_t pit;
2N/A int cmd, rv;
2N/A
2N/A bzero(&pit, sizeof (pit));
2N/A pit.pit_hdl = dtp;
2N/A pit.pit_func = func;
2N/A pit.pit_arg = arg;
2N/A pit.pit_pat = pdp ? pdp->dtpd_name : NULL;
2N/A
2N/A for (pit.pit_pvp = dt_list_next(&dtp->dt_provlist);
2N/A pit.pit_pvp != NULL; pit.pit_pvp = dt_list_next(pit.pit_pvp)) {
2N/A
2N/A if (pit.pit_pvp->pv_flags & DT_PROVIDER_IMPL)
2N/A continue; /* we'll get these later using dt_ioctl() */
2N/A
2N/A if (!dt_gmatch(pit.pit_pvp->pv_desc.dtvd_name, provider))
2N/A continue;
2N/A
2N/A (void) strlcpy(pit.pit_desc.dtpd_provider,
2N/A pit.pit_pvp->pv_desc.dtvd_name, DTRACE_PROVNAMELEN);
2N/A
2N/A if ((rv = dt_idhash_iter(pit.pit_pvp->pv_probes,
2N/A (dt_idhash_f *)dt_probe_iter, &pit)) != 0)
2N/A return (rv);
2N/A }
2N/A
2N/A if (pdp != NULL)
2N/A cmd = DTRACEIOC_PROBEMATCH;
2N/A else
2N/A cmd = DTRACEIOC_PROBES;
2N/A
2N/A for (;;) {
2N/A if (pdp != NULL)
2N/A bcopy(pdp, &pd, sizeof (pd));
2N/A
2N/A pd.dtpd_id = id;
2N/A
2N/A if (dt_ioctl(dtp, cmd, &pd) != 0)
2N/A break;
2N/A else if ((rv = func(dtp, &pd, arg)) != 0)
2N/A return (rv);
2N/A
2N/A pit.pit_matches++;
2N/A id = pd.dtpd_id + 1;
2N/A }
2N/A
2N/A switch (errno) {
2N/A case ESRCH:
2N/A case EBADF:
2N/A return (pit.pit_matches ? 0 : dt_set_errno(dtp, EDT_NOPROBE));
2N/A case EINVAL:
2N/A return (dt_set_errno(dtp, EDT_BADPGLOB));
2N/A default:
2N/A return (dt_set_errno(dtp, errno));
2N/A }
2N/A}