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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * tree.c -- routines for manipulating the prop tree 26 * 27 * the actions in escparse.y call these routines to construct 28 * the parse tree. these routines, in turn, call the check_X() 29 * routines for semantic checking. 30 */ 31 32 #pragma ident "%Z%%M% %I% %E% SMI" 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <ctype.h> 37 #include <strings.h> 38 #include <alloca.h> 39 #include "alloc.h" 40 #include "out.h" 41 #include "stats.h" 42 #include "stable.h" 43 #include "literals.h" 44 #include "lut.h" 45 #include "esclex.h" 46 #include "tree.h" 47 #include "check.h" 48 #include "ptree.h" 49 50 static struct node *Root; 51 52 static char *Newname; 53 54 static struct stats *Faultcount; 55 static struct stats *Upsetcount; 56 static struct stats *Defectcount; 57 static struct stats *Errorcount; 58 static struct stats *Ereportcount; 59 static struct stats *SERDcount; 60 static struct stats *STATcount; 61 static struct stats *ASRUcount; 62 static struct stats *FRUcount; 63 static struct stats *Configcount; 64 static struct stats *Propcount; 65 static struct stats *Maskcount; 66 static struct stats *Nodecount; 67 static struct stats *Namecount; 68 static struct stats *Nodesize; 69 70 struct lut *Usedprops; 71 72 void 73 tree_init(void) 74 { 75 Faultcount = stats_new_counter("parser.fault", "fault decls", 1); 76 Upsetcount = stats_new_counter("parser.upset", "upset decls", 1); 77 Defectcount = stats_new_counter("parser.defect", "defect decls", 1); 78 Errorcount = stats_new_counter("parser.error", "error decls", 1); 79 Ereportcount = stats_new_counter("parser.ereport", "ereport decls", 1); 80 SERDcount = stats_new_counter("parser.SERD", "SERD engine decls", 1); 81 STATcount = stats_new_counter("parser.STAT", "STAT engine decls", 1); 82 ASRUcount = stats_new_counter("parser.ASRU", "ASRU decls", 1); 83 FRUcount = stats_new_counter("parser.FRU", "FRU decls", 1); 84 Configcount = stats_new_counter("parser.config", "config stmts", 1); 85 Propcount = stats_new_counter("parser.prop", "prop stmts", 1); 86 Maskcount = stats_new_counter("parser.mask", "mask stmts", 1); 87 Nodecount = stats_new_counter("parser.node", "nodes created", 1); 88 Namecount = stats_new_counter("parser.name", "names created", 1); 89 Nodesize = 90 stats_new_counter("parser.nodesize", "sizeof(struct node)", 1); 91 stats_counter_add(Nodesize, sizeof (struct node)); 92 } 93 94 void 95 tree_fini(void) 96 { 97 stats_delete(Faultcount); 98 stats_delete(Upsetcount); 99 stats_delete(Defectcount); 100 stats_delete(Errorcount); 101 stats_delete(Ereportcount); 102 stats_delete(SERDcount); 103 stats_delete(STATcount); 104 stats_delete(ASRUcount); 105 stats_delete(FRUcount); 106 stats_delete(Configcount); 107 stats_delete(Propcount); 108 stats_delete(Maskcount); 109 stats_delete(Nodecount); 110 stats_delete(Namecount); 111 stats_delete(Nodesize); 112 113 /* free entire parse tree */ 114 tree_free(Root); 115 116 /* free up the luts we keep for decls */ 117 lut_free(Faults, NULL, NULL); 118 Faults = NULL; 119 lut_free(Upsets, NULL, NULL); 120 Upsets = NULL; 121 lut_free(Defects, NULL, NULL); 122 Defects = NULL; 123 lut_free(Errors, NULL, NULL); 124 Errors = NULL; 125 lut_free(Ereports, NULL, NULL); 126 Ereports = NULL; 127 lut_free(Ereportenames, NULL, NULL); 128 Ereportenames = NULL; 129 lut_free(Ereportenames_discard, NULL, NULL); 130 Ereportenames_discard = NULL; 131 lut_free(SERDs, NULL, NULL); 132 SERDs = NULL; 133 lut_free(STATs, NULL, NULL); 134 STATs = NULL; 135 lut_free(ASRUs, NULL, NULL); 136 ASRUs = NULL; 137 lut_free(FRUs, NULL, NULL); 138 FRUs = NULL; 139 lut_free(Configs, NULL, NULL); 140 Configs = NULL; 141 lut_free(Usedprops, NULL, NULL); 142 Usedprops = NULL; 143 144 Props = Lastprops = NULL; 145 Masks = Lastmasks = NULL; 146 Problems = Lastproblems = NULL; 147 148 if (Newname != NULL) { 149 FREE(Newname); 150 Newname = NULL; 151 } 152 } 153 154 /*ARGSUSED*/ 155 static int 156 nodesize(enum nodetype t, struct node *ret) 157 { 158 int size = sizeof (struct node); 159 160 switch (t) { 161 case T_NAME: 162 size += sizeof (ret->u.name) - sizeof (ret->u); 163 break; 164 165 case T_GLOBID: 166 size += sizeof (ret->u.globid) - sizeof (ret->u); 167 break; 168 169 case T_TIMEVAL: 170 case T_NUM: 171 size += sizeof (ret->u.ull) - sizeof (ret->u); 172 break; 173 174 case T_QUOTE: 175 size += sizeof (ret->u.quote) - sizeof (ret->u); 176 break; 177 178 case T_FUNC: 179 size += sizeof (ret->u.func) - sizeof (ret->u); 180 break; 181 182 case T_FAULT: 183 case T_UPSET: 184 case T_DEFECT: 185 case T_ERROR: 186 case T_EREPORT: 187 case T_ASRU: 188 case T_FRU: 189 case T_SERD: 190 case T_STAT: 191 case T_CONFIG: 192 case T_PROP: 193 case T_MASK: 194 size += sizeof (ret->u.stmt) - sizeof (ret->u); 195 break; 196 197 case T_EVENT: 198 size += sizeof (ret->u.event) - sizeof (ret->u); 199 break; 200 201 case T_ARROW: 202 size += sizeof (ret->u.arrow) - sizeof (ret->u); 203 break; 204 205 default: 206 size += sizeof (ret->u.expr) - sizeof (ret->u); 207 break; 208 } 209 return (size); 210 } 211 212 struct node * 213 newnode(enum nodetype t, const char *file, int line) 214 { 215 struct node *ret = NULL; 216 int size = nodesize(t, ret); 217 218 ret = alloc_xmalloc(size); 219 stats_counter_bump(Nodecount); 220 bzero(ret, size); 221 ret->t = t; 222 ret->file = (file == NULL) ? "<nofile>" : file; 223 ret->line = line; 224 225 return (ret); 226 } 227 228 /*ARGSUSED*/ 229 void 230 tree_free(struct node *root) 231 { 232 if (root == NULL) 233 return; 234 235 switch (root->t) { 236 case T_NAME: 237 tree_free(root->u.name.child); 238 tree_free(root->u.name.next); 239 break; 240 case T_FUNC: 241 tree_free(root->u.func.arglist); 242 break; 243 case T_AND: 244 case T_OR: 245 case T_EQ: 246 case T_NE: 247 case T_ADD: 248 case T_DIV: 249 case T_MOD: 250 case T_MUL: 251 case T_SUB: 252 case T_LT: 253 case T_LE: 254 case T_GT: 255 case T_GE: 256 case T_BITAND: 257 case T_BITOR: 258 case T_BITXOR: 259 case T_BITNOT: 260 case T_LSHIFT: 261 case T_RSHIFT: 262 case T_NVPAIR: 263 case T_ASSIGN: 264 case T_CONDIF: 265 case T_CONDELSE: 266 case T_LIST: 267 tree_free(root->u.expr.left); 268 tree_free(root->u.expr.right); 269 break; 270 case T_EVENT: 271 tree_free(root->u.event.ename); 272 tree_free(root->u.event.epname); 273 tree_free(root->u.event.eexprlist); 274 break; 275 case T_NOT: 276 tree_free(root->u.expr.left); 277 break; 278 case T_ARROW: 279 tree_free(root->u.arrow.lhs); 280 tree_free(root->u.arrow.nnp); 281 tree_free(root->u.arrow.knp); 282 tree_free(root->u.arrow.rhs); 283 break; 284 case T_PROP: 285 case T_MASK: 286 tree_free(root->u.stmt.np); 287 break; 288 case T_FAULT: 289 case T_UPSET: 290 case T_DEFECT: 291 case T_ERROR: 292 case T_EREPORT: 293 case T_ASRU: 294 case T_FRU: 295 case T_SERD: 296 case T_STAT: 297 case T_CONFIG: 298 tree_free(root->u.stmt.np); 299 if (root->u.stmt.nvpairs) 300 tree_free(root->u.stmt.nvpairs); 301 if (root->u.stmt.lutp) 302 lut_free(root->u.stmt.lutp, NULL, NULL); 303 break; 304 case T_TIMEVAL: 305 case T_NUM: 306 case T_QUOTE: 307 case T_GLOBID: 308 case T_NOTHING: 309 break; 310 default: 311 out(O_DIE, 312 "internal error: tree_free unexpected nodetype: %d", 313 root->t); 314 /*NOTREACHED*/ 315 } 316 alloc_xfree((char *)root, nodesize(root->t, root)); 317 } 318 319 static int 320 tree_treecmp(struct node *np1, struct node *np2, enum nodetype t, 321 lut_cmp cmp_func) 322 { 323 if (np1 == NULL || np2 == NULL) 324 return (0); 325 326 if (np1->t != np2->t) 327 return (1); 328 329 ASSERT(cmp_func != NULL); 330 331 if (np1->t == t) 332 return ((*cmp_func)(np1, np2)); 333 334 switch (np1->t) { 335 case T_NAME: 336 if (tree_treecmp(np1->u.name.child, np2->u.name.child, t, 337 cmp_func)) 338 return (1); 339 return (tree_treecmp(np1->u.name.next, np2->u.name.next, t, 340 cmp_func)); 341 /*NOTREACHED*/ 342 break; 343 case T_FUNC: 344 return (tree_treecmp(np1->u.func.arglist, np2->u.func.arglist, 345 t, cmp_func)); 346 /*NOTREACHED*/ 347 break; 348 case T_AND: 349 case T_OR: 350 case T_EQ: 351 case T_NE: 352 case T_ADD: 353 case T_DIV: 354 case T_MOD: 355 case T_MUL: 356 case T_SUB: 357 case T_LT: 358 case T_LE: 359 case T_GT: 360 case T_GE: 361 case T_BITAND: 362 case T_BITOR: 363 case T_BITXOR: 364 case T_BITNOT: 365 case T_LSHIFT: 366 case T_RSHIFT: 367 case T_NVPAIR: 368 case T_ASSIGN: 369 case T_CONDIF: 370 case T_CONDELSE: 371 case T_LIST: 372 if (tree_treecmp(np1->u.expr.left, np2->u.expr.left, t, 373 cmp_func)) 374 return (1); 375 return (tree_treecmp(np1->u.expr.right, np2->u.expr.right, t, 376 cmp_func)); 377 /*NOTREACHED*/ 378 break; 379 case T_EVENT: 380 if (tree_treecmp(np1->u.event.ename, np2->u.event.ename, t, 381 cmp_func)) 382 return (1); 383 if (tree_treecmp(np1->u.event.epname, np2->u.event.epname, t, 384 cmp_func)) 385 return (1); 386 return (tree_treecmp(np1->u.event.eexprlist, 387 np2->u.event.eexprlist, t, cmp_func)); 388 /*NOTREACHED*/ 389 break; 390 case T_NOT: 391 return (tree_treecmp(np1->u.expr.left, np2->u.expr.left, t, 392 cmp_func)); 393 /*NOTREACHED*/ 394 break; 395 case T_ARROW: 396 if (tree_treecmp(np1->u.arrow.lhs, np2->u.arrow.lhs, t, 397 cmp_func)) 398 return (1); 399 if (tree_treecmp(np1->u.arrow.nnp, np2->u.arrow.nnp, t, 400 cmp_func)) 401 return (1); 402 if (tree_treecmp(np1->u.arrow.knp, np2->u.arrow.knp, t, 403 cmp_func)) 404 return (1); 405 return (tree_treecmp(np1->u.arrow.rhs, np2->u.arrow.rhs, t, 406 cmp_func)); 407 /*NOTREACHED*/ 408 break; 409 case T_PROP: 410 case T_MASK: 411 return (tree_treecmp(np1->u.stmt.np, np2->u.stmt.np, t, 412 cmp_func)); 413 /*NOTREACHED*/ 414 break; 415 case T_FAULT: 416 case T_UPSET: 417 case T_DEFECT: 418 case T_ERROR: 419 case T_EREPORT: 420 case T_ASRU: 421 case T_FRU: 422 case T_SERD: 423 case T_STAT: 424 if (tree_treecmp(np1->u.stmt.np, np2->u.stmt.np, t, cmp_func)) 425 return (1); 426 return (tree_treecmp(np1->u.stmt.nvpairs, np2->u.stmt.nvpairs, 427 t, cmp_func)); 428 /*NOTREACHED*/ 429 break; 430 case T_TIMEVAL: 431 case T_NUM: 432 case T_QUOTE: 433 case T_GLOBID: 434 case T_NOTHING: 435 break; 436 default: 437 out(O_DIE, 438 "internal error: tree_treecmp unexpected nodetype: %d", 439 np1->t); 440 /*NOTREACHED*/ 441 break; 442 } 443 444 return (0); 445 } 446 447 struct node * 448 tree_root(struct node *np) 449 { 450 if (np) 451 Root = np; 452 return (Root); 453 } 454 455 struct node * 456 tree_nothing(void) 457 { 458 return (newnode(T_NOTHING, L_nofile, 0)); 459 } 460 461 struct node * 462 tree_expr(enum nodetype t, struct node *left, struct node *right) 463 { 464 struct node *ret; 465 466 ASSERTinfo(left != NULL || right != NULL, ptree_nodetype2str(t)); 467 468 ret = newnode(t, 469 (left) ? left->file : right->file, 470 (left) ? left->line : right->line); 471 472 ret->u.expr.left = left; 473 ret->u.expr.right = right; 474 475 check_expr(ret); 476 477 return (ret); 478 } 479 480 /* 481 * ename_compress -- convert event class name in to more space-efficient form 482 * 483 * this routine is called after the parser has completed an "ename", which 484 * is that part of an event that contains the class name (like ereport.x.y.z). 485 * after this routine gets done with the ename, two things are true: 486 * 1. the ename uses only a single struct node 487 * 2. ename->u.name.s contains the *complete* class name, dots and all, 488 * entered into the string table. 489 * 490 * so in addition to saving space by using fewer struct nodes, this routine 491 * allows consumers of the fault tree to assume the ename is a single 492 * string, rather than a linked list of strings. 493 */ 494 static struct node * 495 ename_compress(struct node *ename) 496 { 497 char *buf; 498 char *cp; 499 int len = 0; 500 struct node *np; 501 502 if (ename == NULL) 503 return (ename); 504 505 ASSERT(ename->t == T_NAME); 506 507 if (ename->u.name.next == NULL) 508 return (ename); /* no compression to be applied here */ 509 510 for (np = ename; np != NULL; np = np->u.name.next) { 511 ASSERT(np->t == T_NAME); 512 len++; /* room for '.' and final '\0' */ 513 len += strlen(np->u.name.s); 514 } 515 cp = buf = alloca(len); 516 for (np = ename; np != NULL; np = np->u.name.next) { 517 ASSERT(np->t == T_NAME); 518 if (np != ename) 519 *cp++ = '.'; 520 (void) strcpy(cp, np->u.name.s); 521 cp += strlen(cp); 522 } 523 524 ename->u.name.s = stable(buf); 525 tree_free(ename->u.name.next); 526 ename->u.name.next = NULL; 527 ename->u.name.last = ename; 528 return (ename); 529 } 530 531 struct node * 532 tree_event(struct node *ename, struct node *epname, struct node *eexprlist) 533 { 534 struct node *ret; 535 536 ASSERT(ename != NULL); 537 538 ret = newnode(T_EVENT, ename->file, ename->line); 539 540 ret->u.event.ename = ename_compress(ename); 541 ret->u.event.epname = epname; 542 ret->u.event.eexprlist = eexprlist; 543 544 check_event(ret); 545 546 return (ret); 547 } 548 549 struct node * 550 tree_name(const char *s, enum itertype it, const char *file, int line) 551 { 552 struct node *ret = newnode(T_NAME, file, line); 553 554 ASSERT(s != NULL); 555 556 stats_counter_bump(Namecount); 557 ret->u.name.t = N_UNSPEC; 558 ret->u.name.s = stable(s); 559 ret->u.name.it = it; 560 ret->u.name.last = ret; 561 562 if (it == IT_ENAME) { 563 /* PHASE2, possible optimization: convert to table driven */ 564 if (s == L_fault) 565 ret->u.name.t = N_FAULT; 566 else if (s == L_upset) 567 ret->u.name.t = N_UPSET; 568 else if (s == L_defect) 569 ret->u.name.t = N_DEFECT; 570 else if (s == L_error) 571 ret->u.name.t = N_ERROR; 572 else if (s == L_ereport) 573 ret->u.name.t = N_EREPORT; 574 else if (s == L_serd) 575 ret->u.name.t = N_SERD; 576 else if (s == L_stat) 577 ret->u.name.t = N_STAT; 578 else 579 outfl(O_ERR, file, line, "unknown class: %s", s); 580 } 581 return (ret); 582 } 583 584 struct node * 585 tree_iname(const char *s, const char *file, int line) 586 { 587 struct node *ret; 588 char *ss; 589 char *ptr; 590 591 ASSERT(s != NULL && *s != '\0'); 592 593 ss = STRDUP(s); 594 595 ptr = &ss[strlen(ss) - 1]; 596 if (!isdigit(*ptr)) { 597 outfl(O_ERR, file, line, 598 "instanced name expected (i.e. \"x0/y1\")"); 599 FREE(ss); 600 return (tree_name(s, IT_NONE, file, line)); 601 } 602 while (ptr > ss && isdigit(*(ptr - 1))) 603 ptr--; 604 605 ret = newnode(T_NAME, file, line); 606 stats_counter_bump(Namecount); 607 ret->u.name.child = tree_num(ptr, file, line); 608 *ptr = '\0'; 609 ret->u.name.t = N_UNSPEC; 610 ret->u.name.s = stable(ss); 611 ret->u.name.it = IT_NONE; 612 ret->u.name.last = ret; 613 FREE(ss); 614 615 return (ret); 616 } 617 618 struct node * 619 tree_globid(const char *s, const char *file, int line) 620 { 621 struct node *ret = newnode(T_GLOBID, file, line); 622 623 ASSERT(s != NULL); 624 625 ret->u.globid.s = stable(s); 626 627 return (ret); 628 } 629 630 struct node * 631 tree_name_append(struct node *np1, struct node *np2) 632 { 633 ASSERT(np1 != NULL && np2 != NULL); 634 635 if (np1->t != T_NAME) 636 outfl(O_DIE, np1->file, np1->line, 637 "tree_name_append: internal error (np1 type %d)", np1->t); 638 if (np2->t != T_NAME) 639 outfl(O_DIE, np2->file, np2->line, 640 "tree_name_append: internal error (np2 type %d)", np2->t); 641 642 ASSERT(np1->u.name.last != NULL); 643 644 np1->u.name.last->u.name.next = np2; 645 np1->u.name.last = np2; 646 return (np1); 647 } 648 649 /* 650 * tree_name_repairdash -- repair a class name that contained a dash 651 * 652 * this routine is called by the parser when a dash is encountered 653 * in a class name. the event protocol allows the dashes but our 654 * lexer considers them a separate token (arithmetic minus). an extra 655 * rule in the parser catches this case and calls this routine to fixup 656 * the last component of the class name (so far) by constructing the 657 * new stable entry for a name including the dash. 658 */ 659 struct node * 660 tree_name_repairdash(struct node *np, const char *s) 661 { 662 int len; 663 char *buf; 664 665 ASSERT(np != NULL && s != NULL); 666 667 if (np->t != T_NAME) 668 outfl(O_DIE, np->file, np->line, 669 "tree_name_repairdash: internal error (np type %d)", 670 np->t); 671 672 ASSERT(np->u.name.last != NULL); 673 674 len = strlen(np->u.name.last->u.name.s) + 1 + strlen(s) + 1; 675 buf = MALLOC(len); 676 (void) snprintf(buf, len, "%s-%s", np->u.name.last->u.name.s, s); 677 np->u.name.last->u.name.s = stable(buf); 678 FREE(buf); 679 return (np); 680 } 681 682 struct node * 683 tree_name_repairdash2(const char *s, struct node *np) 684 { 685 int len; 686 char *buf; 687 688 ASSERT(np != NULL && s != NULL); 689 690 if (np->t != T_NAME) 691 outfl(O_DIE, np->file, np->line, 692 "tree_name_repairdash: internal error (np type %d)", 693 np->t); 694 695 ASSERT(np->u.name.last != NULL); 696 697 len = strlen(np->u.name.last->u.name.s) + 1 + strlen(s) + 1; 698 buf = MALLOC(len); 699 (void) snprintf(buf, len, "%s-%s", s, np->u.name.last->u.name.s); 700 np->u.name.last->u.name.s = stable(buf); 701 FREE(buf); 702 return (np); 703 } 704 705 struct node * 706 tree_name_iterator(struct node *np1, struct node *np2) 707 { 708 ASSERT(np1 != NULL); 709 ASSERT(np2 != NULL); 710 ASSERTinfo(np1->t == T_NAME, ptree_nodetype2str(np1->t)); 711 712 np1->u.name.child = np2; 713 714 check_name_iterator(np1); 715 716 return (np1); 717 } 718 719 struct node * 720 tree_timeval(const char *s, const char *suffix, const char *file, int line) 721 { 722 struct node *ret = newnode(T_TIMEVAL, file, line); 723 const unsigned long long *ullp; 724 725 ASSERT(s != NULL); 726 ASSERT(suffix != NULL); 727 728 if ((ullp = lex_s2ullp_lut_lookup(Timesuffixlut, suffix)) == NULL) { 729 outfl(O_ERR, file, line, 730 "unrecognized number suffix: %s", suffix); 731 /* still construct a valid timeval node so parsing continues */ 732 ret->u.ull = 1; 733 } else { 734 ret->u.ull = (unsigned long long)strtoul(s, NULL, 0) * *ullp; 735 } 736 737 return (ret); 738 } 739 740 struct node * 741 tree_num(const char *s, const char *file, int line) 742 { 743 struct node *ret = newnode(T_NUM, file, line); 744 745 ret->u.ull = (unsigned long long)strtoul(s, NULL, 0); 746 return (ret); 747 } 748 749 struct node * 750 tree_quote(const char *s, const char *file, int line) 751 { 752 struct node *ret = newnode(T_QUOTE, file, line); 753 754 ret->u.quote.s = stable(s); 755 return (ret); 756 } 757 758 struct node * 759 tree_func(const char *s, struct node *np, const char *file, int line) 760 { 761 struct node *ret = newnode(T_FUNC, file, line); 762 const char *ptr; 763 764 ret->u.func.s = s; 765 ret->u.func.arglist = np; 766 767 check_func(ret); 768 769 /* 770 * keep track of the properties we're interested in so we can ignore the 771 * rest 772 */ 773 if (strcmp(s, L_confprop) == 0 || strcmp(s, L_confprop_defined) == 0) { 774 ptr = stable(np->u.expr.right->u.quote.s); 775 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 776 } else if (strcmp(s, L_is_connected) == 0) { 777 ptr = stable("connected"); 778 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 779 ptr = stable("CONNECTED"); 780 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 781 } else if (strcmp(s, L_is_type) == 0) { 782 ptr = stable("type"); 783 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 784 ptr = stable("TYPE"); 785 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 786 } else if (strcmp(s, L_is_on) == 0) { 787 ptr = stable("on"); 788 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 789 ptr = stable("ON"); 790 Usedprops = lut_add(Usedprops, (void *)ptr, (void *)ptr, NULL); 791 } 792 793 return (ret); 794 } 795 796 /* 797 * given a list from a prop or mask statement or a function argument, 798 * convert all iterators to explicit iterators by inventing appropriate 799 * iterator names. 800 */ 801 static void 802 make_explicit(struct node *np, int eventonly) 803 { 804 struct node *pnp; /* component of pathname */ 805 struct node *pnp2; 806 int count; 807 static size_t namesz; 808 809 if (Newname == NULL) { 810 namesz = 200; 811 Newname = MALLOC(namesz); 812 } 813 814 if (np == NULL) 815 return; /* all done */ 816 817 switch (np->t) { 818 case T_ASSIGN: 819 case T_CONDIF: 820 case T_CONDELSE: 821 case T_NE: 822 case T_EQ: 823 case T_LT: 824 case T_LE: 825 case T_GT: 826 case T_GE: 827 case T_BITAND: 828 case T_BITOR: 829 case T_BITXOR: 830 case T_BITNOT: 831 case T_LSHIFT: 832 case T_RSHIFT: 833 case T_LIST: 834 case T_AND: 835 case T_OR: 836 case T_NOT: 837 case T_ADD: 838 case T_SUB: 839 case T_MUL: 840 case T_DIV: 841 case T_MOD: 842 make_explicit(np->u.expr.left, eventonly); 843 make_explicit(np->u.expr.right, eventonly); 844 break; 845 846 case T_EVENT: 847 make_explicit(np->u.event.epname, 0); 848 make_explicit(np->u.event.eexprlist, 1); 849 break; 850 851 case T_FUNC: 852 make_explicit(np->u.func.arglist, eventonly); 853 break; 854 855 case T_NAME: 856 if (eventonly) 857 return; 858 for (pnp = np; pnp != NULL; pnp = pnp->u.name.next) 859 if (pnp->u.name.child == NULL) { 860 /* 861 * found implicit iterator. convert 862 * it to an explicit iterator by 863 * using the name of the component 864 * appended with '#' and the number 865 * of times we've seen this same 866 * component name in this path so far. 867 */ 868 count = 0; 869 for (pnp2 = np; pnp2 != NULL; 870 pnp2 = pnp2->u.name.next) 871 if (pnp2 == pnp) 872 break; 873 else if (pnp2->u.name.s == 874 pnp->u.name.s) 875 count++; 876 877 if (namesz < strlen(pnp->u.name.s) + 878 100) { 879 namesz = strlen(pnp->u.name.s) + 880 100; 881 FREE(Newname); 882 Newname = MALLOC(namesz); 883 } 884 /* 885 * made up interator name is: 886 * name#ordinal 887 * or 888 * name##ordinal 889 * the first one is used for vertical 890 * expansion, the second for horizontal. 891 * either way, the '#' embedded in 892 * the name makes it impossible to 893 * collide with an actual iterator 894 * given to us in the eversholt file. 895 */ 896 (void) snprintf(Newname, namesz, 897 "%s#%s%d", pnp->u.name.s, 898 (pnp->u.name.it == IT_HORIZONTAL) ? 899 "#" : "", count); 900 901 pnp->u.name.child = tree_name(Newname, 902 IT_NONE, pnp->file, pnp->line); 903 pnp->u.name.childgen = 1; 904 } 905 break; 906 } 907 } 908 909 struct node * 910 tree_pname(struct node *np) 911 { 912 make_explicit(np, 0); 913 return (np); 914 } 915 916 struct node * 917 tree_arrow(struct node *lhs, struct node *nnp, struct node *knp, 918 struct node *rhs) 919 { 920 struct node *ret; 921 922 ASSERT(lhs != NULL || rhs != NULL); 923 924 ret = newnode(T_ARROW, 925 (lhs) ? lhs->file : rhs->file, 926 (lhs) ? lhs->line : rhs->line); 927 928 ret->u.arrow.lhs = lhs; 929 ret->u.arrow.nnp = nnp; 930 ret->u.arrow.knp = knp; 931 ret->u.arrow.rhs = rhs; 932 933 make_explicit(lhs, 0); 934 make_explicit(rhs, 0); 935 936 check_arrow(ret); 937 938 return (ret); 939 } 940 941 static struct lut * 942 nvpair2lut(struct node *np, struct lut *lutp, enum nodetype t) 943 { 944 if (np) { 945 if (np->t == T_NVPAIR) { 946 ASSERTeq(np->u.expr.left->t, T_NAME, 947 ptree_nodetype2str); 948 check_stmt_allowed_properties(t, np, lutp); 949 lutp = tree_s2np_lut_add(lutp, 950 np->u.expr.left->u.name.s, np->u.expr.right); 951 } else if (np->t == T_LIST) { 952 lutp = nvpair2lut(np->u.expr.left, lutp, t); 953 lutp = nvpair2lut(np->u.expr.right, lutp, t); 954 } else 955 outfl(O_DIE, np->file, np->line, 956 "internal error: nvpair2lut type %s", 957 ptree_nodetype2str(np->t)); 958 } 959 960 return (lutp); 961 } 962 963 struct lut * 964 tree_s2np_lut_add(struct lut *root, const char *s, struct node *np) 965 { 966 return (lut_add(root, (void *)s, (void *)np, NULL)); 967 } 968 969 struct node * 970 tree_s2np_lut_lookup(struct lut *root, const char *s) 971 { 972 return (struct node *)lut_lookup(root, (void *)s, NULL); 973 } 974 975 struct lut * 976 tree_name2np_lut_add(struct lut *root, struct node *namep, struct node *np) 977 { 978 return (lut_add(root, (void *)namep, (void *)np, 979 (lut_cmp)tree_namecmp)); 980 } 981 982 struct node * 983 tree_name2np_lut_lookup(struct lut *root, struct node *namep) 984 { 985 return (struct node *) 986 lut_lookup(root, (void *)namep, (lut_cmp)tree_namecmp); 987 } 988 989 struct node * 990 tree_name2np_lut_lookup_name(struct lut *root, struct node *namep) 991 { 992 return (struct node *) 993 lut_lookup_lhs(root, (void *)namep, (lut_cmp)tree_namecmp); 994 } 995 996 struct lut * 997 tree_event2np_lut_add(struct lut *root, struct node *enp, struct node *np) 998 { 999 return (lut_add(root, (void *)enp, (void *)np, (lut_cmp)tree_eventcmp)); 1000 } 1001 1002 struct node * 1003 tree_event2np_lut_lookup(struct lut *root, struct node *enp) 1004 { 1005 return ((struct node *) 1006 lut_lookup(root, (void *)enp, (lut_cmp)tree_eventcmp)); 1007 } 1008 1009 struct node * 1010 tree_event2np_lut_lookup_event(struct lut *root, struct node *enp) 1011 { 1012 return ((struct node *) 1013 lut_lookup_lhs(root, (void *)enp, (lut_cmp)tree_eventcmp)); 1014 } 1015 1016 static struct node * 1017 dodecl(enum nodetype t, const char *file, int line, 1018 struct node *np, struct node *nvpairs, struct lut **lutpp, 1019 struct stats *countp, int justpath) 1020 { 1021 struct node *ret; 1022 struct node *decl; 1023 1024 /* allocate parse tree node */ 1025 ret = newnode(t, file, line); 1026 ret->u.stmt.np = np; 1027 ret->u.stmt.nvpairs = nvpairs; 1028 1029 /* 1030 * the global lut pointed to by lutpp (Faults, Defects, Upsets, 1031 * Errors, Ereports, Serds, FRUs, or ASRUs) keeps the first decl. 1032 * if this isn't the first declr, we merge the 1033 * nvpairs into the first decl so we have a 1034 * merged table to look up properties from. 1035 * if this is the first time we've seen this fault, 1036 * we add it to the global lut and start lutp 1037 * off with any nvpairs from this declaration statement. 1038 */ 1039 if (justpath && (decl = tree_name2np_lut_lookup(*lutpp, np)) == NULL) { 1040 /* this is the first time name is declared */ 1041 stats_counter_bump(countp); 1042 *lutpp = tree_name2np_lut_add(*lutpp, np, ret); 1043 ret->u.stmt.lutp = nvpair2lut(nvpairs, NULL, t); 1044 } else if (!justpath && 1045 (decl = tree_event2np_lut_lookup(*lutpp, np)) == NULL) { 1046 /* this is the first time event is declared */ 1047 stats_counter_bump(countp); 1048 *lutpp = tree_event2np_lut_add(*lutpp, np, ret); 1049 ret->u.stmt.lutp = nvpair2lut(nvpairs, NULL, t); 1050 } else { 1051 /* was declared before, just add new nvpairs to its lutp */ 1052 decl->u.stmt.lutp = nvpair2lut(nvpairs, decl->u.stmt.lutp, t); 1053 } 1054 1055 return (ret); 1056 } 1057 1058 /*ARGSUSED*/ 1059 static void 1060 update_serd_refstmt(void *lhs, void *rhs, void *arg) 1061 { 1062 struct node *serd; 1063 1064 ASSERT(rhs != NULL); 1065 1066 serd = tree_s2np_lut_lookup(((struct node *)rhs)->u.stmt.lutp, 1067 L_engine); 1068 if (serd == NULL) 1069 return; 1070 1071 ASSERT(serd->t == T_EVENT); 1072 if (arg != NULL && tree_eventcmp(serd, (struct node *)arg) != 0) 1073 return; 1074 1075 serd = tree_event2np_lut_lookup(SERDs, serd); 1076 if (serd != NULL) 1077 serd->u.stmt.flags |= STMT_REF; 1078 } 1079 1080 struct node * 1081 tree_decl(enum nodetype t, struct node *np, struct node *nvpairs, 1082 const char *file, int line) 1083 { 1084 struct node *decl; 1085 struct node *ret; 1086 1087 ASSERT(np != NULL); 1088 1089 check_type_iterator(np); 1090 1091 switch (t) { 1092 case T_EVENT: 1093 /* determine the type of event being declared */ 1094 ASSERT(np->u.event.ename->t == T_NAME); 1095 switch (np->u.event.ename->u.name.t) { 1096 case N_FAULT: 1097 ret = dodecl(T_FAULT, file, line, np, nvpairs, 1098 &Faults, Faultcount, 0); 1099 1100 /* increment serd statement reference */ 1101 decl = tree_event2np_lut_lookup(Faults, np); 1102 update_serd_refstmt(NULL, decl, NULL); 1103 break; 1104 1105 case N_UPSET: 1106 ret = dodecl(T_UPSET, file, line, np, nvpairs, 1107 &Upsets, Upsetcount, 0); 1108 1109 /* increment serd statement reference */ 1110 decl = tree_event2np_lut_lookup(Upsets, np); 1111 update_serd_refstmt(NULL, decl, NULL); 1112 break; 1113 1114 case N_DEFECT: 1115 ret = dodecl(T_DEFECT, file, line, np, nvpairs, 1116 &Defects, Defectcount, 0); 1117 1118 /* increment serd statement reference */ 1119 decl = tree_event2np_lut_lookup(Defects, np); 1120 update_serd_refstmt(NULL, decl, NULL); 1121 break; 1122 1123 case N_ERROR: 1124 ret = dodecl(T_ERROR, file, line, np, nvpairs, 1125 &Errors, Errorcount, 0); 1126 break; 1127 1128 case N_EREPORT: 1129 ret = dodecl(T_EREPORT, file, line, np, nvpairs, 1130 &Ereports, Ereportcount, 0); 1131 /* 1132 * Keep a lut of just the enames, so that the DE 1133 * can subscribe to a uniqified list of event 1134 * classes. 1135 */ 1136 Ereportenames = 1137 tree_name2np_lut_add(Ereportenames, 1138 np->u.event.ename, np); 1139 1140 /* 1141 * Keep a lut of the enames (event classes) to 1142 * silently discard if we can't find a matching 1143 * configuration node when an ereport of of a given 1144 * class is received. Such events are declaired 1145 * with 'discard_if_config_unknown=1'. 1146 */ 1147 if (tree_s2np_lut_lookup(ret->u.stmt.lutp, 1148 L_discard_if_config_unknown)) { 1149 Ereportenames_discard = lut_add( 1150 Ereportenames_discard, 1151 (void *)np->u.event.ename->u.name.s, 1152 (void *)np->u.event.ename->u.name.s, NULL); 1153 } 1154 break; 1155 1156 default: 1157 outfl(O_ERR, file, line, 1158 "tree_decl: internal error, event name type %s", 1159 ptree_nametype2str(np->u.event.ename->u.name.t)); 1160 } 1161 break; 1162 1163 case T_ENGINE: 1164 /* determine the type of engine being declared */ 1165 ASSERT(np->u.event.ename->t == T_NAME); 1166 switch (np->u.event.ename->u.name.t) { 1167 case N_SERD: 1168 ret = dodecl(T_SERD, file, line, np, nvpairs, 1169 &SERDs, SERDcount, 0); 1170 lut_walk(Upsets, update_serd_refstmt, np); 1171 break; 1172 1173 case N_STAT: 1174 ret = dodecl(T_STAT, file, line, np, nvpairs, 1175 &STATs, STATcount, 0); 1176 break; 1177 1178 default: 1179 outfl(O_ERR, file, line, 1180 "tree_decl: internal error, engine name type %s", 1181 ptree_nametype2str(np->u.event.ename->u.name.t)); 1182 } 1183 break; 1184 case T_ASRU: 1185 ret = dodecl(T_ASRU, file, line, np, nvpairs, 1186 &ASRUs, ASRUcount, 1); 1187 break; 1188 1189 case T_FRU: 1190 ret = dodecl(T_FRU, file, line, np, nvpairs, 1191 &FRUs, FRUcount, 1); 1192 break; 1193 1194 case T_CONFIG: 1195 /* 1196 * config statements are different from above: they 1197 * are not merged at all (until the configuration cache 1198 * code does its own style of merging. and the properties 1199 * are a free-for-all -- we don't check for allowed or 1200 * required config properties. 1201 */ 1202 ret = newnode(T_CONFIG, file, line); 1203 ret->u.stmt.np = np; 1204 ret->u.stmt.nvpairs = nvpairs; 1205 ret->u.stmt.lutp = nvpair2lut(nvpairs, NULL, T_CONFIG); 1206 1207 if (lut_lookup(Configs, np, (lut_cmp)tree_namecmp) == NULL) 1208 stats_counter_bump(Configcount); 1209 1210 Configs = lut_add(Configs, (void *)np, (void *)ret, NULL); 1211 break; 1212 1213 default: 1214 out(O_DIE, "tree_decl: internal error, type %s", 1215 ptree_nodetype2str(t)); 1216 } 1217 1218 return (ret); 1219 } 1220 1221 /* keep backpointers in arrows to the prop they belong to (used for scoping) */ 1222 static void 1223 set_arrow_prop(struct node *prop, struct node *np) 1224 { 1225 if (np == NULL) 1226 return; 1227 1228 if (np->t == T_ARROW) { 1229 np->u.arrow.prop = prop; 1230 set_arrow_prop(prop, np->u.arrow.lhs); 1231 /* 1232 * no need to recurse right or handle T_LIST since 1233 * T_ARROWs always cascade left and are at the top 1234 * of the parse tree. (you can see this in the rule 1235 * for "propbody" in escparse.y.) 1236 */ 1237 } 1238 } 1239 1240 struct node * 1241 tree_stmt(enum nodetype t, struct node *np, const char *file, int line) 1242 { 1243 struct node *ret = newnode(t, file, line); 1244 struct node *pp; 1245 int inlist = 0; 1246 1247 ret->u.stmt.np = np; 1248 1249 switch (t) { 1250 case T_PROP: 1251 check_proplists(t, np); 1252 check_propnames(t, np, 0, 0); 1253 check_propscope(np); 1254 set_arrow_prop(ret, np); 1255 1256 for (pp = Props; pp; pp = pp->u.stmt.next) { 1257 if (tree_treecmp(pp, ret, T_NAME, 1258 (lut_cmp)tree_namecmp) == 0) { 1259 inlist = 1; 1260 break; 1261 } 1262 } 1263 if (inlist == 0) 1264 stats_counter_bump(Propcount); 1265 1266 /* "Props" is a linked list of all prop statements */ 1267 if (Lastprops) 1268 Lastprops->u.stmt.next = ret; 1269 else 1270 Props = ret; 1271 Lastprops = ret; 1272 break; 1273 1274 case T_MASK: 1275 check_proplists(t, np); 1276 check_propnames(t, np, 0, 0); 1277 check_propscope(np); 1278 set_arrow_prop(ret, np); 1279 1280 for (pp = Masks; pp; pp = pp->u.stmt.next) { 1281 if (tree_treecmp(pp, ret, T_NAME, 1282 (lut_cmp)tree_namecmp) == 0) { 1283 inlist = 1; 1284 break; 1285 } 1286 } 1287 if (inlist == 0) 1288 stats_counter_bump(Maskcount); 1289 1290 /* "Masks" is a linked list of all mask statements */ 1291 if (Lastmasks) 1292 Lastmasks->u.stmt.next = ret; 1293 else 1294 Masks = ret; 1295 Lastmasks = ret; 1296 stats_counter_bump(Maskcount); 1297 break; 1298 1299 default: 1300 outfl(O_DIE, np->file, np->line, 1301 "tree_stmt: internal error (t %d)", t); 1302 } 1303 1304 return (ret); 1305 } 1306 1307 void 1308 tree_report() 1309 { 1310 /* 1311 * The only declarations with required properties 1312 * currently are faults and serds. Make sure the 1313 * the declarations have the required properties. 1314 */ 1315 lut_walk(Faults, (lut_cb)check_required_props, (void *)T_FAULT); 1316 lut_walk(Upsets, (lut_cb)check_required_props, (void *)T_UPSET); 1317 lut_walk(Errors, (lut_cb)check_required_props, (void *)T_ERROR); 1318 lut_walk(Ereports, (lut_cb)check_required_props, (void *)T_EREPORT); 1319 lut_walk(SERDs, (lut_cb)check_required_props, (void *)T_SERD); 1320 lut_walk(STATs, (lut_cb)check_required_props, (void *)T_STAT); 1321 1322 /* 1323 * we do this now rather than while building the parse 1324 * tree because it is inconvenient for the user if we 1325 * require SERD engines to be declared before used in 1326 * an upset "engine" property. 1327 */ 1328 lut_walk(Faults, (lut_cb)check_refcount, (void *)T_FAULT); 1329 lut_walk(Faults, (lut_cb)check_upset_engine, (void *)T_FAULT); 1330 lut_walk(Defects, (lut_cb)check_upset_engine, (void *)T_DEFECT); 1331 lut_walk(Upsets, (lut_cb)check_upset_engine, (void *)T_UPSET); 1332 lut_walk(Upsets, (lut_cb)check_refcount, (void *)T_UPSET); 1333 lut_walk(Errors, (lut_cb)check_refcount, (void *)T_ERROR); 1334 lut_walk(Ereports, (lut_cb)check_refcount, (void *)T_EREPORT); 1335 lut_walk(SERDs, (lut_cb)check_refcount, (void *)T_SERD); 1336 1337 /* check for cycles */ 1338 lut_walk(Errors, (lut_cb)check_cycle, (void *)0); 1339 } 1340 1341 /* compare two T_NAMES by only looking at components, not iterators */ 1342 int 1343 tree_namecmp(struct node *np1, struct node *np2) 1344 { 1345 ASSERT(np1 != NULL); 1346 ASSERT(np2 != NULL); 1347 ASSERTinfo(np1->t == T_NAME, ptree_nodetype2str(np1->t)); 1348 ASSERTinfo(np2->t == T_NAME, ptree_nodetype2str(np1->t)); 1349 1350 while (np1 && np2 && np1->u.name.s == np2->u.name.s) { 1351 np1 = np1->u.name.next; 1352 np2 = np2->u.name.next; 1353 } 1354 if (np1 == NULL) 1355 if (np2 == NULL) 1356 return (0); 1357 else 1358 return (-1); 1359 else if (np2 == NULL) 1360 return (1); 1361 else 1362 return (np2->u.name.s - np1->u.name.s); 1363 } 1364 1365 int 1366 tree_eventcmp(struct node *np1, struct node *np2) 1367 { 1368 int ret; 1369 1370 ASSERT(np1 != NULL); 1371 ASSERT(np2 != NULL); 1372 ASSERTinfo(np1->t == T_EVENT, ptree_nodetype2str(np1->t)); 1373 ASSERTinfo(np2->t == T_EVENT, ptree_nodetype2str(np2->t)); 1374 1375 if ((ret = tree_namecmp(np1->u.event.ename, 1376 np2->u.event.ename)) == 0) { 1377 if (np1->u.event.epname == NULL && 1378 np2->u.event.epname == NULL) 1379 return (0); 1380 else if (np1->u.event.epname == NULL) 1381 return (-1); 1382 else if (np2->u.event.epname == NULL) 1383 return (1); 1384 else 1385 return tree_namecmp(np1->u.event.epname, 1386 np2->u.event.epname); 1387 } else 1388 return (ret); 1389 } 1390
Indexes created Wed Feb 10 08:45:31 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
