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*/ 53static void 54dt_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 */ 81static void 82dt_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 */ 164static void 165dt_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 209static void 210dt_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 */ 237static void 238dt_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 */ 349static void 350dt_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*/ 377static void 378dt_pragma_ident(const char *prname, dt_node_t *dnp) 379{ 380 /* ignore any #ident or #pragma ident lines */ 381} 382 383static void 384dt_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 */ 430static void 431dt_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 484static 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 */ 504void 505dt_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