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 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Copyright (c) 2011, Joyent Inc. All rights reserved.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <assert.h>
30 #include <strings.h>
31 #ifdef illumos
32 #include <alloca.h>
33 #endif
34 #include <fcntl.h>
35 #include <stdlib.h>
36 #include <stdio.h>
37 
38 #include <sys/types.h>
39 #include <sys/sysctl.h>
40 #include <sys/stat.h>
41 
42 #include <dt_parser.h>
43 #include <dt_impl.h>
44 #include <dt_provider.h>
45 #include <dt_module.h>
46 
47 /*
48  * This callback function is installed in a given identifier hash to search for
49  * and apply deferred pragmas that are pending for a given new identifier name.
50  * Multiple pragmas may be pending for a given name; we processs all of them.
51  */
52 /*ARGSUSED*/
53 static void
54 dt_pragma_apply(dt_idhash_t *dhp, dt_ident_t *idp)
55 {
56 	dt_idhash_t *php;
57 	dt_ident_t *pdp;
58 
59 	if ((php = yypcb->pcb_pragmas) == NULL)
60 		return; /* no pragmas pending for current compilation pass */
61 
62 	while ((pdp = dt_idhash_lookup(php, idp->di_name)) != NULL) {
63 		switch (pdp->di_kind) {
64 		case DT_IDENT_PRAGAT:
65 			idp->di_attr = pdp->di_attr;
66 			break;
67 		case DT_IDENT_PRAGBN:
68 			idp->di_vers = pdp->di_vers;
69 			break;
70 		}
71 		dt_idhash_delete(php, pdp);
72 	}
73 }
74 
75 /*
76  * The #pragma attributes directive can be used to reset stability attributes
77  * on a global identifier or inline definition.  If the identifier is already
78  * defined, we can just change di_attr.  If not, we insert the pragma into a
79  * hash table of the current pcb's deferred pragmas for later processing.
80  */
81 static void
82 dt_pragma_attributes(const char *prname, dt_node_t *dnp)
83 {
84 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
85 	dtrace_attribute_t attr, *a;
86 	dt_provider_t *pvp;
87 	const char *name, *part;
88 	dt_ident_t *idp;
89 
90 	if (dnp == NULL || dnp->dn_kind != DT_NODE_IDENT ||
91 	    dnp->dn_list == NULL || dnp->dn_list->dn_kind != DT_NODE_IDENT) {
92 		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
93 		    "<attributes> <ident>\n", prname);
94 	}
95 
96 	if (dtrace_str2attr(dnp->dn_string, &attr) == -1) {
97 		xyerror(D_PRAGMA_INVAL, "invalid attributes "
98 		    "specified by #pragma %s\n", prname);
99 	}
100 
101 	dnp = dnp->dn_list;
102 	name = dnp->dn_string;
103 
104 	if (strcmp(name, "provider") == 0) {
105 		dnp = dnp->dn_list;
106 		name = dnp->dn_string;
107 
108 		dnp = dnp->dn_list;
109 		part = dnp->dn_string;
110 
111 		if ((pvp = dt_provider_lookup(dtp, name)) != NULL) {
112 			if (strcmp(part, "provider") == 0) {
113 				a = &pvp->pv_desc.dtvd_attr.dtpa_provider;
114 			} else if (strcmp(part, "module") == 0) {
115 				a = &pvp->pv_desc.dtvd_attr.dtpa_mod;
116 			} else if (strcmp(part, "function") == 0) {
117 				a = &pvp->pv_desc.dtvd_attr.dtpa_func;
118 			} else if (strcmp(part, "name") == 0) {
119 				a = &pvp->pv_desc.dtvd_attr.dtpa_name;
120 			} else if (strcmp(part, "args") == 0) {
121 				a = &pvp->pv_desc.dtvd_attr.dtpa_args;
122 			} else {
123 				xyerror(D_PRAGMA_INVAL, "invalid component "
124 				    "\"%s\" in attribute #pragma "
125 				    "for provider %s\n", name, part);
126 			}
127 
128 			*a = attr;
129 			return;
130 		}
131 
132 	} else if ((idp = dt_idstack_lookup(
133 	    &yypcb->pcb_globals, name)) != NULL) {
134 
135 		if (idp->di_gen != dtp->dt_gen) {
136 			xyerror(D_PRAGMA_SCOPE, "#pragma %s cannot modify "
137 			    "entity defined outside program scope\n", prname);
138 		}
139 
140 		idp->di_attr = attr;
141 		return;
142 	}
143 
144 	if (yypcb->pcb_pragmas == NULL && (yypcb->pcb_pragmas =
145 	    dt_idhash_create("pragma", NULL, 0, 0)) == NULL)
146 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
147 
148 	idp = dt_idhash_insert(yypcb->pcb_pragmas, name, DT_IDENT_PRAGAT, 0, 0,
149 	    attr, 0, &dt_idops_thaw, (void *)prname, dtp->dt_gen);
150 
151 	if (idp == NULL)
152 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
153 
154 	if (dtp->dt_globals->dh_defer == NULL)
155 		dtp->dt_globals->dh_defer = &dt_pragma_apply;
156 }
157 
158 /*
159  * The #pragma binding directive can be used to reset the version binding
160  * on a global identifier or inline definition.  If the identifier is already
161  * defined, we can just change di_vers.  If not, we insert the pragma into a
162  * hash table of the current pcb's deferred pragmas for later processing.
163  */
164 static void
165 dt_pragma_binding(const char *prname, dt_node_t *dnp)
166 {
167 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
168 	dt_version_t vers;
169 	const char *name;
170 	dt_ident_t *idp;
171 
172 	if (dnp == NULL || dnp->dn_kind != DT_NODE_STRING ||
173 	    dnp->dn_list == NULL || dnp->dn_list->dn_kind != DT_NODE_IDENT) {
174 		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
175 		    "\"version\" <ident>\n", prname);
176 	}
177 
178 	if (dt_version_str2num(dnp->dn_string, &vers) == -1) {
179 		xyerror(D_PRAGMA_INVAL, "invalid version string "
180 		    "specified by #pragma %s\n", prname);
181 	}
182 
183 	name = dnp->dn_list->dn_string;
184 	idp = dt_idstack_lookup(&yypcb->pcb_globals, name);
185 
186 	if (idp != NULL) {
187 		if (idp->di_gen != dtp->dt_gen) {
188 			xyerror(D_PRAGMA_SCOPE, "#pragma %s cannot modify "
189 			    "entity defined outside program scope\n", prname);
190 		}
191 		idp->di_vers = vers;
192 		return;
193 	}
194 
195 	if (yypcb->pcb_pragmas == NULL && (yypcb->pcb_pragmas =
196 	    dt_idhash_create("pragma", NULL, 0, 0)) == NULL)
197 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
198 
199 	idp = dt_idhash_insert(yypcb->pcb_pragmas, name, DT_IDENT_PRAGBN, 0, 0,
200 	    _dtrace_defattr, vers, &dt_idops_thaw, (void *)prname, dtp->dt_gen);
201 
202 	if (idp == NULL)
203 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
204 
205 	if (dtp->dt_globals->dh_defer == NULL)
206 		dtp->dt_globals->dh_defer = &dt_pragma_apply;
207 }
208 
209 static void
210 dt_pragma_depends_finddep(dtrace_hdl_t *dtp, const char *lname, char *lib,
211     size_t len)
212 {
213 	dt_dirpath_t *dirp;
214 	struct stat sbuf;
215 	int found = 0;
216 
217 	for (dirp = dt_list_next(&dtp->dt_lib_path); dirp != NULL;
218 	    dirp = dt_list_next(dirp)) {
219 		(void) snprintf(lib, len, "%s/%s", dirp->dir_path, lname);
220 
221 		if (stat(lib, &sbuf) == 0) {
222 			found = 1;
223 			break;
224 		}
225 	}
226 
227 	if (!found)
228 		xyerror(D_PRAGMA_DEPEND,
229 		    "failed to find dependency in libpath: %s", lname);
230 }
231 
232 /*
233  * The #pragma depends_on directive can be used to express a dependency on a
234  * module, provider or library which if not present will cause processing to
235  * abort.
236  */
237 static void
238 dt_pragma_depends(const char *prname, dt_node_t *cnp)
239 {
240 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
241 	dt_node_t *nnp = cnp ? cnp->dn_list : NULL;
242 	int found;
243 	dt_lib_depend_t *dld;
244 	char lib[MAXPATHLEN];
245 	size_t plen;
246 	char *provs, *cpy, *tok;
247 
248 	if (cnp == NULL || nnp == NULL ||
249 	    cnp->dn_kind != DT_NODE_IDENT || nnp->dn_kind != DT_NODE_IDENT) {
250 		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
251 		    "<class> <name>\n", prname);
252 	}
253 
254 	if (strcmp(cnp->dn_string, "provider") == 0) {
255 		/*
256 		 * First try to get the provider list using the
257 		 * debug.dtrace.providers sysctl, since that'll work even if
258 		 * we're not running as root.
259 		 */
260 		provs = NULL;
261 		if (sysctlbyname("debug.dtrace.providers", NULL, &plen, NULL, 0) ||
262 		    ((provs = dt_alloc(dtp, plen)) == NULL) ||
263 		    sysctlbyname("debug.dtrace.providers", provs, &plen, NULL, 0))
264 			found = dt_provider_lookup(dtp, nnp->dn_string) != NULL;
265 		else {
266 			found = B_FALSE;
267 			for (cpy = provs; (tok = strsep(&cpy, " ")) != NULL; )
268 				if (strcmp(tok, nnp->dn_string) == 0) {
269 					found = B_TRUE;
270 					break;
271 				}
272 			if (found == B_FALSE)
273 				found = dt_provider_lookup(dtp,
274 				    nnp->dn_string) != NULL;
275 		}
276 		if (provs != NULL)
277 			dt_free(dtp, provs);
278 	} else if (strcmp(cnp->dn_string, "module") == 0) {
279 		dt_module_t *mp = dt_module_lookup_by_name(dtp, nnp->dn_string);
280 		found = mp != NULL && dt_module_getctf(dtp, mp) != NULL;
281 #ifdef __FreeBSD__
282 		if (!found) {
283 			dt_kmodule_t *dkmp = dt_kmodule_lookup(dtp,
284 			    nnp->dn_string);
285 			found = dkmp != NULL &&
286 			    dt_module_getctf(dtp, dkmp->dkm_module) != NULL;
287 		}
288 #endif
289 	} else if (strcmp(cnp->dn_string, "library") == 0) {
290 		if (yypcb->pcb_cflags & DTRACE_C_CTL) {
291 			assert(dtp->dt_filetag != NULL);
292 
293 			dt_pragma_depends_finddep(dtp, nnp->dn_string, lib,
294 			    sizeof (lib));
295 
296 			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep,
297 			    dtp->dt_filetag);
298 			assert(dld != NULL);
299 
300 			if ((dt_lib_depend_add(dtp, &dld->dtld_dependencies,
301 			    lib)) != 0) {
302 				xyerror(D_PRAGMA_DEPEND,
303 				    "failed to add dependency %s:%s\n", lib,
304 				    dtrace_errmsg(dtp, dtrace_errno(dtp)));
305 			}
306 		} else {
307 			/*
308 			 * By this point we have already performed a topological
309 			 * sort of the dependencies; we process this directive
310 			 * as satisfied as long as the dependency was properly
311 			 * loaded.
312 			 */
313 			if (dtp->dt_filetag == NULL)
314 				xyerror(D_PRAGMA_DEPEND, "main program may "
315 				    "not explicitly depend on a library");
316 
317 			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep,
318 			    dtp->dt_filetag);
319 			assert(dld != NULL);
320 
321 			dt_pragma_depends_finddep(dtp, nnp->dn_string, lib,
322 			    sizeof (lib));
323 			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep_sorted,
324 			    lib);
325 			assert(dld != NULL);
326 
327 			if (!dld->dtld_loaded)
328 				xyerror(D_PRAGMA_DEPEND, "program requires "
329 				    "library \"%s\" which failed to load",
330 				    lib);
331 		}
332 
333 		found = B_TRUE;
334 	} else {
335 		xyerror(D_PRAGMA_INVAL, "invalid class %s "
336 		    "specified by #pragma %s\n", cnp->dn_string, prname);
337 	}
338 
339 	if (!found) {
340 		xyerror(D_PRAGMA_DEPEND, "program requires %s %s\n",
341 		    cnp->dn_string, nnp->dn_string);
342 	}
343 }
344 
345 /*
346  * The #pragma error directive can be followed by any list of tokens, which we
347  * just concatenate and print as part of our error message.
348  */
349 static void
350 dt_pragma_error(const char *prname, dt_node_t *dnp)
351 {
352 	dt_node_t *enp;
353 	size_t n = 0;
354 	char *s;
355 
356 	for (enp = dnp; enp != NULL; enp = enp->dn_list) {
357 		if (enp->dn_kind == DT_NODE_IDENT ||
358 		    enp->dn_kind == DT_NODE_STRING)
359 			n += strlen(enp->dn_string) + 1;
360 	}
361 
362 	s = alloca(n + 1);
363 	s[0] = '\0';
364 
365 	for (enp = dnp; enp != NULL; enp = enp->dn_list) {
366 		if (enp->dn_kind == DT_NODE_IDENT ||
367 		    enp->dn_kind == DT_NODE_STRING) {
368 			(void) strcat(s, enp->dn_string);
369 			(void) strcat(s, " ");
370 		}
371 	}
372 
373 	xyerror(D_PRAGERR, "#%s: %s\n", prname, s);
374 }
375 
376 /*ARGSUSED*/
377 static void
378 dt_pragma_ident(const char *prname, dt_node_t *dnp)
379 {
380 	/* ignore any #ident or #pragma ident lines */
381 }
382 
383 static void
384 dt_pragma_option(const char *prname, dt_node_t *dnp)
385 {
386 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
387 	char *opt, *val;
388 
389 	if (dnp == NULL || dnp->dn_kind != DT_NODE_IDENT) {
390 		xyerror(D_PRAGMA_MALFORM,
391 		    "malformed #pragma %s <option>=<val>\n", prname);
392 	}
393 
394 	if (dnp->dn_list != NULL) {
395 		xyerror(D_PRAGMA_MALFORM,
396 		    "superfluous arguments specified for #pragma %s\n", prname);
397 	}
398 
399 	opt = alloca(strlen(dnp->dn_string) + 1);
400 	(void) strcpy(opt, dnp->dn_string);
401 
402 	if ((val = strchr(opt, '=')) != NULL)
403 		*val++ = '\0';
404 
405 	if (dtrace_setopt(dtp, opt, val) == -1) {
406 		if (val == NULL) {
407 			xyerror(D_PRAGMA_OPTSET,
408 			    "failed to set option '%s': %s\n", opt,
409 			    dtrace_errmsg(dtp, dtrace_errno(dtp)));
410 		} else {
411 			xyerror(D_PRAGMA_OPTSET,
412 			    "failed to set option '%s' to '%s': %s\n",
413 			    opt, val, dtrace_errmsg(dtp, dtrace_errno(dtp)));
414 		}
415 	}
416 }
417 
418 /*
419  * The #line directive is used to reset the input line number and to optionally
420  * note the file name for use in error messages.  Sun cpp(1) also produces a
421  * third integer token after the filename which is one of the following:
422  *
423  * 0 - line change has nothing to do with an #include file
424  * 1 - line change because we just entered a #include file
425  * 2 - line change because we just exited a #include file
426  *
427  * We use these state tokens to adjust pcb_idepth, which in turn controls
428  * whether type lookups access the global type space or not.
429  */
430 static void
431 dt_pragma_line(const char *prname, dt_node_t *dnp)
432 {
433 	dt_node_t *fnp = dnp ? dnp->dn_list : NULL;
434 	dt_node_t *inp = fnp ? fnp->dn_list : NULL;
435 
436 	if ((dnp == NULL || dnp->dn_kind != DT_NODE_INT) ||
437 	    (fnp != NULL && fnp->dn_kind != DT_NODE_STRING) ||
438 	    (inp != NULL && inp->dn_kind != DT_NODE_INT)) {
439 		xyerror(D_PRAGMA_MALFORM, "malformed #%s "
440 		    "<line> [ [\"file\"] state ]\n", prname);
441 	}
442 
443 	/*
444 	 * If a file is specified, free any old pcb_filetag and swap fnp's
445 	 * dn_string into pcb_filetag as the new filename for error messages.
446 	 */
447 	if (fnp != NULL) {
448 		if (yypcb->pcb_filetag != NULL)
449 			free(yypcb->pcb_filetag);
450 
451 		/*
452 		 * This is not pretty, but is a necessary evil until we either
453 		 * write "dpp" or get a useful standalone cpp from DevPro.  If
454 		 * the filename begins with /dev/fd, we know it's the master
455 		 * input file (see dt_preproc() in dt_cc.c), so just clear the
456 		 * dt_filetag pointer so error messages refer to the main file.
457 		 */
458 		if (strncmp(fnp->dn_string, "/dev/fd/", 8) != 0) {
459 			yypcb->pcb_filetag = fnp->dn_string;
460 			fnp->dn_string = NULL;
461 		} else
462 			yypcb->pcb_filetag = NULL;
463 	}
464 
465 	if (inp != NULL) {
466 		if (inp->dn_value == 1)
467 			yypcb->pcb_idepth++;
468 		else if (inp->dn_value == 2 && yypcb->pcb_idepth != 0)
469 			yypcb->pcb_idepth--;
470 	}
471 
472 	yylineno = dnp->dn_value;
473 }
474 
475 /*
476  * D compiler pragma types range from control directives to common pragmas to
477  * D custom pragmas, in order of specificity.  Similar to gcc, we use #pragma D
478  * as a special prefix for our pragmas so they can be used in mixed headers.
479  */
480 #define	DT_PRAGMA_DIR	0	/* pragma directive may be used after naked # */
481 #define	DT_PRAGMA_SUB	1	/* pragma directive may be used after #pragma */
482 #define	DT_PRAGMA_DCP	2	/* pragma may only be used after #pragma D */
483 
484 static const struct dt_pragmadesc {
485 	const char *dpd_name;
486 	void (*dpd_func)(const char *, dt_node_t *);
487 	int dpd_kind;
488 } dt_pragmas[] = {
489 	{ "attributes", dt_pragma_attributes, DT_PRAGMA_DCP },
490 	{ "binding", dt_pragma_binding, DT_PRAGMA_DCP },
491 	{ "depends_on", dt_pragma_depends, DT_PRAGMA_DCP },
492 	{ "error", dt_pragma_error, DT_PRAGMA_DIR },
493 	{ "ident", dt_pragma_ident, DT_PRAGMA_DIR },
494 	{ "line", dt_pragma_line, DT_PRAGMA_DIR },
495 	{ "option", dt_pragma_option, DT_PRAGMA_DCP },
496 	{ NULL, NULL }
497 };
498 
499 /*
500  * Process a control line #directive by looking up the directive name in our
501  * lookup table and invoking the corresponding function with the token list.
502  * According to K&R[A12.9], we silently ignore null directive lines.
503  */
504 void
505 dt_pragma(dt_node_t *pnp)
506 {
507 	const struct dt_pragmadesc *dpd;
508 	dt_node_t *dnp;
509 	int kind = DT_PRAGMA_DIR;
510 
511 	for (dnp = pnp; dnp != NULL; dnp = dnp->dn_list) {
512 		if (dnp->dn_kind == DT_NODE_INT) {
513 			dt_pragma_line("line", dnp);
514 			break;
515 		}
516 
517 		if (dnp->dn_kind != DT_NODE_IDENT)
518 			xyerror(D_PRAGCTL_INVAL, "invalid control directive\n");
519 
520 		if (kind == DT_PRAGMA_DIR &&
521 		    strcmp(dnp->dn_string, "pragma") == 0) {
522 			kind = DT_PRAGMA_SUB;
523 			continue;
524 		}
525 
526 		if (kind == DT_PRAGMA_SUB &&
527 		    strcmp(dnp->dn_string, "D") == 0) {
528 			kind = DT_PRAGMA_DCP;
529 			continue;
530 		}
531 
532 		for (dpd = dt_pragmas; dpd->dpd_name != NULL; dpd++) {
533 			if (dpd->dpd_kind <= kind &&
534 			    strcmp(dpd->dpd_name, dnp->dn_string) == 0)
535 				break;
536 		}
537 
538 		yylineno--; /* since we've already seen \n */
539 
540 		if (dpd->dpd_name != NULL) {
541 			dpd->dpd_func(dpd->dpd_name, dnp->dn_list);
542 			yylineno++;
543 			break;
544 		}
545 
546 		switch (kind) {
547 		case DT_PRAGMA_DIR:
548 			xyerror(D_PRAGCTL_INVAL, "invalid control directive: "
549 			    "#%s\n", dnp->dn_string);
550 			/*NOTREACHED*/
551 		case DT_PRAGMA_SUB:
552 			break; /* K&R[A12.8] says to ignore unknown pragmas */
553 		case DT_PRAGMA_DCP:
554 		default:
555 			xyerror(D_PRAGMA_INVAL, "invalid D pragma: %s\n",
556 			    dnp->dn_string);
557 		}
558 
559 		yylineno++;
560 		break;
561 	}
562 
563 	dt_node_list_free(&pnp);
564 }
565