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 *
dt_provider_insert(dtrace_hdl_t * dtp,dt_provider_t * pvp,uint_t h)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 *
dt_provider_lookup(dtrace_hdl_t * dtp,const char * name)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 *
dt_provider_create(dtrace_hdl_t * dtp,const char * name)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
dt_provider_destroy(dtrace_hdl_t * dtp,dt_provider_t * pvp)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
dt_provider_xref(dtrace_hdl_t * dtp,dt_provider_t * pvp,id_t id)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
dt_probe_argmap(dt_node_t * xnp,dt_node_t * nnp)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 *
dt_probe_alloc_args(dt_provider_t * pvp,int argc)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
dt_probe_keylen(const dtrace_probedesc_t * pdp)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 *
dt_probe_key(const dtrace_probedesc_t * pdp,char * s)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 *
dt_probe_discover(dt_provider_t * pvp,const dtrace_probedesc_t * pdp)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 *
dt_probe_lookup(dt_provider_t * pvp,const char * s)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 *
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)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
dt_probe_declare(dt_provider_t * pvp,dt_probe_t * prp)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
dt_probe_destroy(dt_probe_t * prp)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
dt_probe_define(dt_provider_t * pvp,dt_probe_t * prp,const char * fname,const char * rname,uint32_t offset,int isenabled)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 *
dt_probe_tag(dt_probe_t * prp,uint_t argn,dt_node_t * dnp)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
dt_probe_desc(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,void * arg)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 *
dt_probe_info(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probeinfo_t * pip)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
dtrace_probe_info(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probeinfo_t * pip)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
dt_probe_iter(dt_idhash_t * ihp,dt_ident_t * idp,dt_probe_iter_t * pit)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
dtrace_probe_iter(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_probe_f * func,void * arg)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 }
903