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 
48 static dt_provider_t *
dt_provider_insert(dtrace_hdl_t * dtp,dt_provider_t * pvp,uint_t h)49 dt_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 
60 dt_provider_t *
dt_provider_lookup(dtrace_hdl_t * dtp,const char * name)61 dt_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 
93 dt_provider_t *
dt_provider_create(dtrace_hdl_t * dtp,const char * name)94 dt_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 
122 void
dt_provider_destroy(dtrace_hdl_t * dtp,dt_provider_t * pvp)123 dt_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 
150 int
dt_provider_xref(dtrace_hdl_t * dtp,dt_provider_t * pvp,id_t id)151 dt_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 
175 static uint8_t
dt_probe_argmap(dt_node_t * xnp,dt_node_t * nnp)176 dt_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 
191 static dt_node_t *
dt_probe_alloc_args(dt_provider_t * pvp,int argc)192 dt_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 
213 static size_t
dt_probe_keylen(const dtrace_probedesc_t * pdp)214 dt_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 
220 static char *
dt_probe_key(const dtrace_probedesc_t * pdp,char * s)221 dt_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(4D) for a description
230  * of each of its arguments, including native and translated types.
231  */
232 static dt_probe_t *
dt_probe_discover(dt_provider_t * pvp,const dtrace_probedesc_t * pdp)233 dt_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(4D) to match the description and then cache any useful results.
369  */
370 dt_probe_t *
dt_probe_lookup(dt_provider_t * pvp,const char * s)371 dt_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(4D) 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 
408 dt_probe_t *
dt_probe_create(dtrace_hdl_t * dtp,dt_ident_t * idp,int protoc,dt_node_t * nargs,uint_t nargc,dt_node_t * xargs,uint_t xargc)409 dt_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 
486 void
dt_probe_declare(dt_provider_t * pvp,dt_probe_t * prp)487 dt_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 
500 void
dt_probe_destroy(dt_probe_t * prp)501 dt_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 
529 int
dt_probe_define(dt_provider_t * pvp,dt_probe_t * prp,const char * fname,const char * rname,uint32_t offset,int isenabled)530 dt_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  */
624 dt_node_t *
dt_probe_tag(dt_probe_t * prp,uint_t argn,dt_node_t * dnp)625 dt_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*/
663 static int
dt_probe_desc(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,void * arg)664 dt_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 
674 dt_probe_t *
dt_probe_info(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probeinfo_t * pip)675 dt_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(4D), 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 
812 int
dtrace_probe_info(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probeinfo_t * pip)813 dtrace_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*/
820 static int
dt_probe_iter(dt_idhash_t * ihp,dt_ident_t * idp,dt_probe_iter_t * pit)821 dt_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 
835 int
dtrace_probe_iter(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probe_f * func,void * arg)836 dtrace_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