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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011 by Delphix. All rights reserved.
25 */
26
27 #include <unistd.h>
28 #include <strings.h>
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <assert.h>
32 #include <ctype.h>
33 #include <alloca.h>
34
35 #include <dt_impl.h>
36 #include <dt_program.h>
37 #include <dt_printf.h>
38 #include <dt_provider.h>
39
40 dtrace_prog_t *
41 dt_program_create(dtrace_hdl_t *dtp)
42 {
43 dtrace_prog_t *pgp = dt_zalloc(dtp, sizeof (dtrace_prog_t));
44
45 if (pgp != NULL) {
46 dt_list_append(&dtp->dt_programs, pgp);
47 } else {
48 (void) dt_set_errno(dtp, EDT_NOMEM);
49 return (NULL);
50 }
51
52 /*
53 * By default, programs start with DOF version 1 so that output files
54 * containing DOF are backward compatible. If a program requires new
55 * DOF features, the version is increased as needed.
56 */
57 pgp->dp_dofversion = DOF_VERSION_1;
58
59 return (pgp);
60 }
61
62 void
63 dt_program_destroy(dtrace_hdl_t *dtp, dtrace_prog_t *pgp)
64 {
65 dt_stmt_t *stp, *next;
66 uint_t i;
67
68 for (stp = dt_list_next(&pgp->dp_stmts); stp != NULL; stp = next) {
69 next = dt_list_next(stp);
70 dtrace_stmt_destroy(dtp, stp->ds_desc);
71 dt_free(dtp, stp);
72 }
73
74 for (i = 0; i < pgp->dp_xrefslen; i++)
75 dt_free(dtp, pgp->dp_xrefs[i]);
76
77 dt_free(dtp, pgp->dp_xrefs);
78 dt_list_delete(&dtp->dt_programs, pgp);
79 dt_free(dtp, pgp);
80 }
81
82 /*ARGSUSED*/
83 void
84 dtrace_program_info(dtrace_hdl_t *dtp, dtrace_prog_t *pgp,
85 dtrace_proginfo_t *pip)
86 {
87 dt_stmt_t *stp;
88 dtrace_actdesc_t *ap;
89 dtrace_ecbdesc_t *last = NULL;
90
91 if (pip == NULL)
92 return;
93
94 bzero(pip, sizeof (dtrace_proginfo_t));
95
96 if (dt_list_next(&pgp->dp_stmts) != NULL) {
97 pip->dpi_descattr = _dtrace_maxattr;
98 pip->dpi_stmtattr = _dtrace_maxattr;
99 } else {
100 pip->dpi_descattr = _dtrace_defattr;
101 pip->dpi_stmtattr = _dtrace_defattr;
102 }
103
104 for (stp = dt_list_next(&pgp->dp_stmts); stp; stp = dt_list_next(stp)) {
105 dtrace_ecbdesc_t *edp = stp->ds_desc->dtsd_ecbdesc;
106
107 if (edp == last)
108 continue;
109 last = edp;
110
111 pip->dpi_descattr =
112 dt_attr_min(stp->ds_desc->dtsd_descattr, pip->dpi_descattr);
113
114 pip->dpi_stmtattr =
115 dt_attr_min(stp->ds_desc->dtsd_stmtattr, pip->dpi_stmtattr);
116
117 /*
118 * If there aren't any actions, account for the fact that
119 * recording the epid will generate a record.
120 */
121 if (edp->dted_action == NULL)
122 pip->dpi_recgens++;
123
124 for (ap = edp->dted_action; ap != NULL; ap = ap->dtad_next) {
125 if (ap->dtad_kind == DTRACEACT_SPECULATE) {
126 pip->dpi_speculations++;
127 continue;
128 }
129
130 if (DTRACEACT_ISAGG(ap->dtad_kind)) {
131 pip->dpi_recgens -= ap->dtad_arg;
132 pip->dpi_aggregates++;
133 continue;
134 }
135
136 if (DTRACEACT_ISDESTRUCTIVE(ap->dtad_kind))
137 continue;
138
139 if (ap->dtad_kind == DTRACEACT_DIFEXPR &&
140 ap->dtad_difo->dtdo_rtype.dtdt_kind ==
141 DIF_TYPE_CTF &&
142 ap->dtad_difo->dtdo_rtype.dtdt_size == 0)
143 continue;
144
145 pip->dpi_recgens++;
146 }
147 }
148 }
149
150 int
151 dtrace_program_exec(dtrace_hdl_t *dtp, dtrace_prog_t *pgp,
152 dtrace_proginfo_t *pip)
153 {
154 void *dof;
155 int n, err;
156
157 dtrace_program_info(dtp, pgp, pip);
158
159 if ((dof = dtrace_dof_create(dtp, pgp, DTRACE_D_STRIP)) == NULL)
160 return (-1);
161
162 n = dt_ioctl(dtp, DTRACEIOC_ENABLE, dof);
163 dtrace_dof_destroy(dtp, dof);
164
165 if (n == -1) {
166 switch (errno) {
167 case EINVAL:
168 err = EDT_DIFINVAL;
169 break;
170 case EFAULT:
171 err = EDT_DIFFAULT;
172 break;
173 case E2BIG:
174 err = EDT_DIFSIZE;
175 break;
176 case EBUSY:
177 err = EDT_ENABLING_ERR;
178 break;
179 default:
180 err = errno;
181 }
182
183 return (dt_set_errno(dtp, err));
184 }
185
186 if (pip != NULL)
187 pip->dpi_matches += n;
188
189 return (0);
190 }
191
192 static void
193 dt_ecbdesc_hold(dtrace_ecbdesc_t *edp)
194 {
195 edp->dted_refcnt++;
196 }
197
198 void
199 dt_ecbdesc_release(dtrace_hdl_t *dtp, dtrace_ecbdesc_t *edp)
200 {
201 if (--edp->dted_refcnt > 0)
202 return;
203
204 dt_difo_free(dtp, edp->dted_pred.dtpdd_difo);
205 assert(edp->dted_action == NULL);
206 dt_free(dtp, edp);
207 }
208
209 dtrace_ecbdesc_t *
210 dt_ecbdesc_create(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp)
211 {
212 dtrace_ecbdesc_t *edp;
213
214 if ((edp = dt_zalloc(dtp, sizeof (dtrace_ecbdesc_t))) == NULL) {
215 (void) dt_set_errno(dtp, EDT_NOMEM);
216 return (NULL);
217 }
218
219 edp->dted_probe = *pdp;
220 dt_ecbdesc_hold(edp);
221 return (edp);
222 }
223
224 dtrace_stmtdesc_t *
225 dtrace_stmt_create(dtrace_hdl_t *dtp, dtrace_ecbdesc_t *edp)
226 {
227 dtrace_stmtdesc_t *sdp;
228
229 if ((sdp = dt_zalloc(dtp, sizeof (dtrace_stmtdesc_t))) == NULL)
230 return (NULL);
231
232 dt_ecbdesc_hold(edp);
233 sdp->dtsd_ecbdesc = edp;
234 sdp->dtsd_descattr = _dtrace_defattr;
235 sdp->dtsd_stmtattr = _dtrace_defattr;
236
237 return (sdp);
238 }
239
240 dtrace_actdesc_t *
241 dtrace_stmt_action(dtrace_hdl_t *dtp, dtrace_stmtdesc_t *sdp)
242 {
243 dtrace_actdesc_t *new;
244 dtrace_ecbdesc_t *edp = sdp->dtsd_ecbdesc;
245
246 if ((new = dt_alloc(dtp, sizeof (dtrace_actdesc_t))) == NULL)
247 return (NULL);
248
249 if (sdp->dtsd_action_last != NULL) {
250 assert(sdp->dtsd_action != NULL);
251 assert(sdp->dtsd_action_last->dtad_next == NULL);
252 sdp->dtsd_action_last->dtad_next = new;
253 } else {
254 dtrace_actdesc_t *ap = edp->dted_action;
255
256 assert(sdp->dtsd_action == NULL);
257 sdp->dtsd_action = new;
258
259 while (ap != NULL && ap->dtad_next != NULL)
260 ap = ap->dtad_next;
261
262 if (ap == NULL)
263 edp->dted_action = new;
264 else
265 ap->dtad_next = new;
266 }
267
268 sdp->dtsd_action_last = new;
269 bzero(new, sizeof (dtrace_actdesc_t));
270 new->dtad_uarg = (uintptr_t)sdp;
271
272 return (new);
273 }
274
275 int
276 dtrace_stmt_add(dtrace_hdl_t *dtp, dtrace_prog_t *pgp, dtrace_stmtdesc_t *sdp)
277 {
278 dt_stmt_t *stp = dt_alloc(dtp, sizeof (dt_stmt_t));
279
280 if (stp == NULL)
281 return (-1); /* errno is set for us */
282
283 dt_list_append(&pgp->dp_stmts, stp);
284 stp->ds_desc = sdp;
285
286 return (0);
287 }
288
289 int
290 dtrace_stmt_iter(dtrace_hdl_t *dtp, dtrace_prog_t *pgp,
291 dtrace_stmt_f *func, void *data)
292 {
293 dt_stmt_t *stp, *next;
294 int status = 0;
295
296 for (stp = dt_list_next(&pgp->dp_stmts); stp != NULL; stp = next) {
297 next = dt_list_next(stp);
298 if ((status = func(dtp, pgp, stp->ds_desc, data)) != 0)
299 break;
300 }
301
302 return (status);
303 }
304
305 void
306 dtrace_stmt_destroy(dtrace_hdl_t *dtp, dtrace_stmtdesc_t *sdp)
307 {
308 dtrace_ecbdesc_t *edp = sdp->dtsd_ecbdesc;
309
310 /*
311 * We need to remove any actions that we have on this ECB, and
312 * remove our hold on the ECB itself.
313 */
314 if (sdp->dtsd_action != NULL) {
315 dtrace_actdesc_t *last = sdp->dtsd_action_last;
316 dtrace_actdesc_t *ap, *next;
317
318 assert(last != NULL);
319
320 for (ap = edp->dted_action; ap != NULL; ap = ap->dtad_next) {
321 if (ap == sdp->dtsd_action)
322 break;
323
324 if (ap->dtad_next == sdp->dtsd_action)
325 break;
326 }
327
328 assert(ap != NULL);
329
330 if (ap == edp->dted_action)
331 edp->dted_action = last->dtad_next;
332 else
333 ap->dtad_next = last->dtad_next;
334
335 /*
336 * We have now removed our action list from its ECB; we can
337 * safely destroy the list.
338 */
339 last->dtad_next = NULL;
340
341 for (ap = sdp->dtsd_action; ap != NULL; ap = next) {
342 assert(ap->dtad_uarg == (uintptr_t)sdp);
343 dt_difo_free(dtp, ap->dtad_difo);
344 next = ap->dtad_next;
345 dt_free(dtp, ap);
346 }
347 }
348
349 if (sdp->dtsd_fmtdata != NULL)
350 dt_printf_destroy(sdp->dtsd_fmtdata);
351 dt_free(dtp, sdp->dtsd_strdata);
352
353 dt_ecbdesc_release(dtp, sdp->dtsd_ecbdesc);
354 dt_free(dtp, sdp);
355 }
356
357 typedef struct dt_header_info {
358 dtrace_hdl_t *dthi_dtp; /* consumer handle */
359 FILE *dthi_out; /* output file */
360 char *dthi_pmname; /* provider macro name */
361 char *dthi_pfname; /* provider function name */
362 int dthi_empty; /* should we generate empty macros */
363 } dt_header_info_t;
364
365 static void
366 dt_header_fmt_macro(char *buf, const char *str)
367 {
368 for (;;) {
369 if (islower(*str)) {
370 *buf++ = *str++ + 'A' - 'a';
371 } else if (*str == '-') {
372 *buf++ = '_';
373 str++;
374 } else if (*str == '.') {
375 *buf++ = '_';
376 str++;
377 } else if ((*buf++ = *str++) == '\0') {
378 break;
379 }
380 }
381 }
382
383 static void
384 dt_header_fmt_func(char *buf, const char *str)
385 {
386 for (;;) {
387 if (*str == '-') {
388 *buf++ = '_';
389 *buf++ = '_';
390 str++;
391 } else if ((*buf++ = *str++) == '\0') {
392 break;
393 }
394 }
395 }
396
397 /*ARGSUSED*/
398 static int
399 dt_header_decl(dt_idhash_t *dhp, dt_ident_t *idp, void *data)
400 {
401 dt_header_info_t *infop = data;
402 dtrace_hdl_t *dtp = infop->dthi_dtp;
403 dt_probe_t *prp = idp->di_data;
404 dt_node_t *dnp;
405 char buf[DT_TYPE_NAMELEN];
406 char *fname;
407 const char *p;
408 int i;
409
410 p = prp->pr_name;
411 for (i = 0; (p = strchr(p, '-')) != NULL; i++)
412 p++;
413
414 fname = alloca(strlen(prp->pr_name) + 1 + i);
415 dt_header_fmt_func(fname, prp->pr_name);
416
417 if (fprintf(infop->dthi_out, "extern void __dtrace_%s___%s(",
418 infop->dthi_pfname, fname) < 0)
419 return (dt_set_errno(dtp, errno));
420
421 for (dnp = prp->pr_nargs, i = 0; dnp != NULL; dnp = dnp->dn_list, i++) {
422 if (fprintf(infop->dthi_out, "%s",
423 ctf_type_name(dnp->dn_ctfp, dnp->dn_type,
424 buf, sizeof (buf))) < 0)
425 return (dt_set_errno(dtp, errno));
426
427 if (i + 1 != prp->pr_nargc &&
428 fprintf(infop->dthi_out, ", ") < 0)
429 return (dt_set_errno(dtp, errno));
430 }
431
432 if (i == 0 && fprintf(infop->dthi_out, "void") < 0)
433 return (dt_set_errno(dtp, errno));
434
435 if (fprintf(infop->dthi_out, ");\n") < 0)
436 return (dt_set_errno(dtp, errno));
437
438 if (fprintf(infop->dthi_out,
439 "#ifndef\t__sparc\n"
440 "extern int __dtraceenabled_%s___%s(void);\n"
441 "#else\n"
442 "extern int __dtraceenabled_%s___%s(long);\n"
443 "#endif\n",
444 infop->dthi_pfname, fname, infop->dthi_pfname, fname) < 0)
445 return (dt_set_errno(dtp, errno));
446
447 return (0);
448 }
449
450 /*ARGSUSED*/
451 static int
452 dt_header_probe(dt_idhash_t *dhp, dt_ident_t *idp, void *data)
453 {
454 dt_header_info_t *infop = data;
455 dtrace_hdl_t *dtp = infop->dthi_dtp;
456 dt_probe_t *prp = idp->di_data;
457 char *mname, *fname;
458 const char *p;
459 int i;
460
461 p = prp->pr_name;
462 for (i = 0; (p = strchr(p, '-')) != NULL; i++)
463 p++;
464
465 mname = alloca(strlen(prp->pr_name) + 1);
466 dt_header_fmt_macro(mname, prp->pr_name);
467
468 fname = alloca(strlen(prp->pr_name) + 1 + i);
469 dt_header_fmt_func(fname, prp->pr_name);
470
471 if (fprintf(infop->dthi_out, "#define\t%s_%s(",
472 infop->dthi_pmname, mname) < 0)
473 return (dt_set_errno(dtp, errno));
474
475 for (i = 0; i < prp->pr_nargc; i++) {
476 if (fprintf(infop->dthi_out, "arg%d", i) < 0)
477 return (dt_set_errno(dtp, errno));
478
479 if (i + 1 != prp->pr_nargc &&
480 fprintf(infop->dthi_out, ", ") < 0)
481 return (dt_set_errno(dtp, errno));
482 }
483
484 if (!infop->dthi_empty) {
485 if (fprintf(infop->dthi_out, ") \\\n\t") < 0)
486 return (dt_set_errno(dtp, errno));
487
488 if (fprintf(infop->dthi_out, "__dtrace_%s___%s(",
489 infop->dthi_pfname, fname) < 0)
490 return (dt_set_errno(dtp, errno));
491
492 for (i = 0; i < prp->pr_nargc; i++) {
493 if (fprintf(infop->dthi_out, "arg%d", i) < 0)
494 return (dt_set_errno(dtp, errno));
495
496 if (i + 1 != prp->pr_nargc &&
497 fprintf(infop->dthi_out, ", ") < 0)
498 return (dt_set_errno(dtp, errno));
499 }
500 }
501
502 if (fprintf(infop->dthi_out, ")\n") < 0)
503 return (dt_set_errno(dtp, errno));
504
505 if (!infop->dthi_empty) {
506 if (fprintf(infop->dthi_out,
507 "#ifndef\t__sparc\n"
508 "#define\t%s_%s_ENABLED() \\\n"
509 "\t__dtraceenabled_%s___%s()\n"
510 "#else\n"
511 "#define\t%s_%s_ENABLED() \\\n"
512 "\t__dtraceenabled_%s___%s(0)\n"
513 "#endif\n",
514 infop->dthi_pmname, mname,
515 infop->dthi_pfname, fname,
516 infop->dthi_pmname, mname,
517 infop->dthi_pfname, fname) < 0)
518 return (dt_set_errno(dtp, errno));
519
520 } else {
521 if (fprintf(infop->dthi_out, "#define\t%s_%s_ENABLED() (0)\n",
522 infop->dthi_pmname, mname) < 0)
523 return (dt_set_errno(dtp, errno));
524 }
525
526 return (0);
527 }
528
529 static int
530 dt_header_provider(dtrace_hdl_t *dtp, dt_provider_t *pvp, FILE *out)
531 {
532 dt_header_info_t info;
533 const char *p;
534 int i;
535
536 if (pvp->pv_flags & DT_PROVIDER_IMPL)
537 return (0);
538
539 /*
540 * Count the instances of the '-' character since we'll need to double
541 * those up.
542 */
543 p = pvp->pv_desc.dtvd_name;
544 for (i = 0; (p = strchr(p, '-')) != NULL; i++)
545 p++;
546
547 info.dthi_dtp = dtp;
548 info.dthi_out = out;
549 info.dthi_empty = 0;
550
551 info.dthi_pmname = alloca(strlen(pvp->pv_desc.dtvd_name) + 1);
552 dt_header_fmt_macro(info.dthi_pmname, pvp->pv_desc.dtvd_name);
553
554 info.dthi_pfname = alloca(strlen(pvp->pv_desc.dtvd_name) + 1 + i);
555 dt_header_fmt_func(info.dthi_pfname, pvp->pv_desc.dtvd_name);
556
557 if (fprintf(out, "#if _DTRACE_VERSION\n\n") < 0)
558 return (dt_set_errno(dtp, errno));
559
560 if (dt_idhash_iter(pvp->pv_probes, dt_header_probe, &info) != 0)
561 return (-1); /* dt_errno is set for us */
562 if (fprintf(out, "\n\n") < 0)
563 return (dt_set_errno(dtp, errno));
564 if (dt_idhash_iter(pvp->pv_probes, dt_header_decl, &info) != 0)
565 return (-1); /* dt_errno is set for us */
566
567 if (fprintf(out, "\n#else\n\n") < 0)
568 return (dt_set_errno(dtp, errno));
569
570 info.dthi_empty = 1;
571
572 if (dt_idhash_iter(pvp->pv_probes, dt_header_probe, &info) != 0)
573 return (-1); /* dt_errno is set for us */
574
575 if (fprintf(out, "\n#endif\n\n") < 0)
576 return (dt_set_errno(dtp, errno));
577
578 return (0);
579 }
580
581 int
582 dtrace_program_header(dtrace_hdl_t *dtp, FILE *out, const char *fname)
583 {
584 dt_provider_t *pvp;
585 char *mfname, *p;
586
587 if (fname != NULL) {
588 if ((p = strrchr(fname, '/')) != NULL)
589 fname = p + 1;
590
591 mfname = alloca(strlen(fname) + 1);
592 dt_header_fmt_macro(mfname, fname);
593 if (fprintf(out, "#ifndef\t_%s\n#define\t_%s\n\n",
594 mfname, mfname) < 0)
595 return (dt_set_errno(dtp, errno));
596 }
597
598 if (fprintf(out, "#include <unistd.h>\n\n") < 0)
599 return (-1);
600
601 if (fprintf(out, "#ifdef\t__cplusplus\nextern \"C\" {\n#endif\n\n") < 0)
602 return (-1);
603
604 for (pvp = dt_list_next(&dtp->dt_provlist);
605 pvp != NULL; pvp = dt_list_next(pvp)) {
606 if (dt_header_provider(dtp, pvp, out) != 0)
607 return (-1); /* dt_errno is set for us */
608 }
609
610 if (fprintf(out, "\n#ifdef\t__cplusplus\n}\n#endif\n") < 0)
611 return (dt_set_errno(dtp, errno));
612
613 if (fname != NULL && fprintf(out, "\n#endif\t/* _%s */\n", mfname) < 0)
614 return (dt_set_errno(dtp, errno));
615
616 return (0);
617 }