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
40dtrace_prog_t *
41dt_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
62void
63dt_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*/
83void
84dtrace_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
150int
151dtrace_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
192static void
193dt_ecbdesc_hold(dtrace_ecbdesc_t *edp)
194{
195	edp->dted_refcnt++;
196}
197
198void
199dt_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
209dtrace_ecbdesc_t *
210dt_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
224dtrace_stmtdesc_t *
225dtrace_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
240dtrace_actdesc_t *
241dtrace_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
275int
276dtrace_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
289int
290dtrace_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
305void
306dtrace_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
357typedef 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
365static void
366dt_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
383static void
384dt_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*/
398static int
399dt_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*/
451static int
452dt_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
529static int
530dt_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
581int
582dtrace_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}
618