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