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