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 * Use is subject to license terms. 25 * Copyright 2017 Nexenta Systems, Inc. 26 */ 27 28 #include <sys/types.h> 29 #include <sys/inttypes.h> 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/user.h> 33 #include <sys/disp.h> 34 #include <sys/conf.h> 35 #include <sys/bootconf.h> 36 #include <sys/sysconf.h> 37 #include <sys/sunddi.h> 38 #include <sys/esunddi.h> 39 #include <sys/ddi_impldefs.h> 40 #include <sys/kmem.h> 41 #include <sys/vmem.h> 42 #include <sys/fs/ufs_fsdir.h> 43 #include <sys/hwconf.h> 44 #include <sys/modctl.h> 45 #include <sys/cmn_err.h> 46 #include <sys/kobj.h> 47 #include <sys/kobj_lex.h> 48 #include <sys/errno.h> 49 #include <sys/debug.h> 50 #include <sys/autoconf.h> 51 #include <sys/callb.h> 52 #include <sys/sysmacros.h> 53 #include <sys/dacf.h> 54 #include <vm/seg_kmem.h> 55 56 struct hwc_class *hcl_head; /* head of list of classes */ 57 static kmutex_t hcl_lock; /* for accessing list of classes */ 58 59 #define DAFILE "/etc/driver_aliases" 60 #define CLASSFILE "/etc/driver_classes" 61 #define DACFFILE "/etc/dacf.conf" 62 63 static char class_file[] = CLASSFILE; 64 static char dafile[] = DAFILE; 65 static char dacffile[] = DACFFILE; 66 67 char *self_assembly = "/etc/system.d/.self-assembly"; 68 char *systemfile = "/etc/system"; /* name of ascii system file */ 69 70 static struct sysparam *sysparam_hd; /* head of parameters list */ 71 static struct sysparam *sysparam_tl; /* tail of parameters list */ 72 static vmem_t *mod_sysfile_arena; /* parser memory */ 73 74 char obp_bootpath[BO_MAXOBJNAME]; /* bootpath from obp */ 75 76 #if defined(_PSM_MODULES) 77 78 struct psm_mach { 79 struct psm_mach *m_next; 80 char *m_machname; 81 }; 82 83 static struct psm_mach *pmach_head; /* head of list of classes */ 84 85 #define MACHFILE "/etc/mach" 86 static char mach_file[] = MACHFILE; 87 88 #endif /* _PSM_MODULES */ 89 90 #if defined(_RTC_CONFIG) 91 static char rtc_config_file[] = "/etc/rtc_config"; 92 #endif 93 94 static void sys_set_var(int, struct sysparam *, void *); 95 96 static void setparams(void); 97 98 /* 99 * driver.conf parse thread control structure 100 */ 101 struct hwc_parse_mt { 102 ksema_t sema; 103 char *name; /* name of .conf files */ 104 struct par_list **pl; /* parsed parent list */ 105 ddi_prop_t **props; /* parsed properties */ 106 int rv; /* return value */ 107 }; 108 109 static int hwc_parse_now(char *, struct par_list **, ddi_prop_t **); 110 static void hwc_parse_thread(struct hwc_parse_mt *); 111 static struct hwc_parse_mt *hwc_parse_mtalloc(char *, struct par_list **, 112 ddi_prop_t **); 113 static void hwc_parse_mtfree(struct hwc_parse_mt *); 114 static void add_spec(struct hwc_spec *, struct par_list **); 115 static void add_props(struct hwc_spec *, ddi_prop_t **); 116 117 static void check_system_file(void); 118 static int sysparam_compare_entry(struct sysparam *, struct sysparam *); 119 static char *sysparam_type_to_str(int); 120 static void sysparam_count_entry(struct sysparam *, int *, u_longlong_t *); 121 static void sysparam_print_warning(struct sysparam *, u_longlong_t); 122 123 #ifdef DEBUG 124 static int parse_debug_on = 0; 125 126 /*VARARGS1*/ 127 static void 128 parse_debug(struct _buf *file, char *fmt, ...) 129 { 130 va_list adx; 131 132 if (parse_debug_on) { 133 va_start(adx, fmt); 134 vprintf(fmt, adx); 135 if (file) 136 printf(" on line %d of %s\n", kobj_linenum(file), 137 kobj_filename(file)); 138 va_end(adx); 139 } 140 } 141 #endif /* DEBUG */ 142 143 #define FE_BUFLEN 256 144 145 /*PRINTFLIKE3*/ 146 void 147 kobj_file_err(int type, struct _buf *file, char *fmt, ...) 148 { 149 va_list ap; 150 /* 151 * If we're in trouble, we might be short on stack... be paranoid 152 */ 153 char *buf = kmem_alloc(FE_BUFLEN, KM_SLEEP); 154 char *trailer = kmem_alloc(FE_BUFLEN, KM_SLEEP); 155 char *fmt_str = kmem_alloc(FE_BUFLEN, KM_SLEEP); 156 char prefix = '\0'; 157 158 va_start(ap, fmt); 159 if (strchr("^!?", fmt[0]) != NULL) { 160 prefix = fmt[0]; 161 fmt++; 162 } 163 (void) vsnprintf(buf, FE_BUFLEN, fmt, ap); 164 va_end(ap); 165 (void) snprintf(trailer, FE_BUFLEN, " on line %d of %s", 166 kobj_linenum(file), kobj_filename(file)); 167 168 /* 169 * If prefixed with !^?, prepend that character 170 */ 171 if (prefix != '\0') { 172 (void) snprintf(fmt_str, FE_BUFLEN, "%c%%s%%s", prefix); 173 } else { 174 (void) strncpy(fmt_str, "%s%s", FE_BUFLEN); 175 } 176 177 cmn_err(type, fmt_str, buf, trailer); 178 kmem_free(buf, FE_BUFLEN); 179 kmem_free(trailer, FE_BUFLEN); 180 kmem_free(fmt_str, FE_BUFLEN); 181 } 182 183 #ifdef DEBUG 184 char *tokennames[] = { 185 "UNEXPECTED", 186 "EQUALS", 187 "AMPERSAND", 188 "BIT_OR", 189 "STAR", 190 "POUND", 191 "COLON", 192 "SEMICOLON", 193 "COMMA", 194 "SLASH", 195 "WHITE_SPACE", 196 "NEWLINE", 197 "EOF", 198 "STRING", 199 "HEXVAL", 200 "DECVAL", 201 "NAME" 202 }; 203 #endif /* DEBUG */ 204 205 token_t 206 kobj_lex(struct _buf *file, char *val, size_t size) 207 { 208 char *cp; 209 int ch, oval, badquote; 210 size_t remain; 211 token_t token = UNEXPECTED; 212 213 if (size < 2) 214 return (token); /* this token is UNEXPECTED */ 215 216 cp = val; 217 while ((ch = kobj_getc(file)) == ' ' || ch == '\t') 218 ; 219 220 remain = size - 1; 221 *cp++ = (char)ch; 222 switch (ch) { 223 case '=': 224 token = EQUALS; 225 break; 226 case '&': 227 token = AMPERSAND; 228 break; 229 case '|': 230 token = BIT_OR; 231 break; 232 case '*': 233 token = STAR; 234 break; 235 case '#': 236 token = POUND; 237 break; 238 case ':': 239 token = COLON; 240 break; 241 case ';': 242 token = SEMICOLON; 243 break; 244 case ',': 245 token = COMMA; 246 break; 247 case '/': 248 token = SLASH; 249 break; 250 case ' ': 251 case '\t': 252 case '\f': 253 while ((ch = kobj_getc(file)) == ' ' || 254 ch == '\t' || ch == '\f') { 255 if (--remain == 0) { 256 token = UNEXPECTED; 257 goto out; 258 } 259 *cp++ = (char)ch; 260 } 261 (void) kobj_ungetc(file); 262 token = WHITE_SPACE; 263 break; 264 case '\n': 265 case '\r': 266 token = NEWLINE; 267 break; 268 case '"': 269 remain++; 270 cp--; 271 badquote = 0; 272 while (!badquote && (ch = kobj_getc(file)) != '"') { 273 switch (ch) { 274 case '\n': 275 case -1: 276 kobj_file_err(CE_WARN, file, "Missing \""); 277 remain = size - 1; 278 cp = val; 279 *cp++ = '\n'; 280 badquote = 1; 281 /* since we consumed the newline/EOF */ 282 (void) kobj_ungetc(file); 283 break; 284 285 case '\\': 286 if (--remain == 0) { 287 token = UNEXPECTED; 288 goto out; 289 } 290 ch = (char)kobj_getc(file); 291 if (!isdigit(ch)) { 292 /* escape the character */ 293 *cp++ = (char)ch; 294 break; 295 } 296 oval = 0; 297 while (ch >= '0' && ch <= '7') { 298 ch -= '0'; 299 oval = (oval << 3) + ch; 300 ch = (char)kobj_getc(file); 301 } 302 (void) kobj_ungetc(file); 303 /* check for character overflow? */ 304 if (oval > 127) { 305 cmn_err(CE_WARN, 306 "Character " 307 "overflow detected."); 308 } 309 *cp++ = (char)oval; 310 break; 311 default: 312 if (--remain == 0) { 313 token = UNEXPECTED; 314 goto out; 315 } 316 *cp++ = (char)ch; 317 break; 318 } 319 } 320 token = STRING; 321 break; 322 323 case -1: 324 token = EOF; 325 break; 326 327 default: 328 /* 329 * detect a lone '-' (including at the end of a line), and 330 * identify it as a 'name' 331 */ 332 if (ch == '-') { 333 if (--remain == 0) { 334 token = UNEXPECTED; 335 goto out; 336 } 337 *cp++ = (char)(ch = kobj_getc(file)); 338 if (iswhite(ch) || (ch == '\n')) { 339 (void) kobj_ungetc(file); 340 remain++; 341 cp--; 342 token = NAME; 343 break; 344 } 345 } else if (isunary(ch)) { 346 if (--remain == 0) { 347 token = UNEXPECTED; 348 goto out; 349 } 350 *cp++ = (char)(ch = kobj_getc(file)); 351 } 352 353 354 if (isdigit(ch)) { 355 if (ch == '0') { 356 if ((ch = kobj_getc(file)) == 'x') { 357 if (--remain == 0) { 358 token = UNEXPECTED; 359 goto out; 360 } 361 *cp++ = (char)ch; 362 ch = kobj_getc(file); 363 while (isxdigit(ch)) { 364 if (--remain == 0) { 365 token = UNEXPECTED; 366 goto out; 367 } 368 *cp++ = (char)ch; 369 ch = kobj_getc(file); 370 } 371 (void) kobj_ungetc(file); 372 token = HEXVAL; 373 } else { 374 goto digit; 375 } 376 } else { 377 ch = kobj_getc(file); 378 digit: 379 while (isdigit(ch)) { 380 if (--remain == 0) { 381 token = UNEXPECTED; 382 goto out; 383 } 384 *cp++ = (char)ch; 385 ch = kobj_getc(file); 386 } 387 (void) kobj_ungetc(file); 388 token = DECVAL; 389 } 390 } else if (isalpha(ch) || ch == '\\' || ch == '_') { 391 if (ch != '\\') { 392 ch = kobj_getc(file); 393 } else { 394 /* 395 * if the character was a backslash, 396 * back up so we can overwrite it with 397 * the next (i.e. escaped) character. 398 */ 399 remain++; 400 cp--; 401 } 402 while (isnamechar(ch) || ch == '\\') { 403 if (ch == '\\') 404 ch = kobj_getc(file); 405 if (--remain == 0) { 406 token = UNEXPECTED; 407 goto out; 408 } 409 *cp++ = (char)ch; 410 ch = kobj_getc(file); 411 } 412 (void) kobj_ungetc(file); 413 token = NAME; 414 } else { 415 token = UNEXPECTED; 416 } 417 break; 418 } 419 out: 420 *cp = '\0'; 421 422 #ifdef DEBUG 423 /* 424 * The UNEXPECTED token is the first element of the tokennames array, 425 * but its token value is -1. Adjust the value by adding one to it 426 * to change it to an index of the array. 427 */ 428 parse_debug(NULL, "kobj_lex: token %s value '%s'\n", 429 tokennames[token+1], val); 430 #endif 431 return (token); 432 } 433 434 /* 435 * Leave NEWLINE as the next character. 436 */ 437 438 void 439 kobj_find_eol(struct _buf *file) 440 { 441 int ch; 442 443 while ((ch = kobj_getc(file)) != -1) { 444 if (isnewline(ch)) { 445 (void) kobj_ungetc(file); 446 break; 447 } 448 } 449 } 450 451 /* 452 * The ascii system file is read and processed. 453 * 454 * The syntax of commands is as follows: 455 * 456 * '*' in column 1 is a comment line. 457 * <command> : <value> 458 * 459 * command is EXCLUDE, INCLUDE, FORCELOAD, ROOTDEV, ROOTFS, 460 * SWAPDEV, SWAPFS, MODDIR, SET 461 * 462 * value is an ascii string meaningful for the command. 463 */ 464 465 /* 466 * Table of commands 467 */ 468 static struct modcmd modcmd[] = { 469 { "EXCLUDE", MOD_EXCLUDE }, 470 { "exclude", MOD_EXCLUDE }, 471 { "INCLUDE", MOD_INCLUDE }, 472 { "include", MOD_INCLUDE }, 473 { "FORCELOAD", MOD_FORCELOAD }, 474 { "forceload", MOD_FORCELOAD }, 475 { "ROOTDEV", MOD_ROOTDEV }, 476 { "rootdev", MOD_ROOTDEV }, 477 { "ROOTFS", MOD_ROOTFS }, 478 { "rootfs", MOD_ROOTFS }, 479 { "SWAPDEV", MOD_SWAPDEV }, 480 { "swapdev", MOD_SWAPDEV }, 481 { "SWAPFS", MOD_SWAPFS }, 482 { "swapfs", MOD_SWAPFS }, 483 { "MODDIR", MOD_MODDIR }, 484 { "moddir", MOD_MODDIR }, 485 { "SET", MOD_SET }, 486 { "set", MOD_SET }, 487 { "SET32", MOD_SET32 }, 488 { "set32", MOD_SET32 }, 489 { "SET64", MOD_SET64 }, 490 { "set64", MOD_SET64 }, 491 { NULL, MOD_UNKNOWN } 492 }; 493 494 495 static char bad_op[] = "illegal operator '%s' used on a string"; 496 static char colon_err[] = "A colon (:) must follow the '%s' command"; 497 static char tok_err[] = "Unexpected token '%s'"; 498 static char extra_err[] = "extraneous input ignored starting at '%s'"; 499 static char oversize_err[] = "value too long"; 500 501 static struct sysparam * 502 do_sysfile_cmd(struct _buf *file, const char *cmd) 503 { 504 struct sysparam *sysp; 505 struct modcmd *mcp; 506 token_t token, op; 507 char *cp; 508 int ch; 509 char tok1[MOD_MAXPATH + 1]; /* used to read the path set by 'moddir' */ 510 char tok2[64]; 511 512 for (mcp = modcmd; mcp->mc_cmdname != NULL; mcp++) { 513 if (strcmp(mcp->mc_cmdname, cmd) == 0) 514 break; 515 } 516 sysp = vmem_alloc(mod_sysfile_arena, sizeof (struct sysparam), 517 VM_SLEEP); 518 bzero(sysp, sizeof (struct sysparam)); 519 sysp->sys_op = SETOP_NONE; /* set op to noop initially */ 520 521 switch (sysp->sys_type = mcp->mc_type) { 522 case MOD_INCLUDE: 523 case MOD_EXCLUDE: 524 case MOD_FORCELOAD: 525 /* 526 * Are followed by colon. 527 */ 528 case MOD_ROOTFS: 529 case MOD_SWAPFS: 530 if ((token = kobj_lex(file, tok1, sizeof (tok1))) == COLON) { 531 token = kobj_lex(file, tok1, sizeof (tok1)); 532 } else { 533 kobj_file_err(CE_WARN, file, colon_err, cmd); 534 } 535 if (token != NAME) { 536 kobj_file_err(CE_WARN, file, "value expected"); 537 goto bad; 538 } 539 540 cp = tok1 + strlen(tok1); 541 while ((ch = kobj_getc(file)) != -1 && !iswhite(ch) && 542 !isnewline(ch)) { 543 if (cp - tok1 >= sizeof (tok1) - 1) { 544 kobj_file_err(CE_WARN, file, oversize_err); 545 goto bad; 546 } 547 *cp++ = (char)ch; 548 } 549 *cp = '\0'; 550 551 if (ch != -1) 552 (void) kobj_ungetc(file); 553 if (sysp->sys_type == MOD_INCLUDE) 554 return (NULL); 555 sysp->sys_ptr = vmem_alloc(mod_sysfile_arena, strlen(tok1) + 1, 556 VM_SLEEP); 557 (void) strcpy(sysp->sys_ptr, tok1); 558 break; 559 case MOD_SET: 560 case MOD_SET64: 561 case MOD_SET32: 562 { 563 char *var; 564 token_t tok3; 565 566 if (kobj_lex(file, tok1, sizeof (tok1)) != NAME) { 567 kobj_file_err(CE_WARN, file, "value expected"); 568 goto bad; 569 } 570 571 /* 572 * If the next token is a colon (:), 573 * we have the <modname>:<variable> construct. 574 */ 575 if ((token = kobj_lex(file, tok2, sizeof (tok2))) == COLON) { 576 if ((token = kobj_lex(file, tok2, 577 sizeof (tok2))) == NAME) { 578 var = tok2; 579 /* 580 * Save the module name. 581 */ 582 sysp->sys_modnam = vmem_alloc(mod_sysfile_arena, 583 strlen(tok1) + 1, VM_SLEEP); 584 (void) strcpy(sysp->sys_modnam, tok1); 585 op = kobj_lex(file, tok1, sizeof (tok1)); 586 } else { 587 kobj_file_err(CE_WARN, file, "value expected"); 588 goto bad; 589 } 590 } else { 591 /* otherwise, it was the op */ 592 var = tok1; 593 op = token; 594 } 595 /* 596 * kernel param - place variable name in sys_ptr. 597 */ 598 sysp->sys_ptr = vmem_alloc(mod_sysfile_arena, strlen(var) + 1, 599 VM_SLEEP); 600 (void) strcpy(sysp->sys_ptr, var); 601 /* set operation */ 602 switch (op) { 603 case EQUALS: 604 /* simple assignment */ 605 sysp->sys_op = SETOP_ASSIGN; 606 break; 607 case AMPERSAND: 608 /* bitwise AND */ 609 sysp->sys_op = SETOP_AND; 610 break; 611 case BIT_OR: 612 /* bitwise OR */ 613 sysp->sys_op = SETOP_OR; 614 break; 615 default: 616 /* unsupported operation */ 617 kobj_file_err(CE_WARN, file, 618 "unsupported operator %s", tok2); 619 goto bad; 620 } 621 622 switch ((tok3 = kobj_lex(file, tok1, sizeof (tok1)))) { 623 case STRING: 624 /* string variable */ 625 if (sysp->sys_op != SETOP_ASSIGN) { 626 kobj_file_err(CE_WARN, file, bad_op, tok1); 627 goto bad; 628 } 629 if (kobj_get_string(&sysp->sys_info, tok1) == 0) { 630 kobj_file_err(CE_WARN, file, "string garbled"); 631 goto bad; 632 } 633 /* 634 * Set SYSPARAM_STR_TOKEN in sys_flags to notify 635 * sysparam_print_warning() that this is a string 636 * token. 637 */ 638 sysp->sys_flags |= SYSPARAM_STR_TOKEN; 639 break; 640 case HEXVAL: 641 case DECVAL: 642 if (kobj_getvalue(tok1, &sysp->sys_info) == -1) { 643 kobj_file_err(CE_WARN, file, 644 "invalid number '%s'", tok1); 645 goto bad; 646 } 647 648 /* 649 * Set the appropriate flag (hexadecimal or decimal) 650 * in sys_flags for sysparam_print_warning() to be 651 * able to print the number with the correct format. 652 */ 653 if (tok3 == HEXVAL) { 654 sysp->sys_flags |= SYSPARAM_HEX_TOKEN; 655 } else { 656 sysp->sys_flags |= SYSPARAM_DEC_TOKEN; 657 } 658 break; 659 default: 660 kobj_file_err(CE_WARN, file, "bad rvalue '%s'", tok1); 661 goto bad; 662 } /* end switch */ 663 664 /* 665 * Now that we've parsed it to check the syntax, consider 666 * discarding it (because it -doesn't- apply to this flavor 667 * of the kernel) 668 */ 669 #ifdef _LP64 670 if (sysp->sys_type == MOD_SET32) 671 return (NULL); 672 #else 673 if (sysp->sys_type == MOD_SET64) 674 return (NULL); 675 #endif 676 sysp->sys_type = MOD_SET; 677 break; 678 } 679 case MOD_MODDIR: 680 if ((token = kobj_lex(file, tok1, sizeof (tok1))) != COLON) { 681 kobj_file_err(CE_WARN, file, colon_err, cmd); 682 goto bad; 683 } 684 685 cp = tok1; 686 while ((token = kobj_lex(file, cp, 687 sizeof (tok1) - (cp - tok1))) != NEWLINE && token != EOF) { 688 if (token == -1) { 689 kobj_file_err(CE_WARN, file, oversize_err); 690 goto bad; 691 } 692 cp += strlen(cp); 693 while ((ch = kobj_getc(file)) != -1 && !iswhite(ch) && 694 !isnewline(ch) && ch != ':') { 695 if (cp - tok1 >= sizeof (tok1) - 1) { 696 kobj_file_err(CE_WARN, file, 697 oversize_err); 698 goto bad; 699 } 700 *cp++ = (char)ch; 701 } 702 *cp++ = ' '; 703 if (isnewline(ch)) { 704 cp--; 705 (void) kobj_ungetc(file); 706 } 707 } 708 (void) kobj_ungetc(file); 709 *cp = '\0'; 710 sysp->sys_ptr = vmem_alloc(mod_sysfile_arena, strlen(tok1) + 1, 711 VM_SLEEP); 712 (void) strcpy(sysp->sys_ptr, tok1); 713 break; 714 715 case MOD_SWAPDEV: 716 case MOD_ROOTDEV: 717 if ((token = kobj_lex(file, tok1, sizeof (tok1))) != COLON) { 718 kobj_file_err(CE_WARN, file, colon_err, cmd); 719 goto bad; 720 } 721 while ((ch = kobj_getc(file)) == ' ' || ch == '\t') 722 ; 723 cp = tok1; 724 while (!iswhite(ch) && !isnewline(ch) && ch != -1) { 725 if (cp - tok1 >= sizeof (tok1) - 1) { 726 kobj_file_err(CE_WARN, file, oversize_err); 727 goto bad; 728 } 729 730 *cp++ = (char)ch; 731 ch = kobj_getc(file); 732 } 733 if (ch != -1) 734 (void) kobj_ungetc(file); 735 *cp = '\0'; 736 737 sysp->sys_ptr = vmem_alloc(mod_sysfile_arena, strlen(tok1) + 1, 738 VM_SLEEP); 739 (void) strcpy(sysp->sys_ptr, tok1); 740 break; 741 742 case MOD_UNKNOWN: 743 default: 744 kobj_file_err(CE_WARN, file, "unknown command '%s'", cmd); 745 goto bad; 746 } 747 748 return (sysp); 749 750 bad: 751 kobj_find_eol(file); 752 return (NULL); 753 } 754 755 static void 756 read_system_file(char *name) 757 { 758 register struct sysparam *sp; 759 register struct _buf *file; 760 register token_t token, last_tok; 761 char tokval[MAXLINESIZE]; 762 763 if ((file = kobj_open_file(name)) == 764 (struct _buf *)-1) { 765 if (strcmp(name, systemfile) == 0) 766 cmn_err(CE_WARN, "cannot open system file: %s", 767 name); 768 } else { 769 if (sysparam_tl == NULL) 770 sysparam_tl = (struct sysparam *)&sysparam_hd; 771 772 last_tok = NEWLINE; 773 while ((token = kobj_lex(file, tokval, 774 sizeof (tokval))) != EOF) { 775 switch (token) { 776 case STAR: 777 case POUND: 778 /* 779 * Skip comments. 780 */ 781 kobj_find_eol(file); 782 break; 783 case NEWLINE: 784 kobj_newline(file); 785 last_tok = NEWLINE; 786 break; 787 case NAME: 788 if (last_tok != NEWLINE) { 789 kobj_file_err(CE_WARN, file, 790 extra_err, tokval); 791 kobj_find_eol(file); 792 } else if ((sp = do_sysfile_cmd(file, 793 tokval)) != NULL) { 794 sp->sys_next = NULL; 795 sysparam_tl->sys_next = sp; 796 sysparam_tl = sp; 797 } 798 last_tok = NAME; 799 break; 800 default: 801 kobj_file_err(CE_WARN, 802 file, tok_err, tokval); 803 kobj_find_eol(file); 804 break; 805 } 806 } 807 kobj_close_file(file); 808 } 809 } 810 811 void 812 mod_read_system_file(int ask) 813 { 814 mod_sysfile_arena = vmem_create("mod_sysfile", NULL, 0, 8, 815 segkmem_alloc, segkmem_free, heap_arena, 0, VM_SLEEP); 816 817 if (ask) 818 mod_askparams(); 819 820 /* 821 * Read the user self-assembly file first 822 * to preserve existing system settings. 823 */ 824 if (self_assembly != NULL) 825 read_system_file(self_assembly); 826 827 if (systemfile != NULL) 828 read_system_file(systemfile); 829 830 /* 831 * Sanity check of /etc/system. 832 */ 833 check_system_file(); 834 835 param_preset(); 836 (void) mod_sysctl(SYS_SET_KVAR, NULL); 837 param_check(); 838 839 if (ask == 0) 840 setparams(); 841 } 842 843 /* 844 * Search for a specific module variable assignment in /etc/system. If 845 * successful, 1 is returned and the value is stored in '*value'. 846 * Otherwise 0 is returned and '*value' isn't modified. If 'module' is 847 * NULL we look for global definitions. 848 * 849 * This is useful if the value of an assignment is needed before a 850 * module is loaded (e.g. to obtain a default privileged rctl limit). 851 */ 852 int 853 mod_sysvar(const char *module, const char *name, u_longlong_t *value) 854 { 855 struct sysparam *sysp; 856 int cnt = 0; /* dummy */ 857 858 ASSERT(name != NULL); 859 ASSERT(value != NULL); 860 for (sysp = sysparam_hd; sysp != NULL; sysp = sysp->sys_next) { 861 862 if ((sysp->sys_type == MOD_SET) && 863 (((module == NULL) && (sysp->sys_modnam == NULL)) || 864 ((module != NULL) && (sysp->sys_modnam != NULL) && 865 (strcmp(module, sysp->sys_modnam) == 0)))) { 866 867 ASSERT(sysp->sys_ptr != NULL); 868 869 if (strcmp(name, sysp->sys_ptr) == 0) { 870 sysparam_count_entry(sysp, &cnt, value); 871 if ((sysp->sys_flags & SYSPARAM_TERM) != 0) 872 return (1); 873 continue; 874 } 875 } 876 } 877 ASSERT(cnt == 0); 878 return (0); 879 } 880 881 /* 882 * This function scans sysparam records, which are created from the 883 * contents of /etc/system, for entries which are logical duplicates, 884 * and prints warning messages as appropriate. When multiple "set" 885 * commands are encountered, the pileup of values with "&", "|" 886 * and "=" operators results in the final value. 887 */ 888 static void 889 check_system_file(void) 890 { 891 struct sysparam *sysp; 892 893 for (sysp = sysparam_hd; sysp != NULL; sysp = sysp->sys_next) { 894 struct sysparam *entry, *final; 895 u_longlong_t value = 0; 896 int cnt = 1; 897 /* 898 * If the entry is already checked, skip it. 899 */ 900 if ((sysp->sys_flags & SYSPARAM_DUP) != 0) 901 continue; 902 /* 903 * Check if there is a duplicate entry by doing a linear 904 * search. 905 */ 906 final = sysp; 907 for (entry = sysp->sys_next; entry != NULL; 908 entry = entry->sys_next) { 909 /* 910 * Check the entry. if it's different, skip this. 911 */ 912 if (sysparam_compare_entry(sysp, entry) != 0) 913 continue; 914 /* 915 * Count the entry and put the mark. 916 */ 917 sysparam_count_entry(entry, &cnt, &value); 918 entry->sys_flags |= SYSPARAM_DUP; 919 final = entry; 920 } 921 final->sys_flags |= SYSPARAM_TERM; 922 /* 923 * Print the warning if it's duplicated. 924 */ 925 if (cnt >= 2) 926 sysparam_print_warning(final, value); 927 } 928 } 929 930 /* 931 * Compare the sysparam records. 932 * Return 0 if they are the same, return 1 if not. 933 */ 934 static int 935 sysparam_compare_entry(struct sysparam *sysp, struct sysparam *entry) 936 { 937 ASSERT(sysp->sys_ptr != NULL && entry->sys_ptr != NULL); 938 939 /* 940 * If the command is rootdev, rootfs, swapdev, swapfs or moddir, 941 * the record with the same type is treated as a duplicate record. 942 * In other cases, the record is treated as a duplicate record when 943 * its type, its module name (if it exists), and its variable name 944 * are the same. 945 */ 946 switch (sysp->sys_type) { 947 case MOD_ROOTDEV: 948 case MOD_ROOTFS: 949 case MOD_SWAPDEV: 950 case MOD_SWAPFS: 951 case MOD_MODDIR: 952 return (sysp->sys_type == entry->sys_type ? 0 : 1); 953 default: /* In other cases, just go through it. */ 954 break; 955 } 956 957 if (sysp->sys_type != entry->sys_type) 958 return (1); 959 960 if (sysp->sys_modnam != NULL && entry->sys_modnam == NULL) 961 return (1); 962 963 if (sysp->sys_modnam == NULL && entry->sys_modnam != NULL) 964 return (1); 965 966 if (sysp->sys_modnam != NULL && entry->sys_modnam != NULL && 967 strcmp(sysp->sys_modnam, entry->sys_modnam) != 0) 968 return (1); 969 970 return (strcmp(sysp->sys_ptr, entry->sys_ptr)); 971 } 972 973 /* 974 * Translate a sysparam type value to a string. 975 */ 976 static char * 977 sysparam_type_to_str(int type) 978 { 979 struct modcmd *mcp; 980 981 for (mcp = modcmd; mcp->mc_cmdname != NULL; mcp++) { 982 if (mcp->mc_type == type) 983 break; 984 } 985 ASSERT(mcp->mc_type == type); 986 987 if (type != MOD_UNKNOWN) 988 return ((++mcp)->mc_cmdname); /* lower case */ 989 else 990 return (""); /* MOD_UNKNOWN */ 991 } 992 993 /* 994 * Check the entry and accumulate the number of entries. 995 */ 996 static void 997 sysparam_count_entry(struct sysparam *sysp, int *cnt, u_longlong_t *value) 998 { 999 u_longlong_t ul = sysp->sys_info; 1000 1001 switch (sysp->sys_op) { 1002 case SETOP_ASSIGN: 1003 *value = ul; 1004 (*cnt)++; 1005 return; 1006 case SETOP_AND: 1007 *value &= ul; 1008 return; 1009 case SETOP_OR: 1010 *value |= ul; 1011 return; 1012 default: /* Not MOD_SET */ 1013 (*cnt)++; 1014 return; 1015 } 1016 } 1017 1018 /* 1019 * Print out the warning if multiple entries are found in the system file. 1020 */ 1021 static void 1022 sysparam_print_warning(struct sysparam *sysp, u_longlong_t value) 1023 { 1024 char *modnam = sysp->sys_modnam; 1025 char *varnam = sysp->sys_ptr; 1026 int type = sysp->sys_type; 1027 char *typenam = sysparam_type_to_str(type); 1028 boolean_t str_token = ((sysp->sys_flags & SYSPARAM_STR_TOKEN) != 0); 1029 boolean_t hex_number = ((sysp->sys_flags & SYSPARAM_HEX_TOKEN) != 0); 1030 #define warn_format1 " is set more than once in /%s. " 1031 #define warn_format2 " applied as the current setting.\n" 1032 1033 ASSERT(varnam != NULL); 1034 1035 if (type == MOD_SET) { 1036 /* 1037 * If a string token is set, print out the string 1038 * instead of its pointer value. In other cases, 1039 * print out the value with the appropriate format 1040 * for a hexadecimal number or a decimal number. 1041 */ 1042 if (modnam == NULL) { 1043 if (str_token == B_TRUE) { 1044 cmn_err(CE_WARN, "%s" warn_format1 1045 "\"%s %s = %s\"" warn_format2, 1046 varnam, systemfile, typenam, 1047 varnam, (char *)(uintptr_t)value); 1048 } else if (hex_number == B_TRUE) { 1049 cmn_err(CE_WARN, "%s" warn_format1 1050 "\"%s %s = 0x%llx\"" warn_format2, 1051 varnam, systemfile, typenam, 1052 varnam, value); 1053 } else { 1054 cmn_err(CE_WARN, "%s" warn_format1 1055 "\"%s %s = %lld\"" warn_format2, 1056 varnam, systemfile, typenam, 1057 varnam, value); 1058 } 1059 } else { 1060 if (str_token == B_TRUE) { 1061 cmn_err(CE_WARN, "%s:%s" warn_format1 1062 "\"%s %s:%s = %s\"" warn_format2, 1063 modnam, varnam, systemfile, 1064 typenam, modnam, varnam, 1065 (char *)(uintptr_t)value); 1066 } else if (hex_number == B_TRUE) { 1067 cmn_err(CE_WARN, "%s:%s" warn_format1 1068 "\"%s %s:%s = 0x%llx\"" warn_format2, 1069 modnam, varnam, systemfile, 1070 typenam, modnam, varnam, value); 1071 } else { 1072 cmn_err(CE_WARN, "%s:%s" warn_format1 1073 "\"%s %s:%s = %lld\"" warn_format2, 1074 modnam, varnam, systemfile, 1075 typenam, modnam, varnam, value); 1076 } 1077 } 1078 } else { 1079 /* 1080 * If the type is MOD_ROOTDEV, MOD_ROOTFS, MOD_SWAPDEV, 1081 * MOD_SWAPFS or MOD_MODDIR, the entry is treated as 1082 * a duplicate one if it has the same type regardless 1083 * of its variable name. 1084 */ 1085 switch (type) { 1086 case MOD_ROOTDEV: 1087 case MOD_ROOTFS: 1088 case MOD_SWAPDEV: 1089 case MOD_SWAPFS: 1090 case MOD_MODDIR: 1091 cmn_err(CE_WARN, "\"%s\" appears more than once " 1092 "in /%s.", typenam, systemfile); 1093 break; 1094 default: 1095 cmn_err(CE_NOTE, "\"%s: %s\" appears more than once " 1096 "in /%s.", typenam, varnam, systemfile); 1097 break; 1098 } 1099 } 1100 } 1101 1102 /* 1103 * Process the system file commands. 1104 */ 1105 int 1106 mod_sysctl(int fcn, void *p) 1107 { 1108 static char wmesg[] = "forceload of %s failed"; 1109 struct sysparam *sysp; 1110 char *name; 1111 struct modctl *modp; 1112 1113 if (sysparam_hd == NULL) 1114 return (0); 1115 1116 for (sysp = sysparam_hd; sysp != NULL; sysp = sysp->sys_next) { 1117 1118 switch (fcn) { 1119 1120 case SYS_FORCELOAD: 1121 if (sysp->sys_type == MOD_FORCELOAD) { 1122 name = sysp->sys_ptr; 1123 if (modload(NULL, name) == -1) 1124 cmn_err(CE_WARN, wmesg, name); 1125 /* 1126 * The following works because it 1127 * runs before autounloading is started!! 1128 */ 1129 modp = mod_find_by_filename(NULL, name); 1130 if (modp != NULL) 1131 modp->mod_loadflags |= MOD_NOAUTOUNLOAD; 1132 /* 1133 * For drivers, attempt to install it. 1134 */ 1135 if (strncmp(sysp->sys_ptr, "drv", 3) == 0) { 1136 (void) ddi_install_driver(name + 4); 1137 } 1138 } 1139 break; 1140 1141 case SYS_SET_KVAR: 1142 case SYS_SET_MVAR: 1143 if (sysp->sys_type == MOD_SET) 1144 sys_set_var(fcn, sysp, p); 1145 break; 1146 1147 case SYS_CHECK_EXCLUDE: 1148 if (sysp->sys_type == MOD_EXCLUDE) { 1149 if (p == NULL || sysp->sys_ptr == NULL) 1150 return (0); 1151 if (strcmp((char *)p, sysp->sys_ptr) == 0) 1152 return (1); 1153 } 1154 } 1155 } 1156 1157 return (0); 1158 } 1159 1160 /* 1161 * Process the system file commands, by type. 1162 */ 1163 int 1164 mod_sysctl_type(int type, int (*func)(struct sysparam *, void *), void *p) 1165 { 1166 struct sysparam *sysp; 1167 int err; 1168 1169 for (sysp = sysparam_hd; sysp != NULL; sysp = sysp->sys_next) 1170 if (sysp->sys_type == type) 1171 if (err = (*(func))(sysp, p)) 1172 return (err); 1173 return (0); 1174 } 1175 1176 1177 static char seterr[] = "Symbol %s has size of 0 in symbol table. %s"; 1178 static char assumption[] = "Assuming it is an 'int'"; 1179 static char defmsg[] = "Trying to set a variable that is of size %d"; 1180 1181 static void set_int8_var(uintptr_t, struct sysparam *); 1182 static void set_int16_var(uintptr_t, struct sysparam *); 1183 static void set_int32_var(uintptr_t, struct sysparam *); 1184 static void set_int64_var(uintptr_t, struct sysparam *); 1185 1186 static void 1187 sys_set_var(int fcn, struct sysparam *sysp, void *p) 1188 { 1189 uintptr_t symaddr; 1190 int size; 1191 1192 if (fcn == SYS_SET_KVAR && sysp->sys_modnam == NULL) { 1193 symaddr = kobj_getelfsym(sysp->sys_ptr, NULL, &size); 1194 } else if (fcn == SYS_SET_MVAR) { 1195 if (sysp->sys_modnam == (char *)NULL || 1196 strcmp(((struct modctl *)p)->mod_modname, 1197 sysp->sys_modnam) != 0) 1198 return; 1199 symaddr = kobj_getelfsym(sysp->sys_ptr, 1200 ((struct modctl *)p)->mod_mp, &size); 1201 } else 1202 return; 1203 1204 if (symaddr != (uintptr_t)NULL) { 1205 switch (size) { 1206 case 1: 1207 set_int8_var(symaddr, sysp); 1208 break; 1209 case 2: 1210 set_int16_var(symaddr, sysp); 1211 break; 1212 case 0: 1213 cmn_err(CE_WARN, seterr, sysp->sys_ptr, assumption); 1214 /*FALLTHROUGH*/ 1215 case 4: 1216 set_int32_var(symaddr, sysp); 1217 break; 1218 case 8: 1219 set_int64_var(symaddr, sysp); 1220 break; 1221 default: 1222 cmn_err(CE_WARN, defmsg, size); 1223 break; 1224 } 1225 } else { 1226 printf("sorry, variable '%s' is not defined in the '%s' ", 1227 sysp->sys_ptr, 1228 sysp->sys_modnam ? sysp->sys_modnam : "kernel"); 1229 if (sysp->sys_modnam) 1230 printf("module"); 1231 printf("\n"); 1232 } 1233 } 1234 1235 static void 1236 set_int8_var(uintptr_t symaddr, struct sysparam *sysp) 1237 { 1238 uint8_t uc = (uint8_t)sysp->sys_info; 1239 1240 if (moddebug & MODDEBUG_LOADMSG) 1241 printf("OP: %x: param '%s' was '0x%" PRIx8 1242 "' in module: '%s'.\n", sysp->sys_op, sysp->sys_ptr, 1243 *(uint8_t *)symaddr, sysp->sys_modnam); 1244 1245 switch (sysp->sys_op) { 1246 case SETOP_ASSIGN: 1247 *(uint8_t *)symaddr = uc; 1248 break; 1249 case SETOP_AND: 1250 *(uint8_t *)symaddr &= uc; 1251 break; 1252 case SETOP_OR: 1253 *(uint8_t *)symaddr |= uc; 1254 break; 1255 } 1256 1257 if (moddebug & MODDEBUG_LOADMSG) 1258 printf("now it is set to '0x%" PRIx8 "'.\n", 1259 *(uint8_t *)symaddr); 1260 } 1261 1262 static void 1263 set_int16_var(uintptr_t symaddr, struct sysparam *sysp) 1264 { 1265 uint16_t us = (uint16_t)sysp->sys_info; 1266 1267 if (moddebug & MODDEBUG_LOADMSG) 1268 printf("OP: %x: param '%s' was '0x%" PRIx16 1269 "' in module: '%s'.\n", sysp->sys_op, sysp->sys_ptr, 1270 *(uint16_t *)symaddr, sysp->sys_modnam); 1271 1272 switch (sysp->sys_op) { 1273 case SETOP_ASSIGN: 1274 *(uint16_t *)symaddr = us; 1275 break; 1276 case SETOP_AND: 1277 *(uint16_t *)symaddr &= us; 1278 break; 1279 case SETOP_OR: 1280 *(uint16_t *)symaddr |= us; 1281 break; 1282 } 1283 1284 if (moddebug & MODDEBUG_LOADMSG) 1285 printf("now it is set to '0x%" PRIx16 "'.\n", 1286 *(uint16_t *)symaddr); 1287 } 1288 1289 static void 1290 set_int32_var(uintptr_t symaddr, struct sysparam *sysp) 1291 { 1292 uint32_t ui = (uint32_t)sysp->sys_info; 1293 1294 if (moddebug & MODDEBUG_LOADMSG) 1295 printf("OP: %x: param '%s' was '0x%" PRIx32 1296 "' in module: '%s'.\n", sysp->sys_op, sysp->sys_ptr, 1297 *(uint32_t *)symaddr, sysp->sys_modnam); 1298 1299 switch (sysp->sys_op) { 1300 case SETOP_ASSIGN: 1301 *(uint32_t *)symaddr = ui; 1302 break; 1303 case SETOP_AND: 1304 *(uint32_t *)symaddr &= ui; 1305 break; 1306 case SETOP_OR: 1307 *(uint32_t *)symaddr |= ui; 1308 break; 1309 } 1310 1311 if (moddebug & MODDEBUG_LOADMSG) 1312 printf("now it is set to '0x%" PRIx32 "'.\n", 1313 *(uint32_t *)symaddr); 1314 } 1315 1316 static void 1317 set_int64_var(uintptr_t symaddr, struct sysparam *sysp) 1318 { 1319 uint64_t ul = sysp->sys_info; 1320 1321 if (moddebug & MODDEBUG_LOADMSG) 1322 printf("OP: %x: param '%s' was '0x%" PRIx64 1323 "' in module: '%s'.\n", sysp->sys_op, sysp->sys_ptr, 1324 *(uint64_t *)symaddr, sysp->sys_modnam); 1325 1326 switch (sysp->sys_op) { 1327 case SETOP_ASSIGN: 1328 *(uint64_t *)symaddr = ul; 1329 break; 1330 case SETOP_AND: 1331 *(uint64_t *)symaddr &= ul; 1332 break; 1333 case SETOP_OR: 1334 *(uint64_t *)symaddr |= ul; 1335 break; 1336 } 1337 1338 if (moddebug & MODDEBUG_LOADMSG) 1339 printf("now it is set to '0x%" PRIx64 "'.\n", 1340 *(uint64_t *)symaddr); 1341 } 1342 1343 /* 1344 * The next item on the line is a string value. Allocate memory for 1345 * it and copy the string. Return 1, and set arg ptr to newly allocated 1346 * and initialized buffer, or NULL if an error occurs. 1347 */ 1348 int 1349 kobj_get_string(u_longlong_t *llptr, char *tchar) 1350 { 1351 char *cp; 1352 char *start = (char *)0; 1353 int len = 0; 1354 1355 len = strlen(tchar); 1356 start = tchar; 1357 /* copy string */ 1358 cp = vmem_alloc(mod_sysfile_arena, len + 1, VM_SLEEP); 1359 bzero(cp, len + 1); 1360 *llptr = (u_longlong_t)(uintptr_t)cp; 1361 for (; len > 0; len--) { 1362 /* convert some common escape sequences */ 1363 if (*start == '\\') { 1364 switch (*(start + 1)) { 1365 case 't': 1366 /* tab */ 1367 *cp++ = '\t'; 1368 len--; 1369 start += 2; 1370 break; 1371 case 'n': 1372 /* new line */ 1373 *cp++ = '\n'; 1374 len--; 1375 start += 2; 1376 break; 1377 case 'b': 1378 /* back space */ 1379 *cp++ = '\b'; 1380 len--; 1381 start += 2; 1382 break; 1383 default: 1384 /* simply copy it */ 1385 *cp++ = *start++; 1386 break; 1387 } 1388 } else 1389 *cp++ = *start++; 1390 } 1391 *cp = '\0'; 1392 return (1); 1393 } 1394 1395 1396 /* 1397 * this function frees the memory allocated by kobj_get_string 1398 */ 1399 void 1400 kobj_free_string(void *ptr, int len) 1401 { 1402 vmem_free(mod_sysfile_arena, ptr, len); 1403 } 1404 1405 1406 /* 1407 * get a decimal octal or hex number. Handle '~' for one's complement. 1408 */ 1409 int 1410 kobj_getvalue(const char *token, u_longlong_t *valuep) 1411 { 1412 int radix; 1413 u_longlong_t retval = 0; 1414 int onescompl = 0; 1415 int negate = 0; 1416 char c; 1417 1418 if (*token == '~') { 1419 onescompl++; /* perform one's complement on result */ 1420 token++; 1421 } else if (*token == '-') { 1422 negate++; 1423 token++; 1424 } 1425 if (*token == '0') { 1426 token++; 1427 c = *token; 1428 1429 if (c == '\0') { 1430 *valuep = 0; /* value is 0 */ 1431 return (0); 1432 } 1433 1434 if (c == 'x' || c == 'X') { 1435 radix = 16; 1436 token++; 1437 } else 1438 radix = 8; 1439 } else 1440 radix = 10; 1441 1442 while ((c = *token++)) { 1443 switch (radix) { 1444 case 8: 1445 if (c >= '0' && c <= '7') 1446 c -= '0'; 1447 else 1448 return (-1); /* invalid number */ 1449 retval = (retval << 3) + c; 1450 break; 1451 case 10: 1452 if (c >= '0' && c <= '9') 1453 c -= '0'; 1454 else 1455 return (-1); /* invalid number */ 1456 retval = (retval * 10) + c; 1457 break; 1458 case 16: 1459 if (c >= 'a' && c <= 'f') 1460 c = c - 'a' + 10; 1461 else if (c >= 'A' && c <= 'F') 1462 c = c - 'A' + 10; 1463 else if (c >= '0' && c <= '9') 1464 c -= '0'; 1465 else 1466 return (-1); /* invalid number */ 1467 retval = (retval << 4) + c; 1468 break; 1469 } 1470 } 1471 if (onescompl) 1472 retval = ~retval; 1473 if (negate) 1474 retval = -retval; 1475 *valuep = retval; 1476 return (0); 1477 } 1478 1479 /* 1480 * Path to the root device and root filesystem type from 1481 * property information derived from the boot subsystem 1482 */ 1483 void 1484 setbootpath(char *path) 1485 { 1486 rootfs.bo_flags |= BO_VALID; 1487 (void) copystr(path, rootfs.bo_name, BO_MAXOBJNAME, NULL); 1488 BMDPRINTF(("rootfs bootpath: %s\n", rootfs.bo_name)); 1489 } 1490 1491 void 1492 setbootfstype(char *fstype) 1493 { 1494 (void) copystr(fstype, rootfs.bo_fstype, BO_MAXFSNAME, NULL); 1495 BMDPRINTF(("rootfs fstype: %s\n", rootfs.bo_fstype)); 1496 } 1497 1498 /* 1499 * set parameters that can be set early during initialization. 1500 */ 1501 static void 1502 setparams() 1503 { 1504 struct sysparam *sysp; 1505 struct bootobj *bootobjp; 1506 1507 for (sysp = sysparam_hd; sysp != NULL; sysp = sysp->sys_next) { 1508 1509 if (sysp->sys_type == MOD_MODDIR) { 1510 default_path = sysp->sys_ptr; 1511 continue; 1512 } 1513 1514 if (sysp->sys_type == MOD_SWAPDEV || 1515 sysp->sys_type == MOD_SWAPFS) 1516 bootobjp = &swapfile; 1517 else if (sysp->sys_type == MOD_ROOTFS) 1518 bootobjp = &rootfs; 1519 1520 switch (sysp->sys_type) { 1521 case MOD_SWAPDEV: 1522 bootobjp->bo_flags |= BO_VALID; 1523 (void) copystr(sysp->sys_ptr, bootobjp->bo_name, 1524 BO_MAXOBJNAME, NULL); 1525 break; 1526 case MOD_ROOTFS: 1527 case MOD_SWAPFS: 1528 bootobjp->bo_flags |= BO_VALID; 1529 (void) copystr(sysp->sys_ptr, bootobjp->bo_fstype, 1530 BO_MAXOBJNAME, NULL); 1531 break; 1532 case MOD_ROOTDEV: 1533 default: 1534 break; 1535 } 1536 } 1537 } 1538 1539 /* 1540 * clean up after an error. 1541 */ 1542 static void 1543 hwc_free(struct hwc_spec *hwcp) 1544 { 1545 char *name; 1546 1547 if ((name = hwcp->hwc_parent_name) != NULL) 1548 kmem_free(name, strlen(name) + 1); 1549 if ((name = hwcp->hwc_class_name) != NULL) 1550 kmem_free(name, strlen(name) + 1); 1551 if ((name = hwcp->hwc_devi_name) != NULL) 1552 kmem_free(name, strlen(name) + 1); 1553 i_ddi_prop_list_delete(hwcp->hwc_devi_sys_prop_ptr); 1554 kmem_free(hwcp, sizeof (struct hwc_spec)); 1555 } 1556 1557 /* 1558 * Free a list of specs 1559 */ 1560 void 1561 hwc_free_spec_list(struct hwc_spec *list) 1562 { 1563 while (list) { 1564 struct hwc_spec *tmp = list; 1565 list = tmp->hwc_next; 1566 hwc_free(tmp); 1567 } 1568 } 1569 1570 struct val_list { 1571 struct val_list *val_next; 1572 enum { 1573 VAL_STRING, 1574 VAL_INTEGER 1575 } val_type; 1576 int val_size; 1577 union { 1578 char *string; 1579 int integer; 1580 } val; 1581 }; 1582 1583 static struct val_list * 1584 add_val(struct val_list **val_listp, struct val_list *tail, 1585 int val_type, caddr_t val) 1586 { 1587 struct val_list *new_val; 1588 #ifdef DEBUG 1589 struct val_list *listp = *val_listp; 1590 #endif 1591 1592 new_val = kmem_alloc(sizeof (struct val_list), KM_SLEEP); 1593 new_val->val_next = NULL; 1594 if ((new_val->val_type = val_type) == VAL_STRING) { 1595 new_val->val_size = strlen((char *)val) + 1; 1596 new_val->val.string = kmem_alloc(new_val->val_size, KM_SLEEP); 1597 (void) strcpy(new_val->val.string, (char *)val); 1598 } else { 1599 new_val->val_size = sizeof (int); 1600 new_val->val.integer = (int)(uintptr_t)val; 1601 } 1602 1603 ASSERT((listp == NULL && tail == NULL) || 1604 (listp != NULL && tail != NULL)); 1605 1606 if (tail != NULL) { 1607 ASSERT(tail->val_next == NULL); 1608 tail->val_next = new_val; 1609 } else { 1610 *val_listp = new_val; 1611 } 1612 1613 return (new_val); 1614 } 1615 1616 static void 1617 free_val_list(struct val_list *head) 1618 { 1619 struct val_list *tval_list; 1620 1621 for (/* CSTYLED */; head != NULL; /* CSTYLED */) { 1622 tval_list = head; 1623 head = head->val_next; 1624 if (tval_list->val_type == VAL_STRING) 1625 kmem_free(tval_list->val.string, tval_list->val_size); 1626 kmem_free(tval_list, sizeof (struct val_list)); 1627 } 1628 } 1629 1630 /* 1631 * make sure there are no reserved IEEE 1275 characters (except 1632 * for uppercase characters). 1633 */ 1634 static int 1635 valid_prop_name(char *name) 1636 { 1637 int i; 1638 int len = strlen(name); 1639 1640 for (i = 0; i < len; i++) { 1641 if (name[i] < 0x21 || 1642 name[i] == '/' || 1643 name[i] == '\\' || 1644 name[i] == ':' || 1645 name[i] == '[' || 1646 name[i] == ']' || 1647 name[i] == '@') 1648 return (0); 1649 } 1650 return (1); 1651 } 1652 1653 static void 1654 make_prop(struct _buf *file, dev_info_t *devi, char *name, struct val_list *val) 1655 { 1656 int propcnt = 0, val_type; 1657 struct val_list *vl, *tvl; 1658 caddr_t valbuf = NULL; 1659 char **valsp; 1660 int *valip; 1661 1662 if (name == NULL) 1663 return; 1664 1665 #ifdef DEBUG 1666 parse_debug(NULL, "%s", name); 1667 #endif 1668 if (!valid_prop_name(name)) { 1669 cmn_err(CE_WARN, "invalid property name '%s'", name); 1670 return; 1671 } 1672 if (val) { 1673 for (vl = val, val_type = vl->val_type; vl; vl = vl->val_next) { 1674 if (val_type != vl->val_type) { 1675 cmn_err(CE_WARN, "Mixed types in value list"); 1676 return; 1677 } 1678 propcnt++; 1679 } 1680 1681 vl = val; 1682 1683 if (val_type == VAL_INTEGER) { 1684 valip = (int *)kmem_alloc( 1685 (propcnt * sizeof (int)), KM_SLEEP); 1686 valbuf = (caddr_t)valip; 1687 while (vl) { 1688 tvl = vl; 1689 vl = vl->val_next; 1690 #ifdef DEBUG 1691 parse_debug(NULL, " %x", tvl->val.integer); 1692 #endif 1693 *valip = tvl->val.integer; 1694 valip++; 1695 } 1696 /* restore valip */ 1697 valip = (int *)valbuf; 1698 1699 /* create the property */ 1700 if (e_ddi_prop_update_int_array(DDI_DEV_T_NONE, devi, 1701 name, valip, propcnt) != DDI_PROP_SUCCESS) { 1702 kobj_file_err(CE_WARN, file, 1703 "cannot create property %s", name); 1704 } 1705 /* cleanup */ 1706 kmem_free(valip, (propcnt * sizeof (int))); 1707 } else if (val_type == VAL_STRING) { 1708 valsp = (char **)kmem_alloc( 1709 ((propcnt + 1) * sizeof (char *)), KM_SLEEP); 1710 valbuf = (caddr_t)valsp; 1711 while (vl) { 1712 tvl = vl; 1713 vl = vl->val_next; 1714 #ifdef DEBUG 1715 parse_debug(NULL, " %s", tvl->val.string); 1716 #endif 1717 *valsp = tvl->val.string; 1718 valsp++; 1719 } 1720 /* terminate array with NULL */ 1721 *valsp = NULL; 1722 1723 /* restore valsp */ 1724 valsp = (char **)valbuf; 1725 1726 /* create the property */ 1727 if (e_ddi_prop_update_string_array(DDI_DEV_T_NONE, 1728 devi, name, valsp, propcnt) 1729 != DDI_PROP_SUCCESS) { 1730 kobj_file_err(CE_WARN, file, 1731 "cannot create property %s", name); 1732 } 1733 /* Clean up */ 1734 kmem_free(valsp, ((propcnt + 1) * sizeof (char *))); 1735 } else { 1736 cmn_err(CE_WARN, "Invalid property type"); 1737 return; 1738 } 1739 } else { 1740 /* 1741 * No value was passed in with property so we will assume 1742 * it is a "boolean" property and create an integer 1743 * property with 0 value. 1744 */ 1745 #ifdef DEBUG 1746 parse_debug(NULL, "\n"); 1747 #endif 1748 if (e_ddi_prop_update_int(DDI_DEV_T_NONE, devi, name, 0) 1749 != DDI_PROP_SUCCESS) { 1750 kobj_file_err(CE_WARN, file, 1751 "cannot create property %s", name); 1752 } 1753 } 1754 } 1755 1756 static char omit_err[] = "(the ';' may have been omitted on previous spec!)"; 1757 static char prnt_err[] = "'parent' property already specified"; 1758 static char nm_err[] = "'name' property already specified"; 1759 static char class_err[] = "'class' property already specified"; 1760 1761 typedef enum { 1762 hwc_begin, parent, drvname, drvclass, prop, 1763 parent_equals, name_equals, drvclass_equals, 1764 parent_equals_string, name_equals_string, 1765 drvclass_equals_string, 1766 prop_equals, prop_equals_string, prop_equals_integer, 1767 prop_equals_string_comma, prop_equals_integer_comma 1768 } hwc_state_t; 1769 1770 static struct hwc_spec * 1771 get_hwc_spec(struct _buf *file, char *tokbuf, size_t linesize) 1772 { 1773 char *prop_name; 1774 token_t token; 1775 struct hwc_spec *hwcp; 1776 struct dev_info *devi; 1777 struct val_list *val_list, *tail; 1778 hwc_state_t state; 1779 u_longlong_t ival; 1780 1781 hwcp = kmem_zalloc(sizeof (*hwcp), KM_SLEEP); 1782 devi = kmem_zalloc(sizeof (*devi), KM_SLEEP); 1783 1784 state = hwc_begin; 1785 token = NAME; 1786 prop_name = NULL; 1787 val_list = NULL; 1788 tail = NULL; 1789 do { 1790 #ifdef DEBUG 1791 parse_debug(NULL, "state 0x%x\n", state); 1792 #endif 1793 switch (token) { 1794 case NAME: 1795 switch (state) { 1796 case prop: 1797 case prop_equals_string: 1798 case prop_equals_integer: 1799 make_prop(file, (dev_info_t *)devi, 1800 prop_name, val_list); 1801 if (prop_name) { 1802 kmem_free(prop_name, 1803 strlen(prop_name) + 1); 1804 prop_name = NULL; 1805 } 1806 if (val_list) { 1807 free_val_list(val_list); 1808 val_list = NULL; 1809 } 1810 tail = NULL; 1811 /*FALLTHROUGH*/ 1812 case hwc_begin: 1813 if (strcmp(tokbuf, "PARENT") == 0 || 1814 strcmp(tokbuf, "parent") == 0) { 1815 state = parent; 1816 } else if (strcmp(tokbuf, "NAME") == 0 || 1817 strcmp(tokbuf, "name") == 0) { 1818 state = drvname; 1819 } else if (strcmp(tokbuf, "CLASS") == 0 || 1820 strcmp(tokbuf, "class") == 0) { 1821 state = drvclass; 1822 prop_name = kmem_alloc(strlen(tokbuf) + 1823 1, KM_SLEEP); 1824 (void) strcpy(prop_name, tokbuf); 1825 } else { 1826 state = prop; 1827 prop_name = kmem_alloc(strlen(tokbuf) + 1828 1, KM_SLEEP); 1829 (void) strcpy(prop_name, tokbuf); 1830 } 1831 break; 1832 default: 1833 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1834 } 1835 break; 1836 case EQUALS: 1837 switch (state) { 1838 case drvname: 1839 state = name_equals; 1840 break; 1841 case parent: 1842 state = parent_equals; 1843 break; 1844 case drvclass: 1845 state = drvclass_equals; 1846 break; 1847 case prop: 1848 state = prop_equals; 1849 break; 1850 default: 1851 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1852 } 1853 break; 1854 case STRING: 1855 switch (state) { 1856 case name_equals: 1857 if (ddi_get_name((dev_info_t *)devi)) { 1858 kobj_file_err(CE_WARN, file, "%s %s", 1859 nm_err, omit_err); 1860 goto bad; 1861 } 1862 devi->devi_name = kmem_alloc(strlen(tokbuf) + 1, 1863 KM_SLEEP); 1864 (void) strcpy(devi->devi_name, tokbuf); 1865 state = hwc_begin; 1866 break; 1867 case parent_equals: 1868 if (hwcp->hwc_parent_name) { 1869 kobj_file_err(CE_WARN, file, "%s %s", 1870 prnt_err, omit_err); 1871 goto bad; 1872 } 1873 hwcp->hwc_parent_name = kmem_alloc(strlen 1874 (tokbuf) + 1, KM_SLEEP); 1875 (void) strcpy(hwcp->hwc_parent_name, tokbuf); 1876 state = hwc_begin; 1877 break; 1878 case drvclass_equals: 1879 if (hwcp->hwc_class_name) { 1880 kobj_file_err(CE_WARN, file, class_err); 1881 goto bad; 1882 } 1883 hwcp->hwc_class_name = kmem_alloc( 1884 strlen(tokbuf) + 1, KM_SLEEP); 1885 (void) strcpy(hwcp->hwc_class_name, tokbuf); 1886 /*FALLTHROUGH*/ 1887 case prop_equals: 1888 case prop_equals_string_comma: 1889 tail = add_val(&val_list, tail, VAL_STRING, 1890 tokbuf); 1891 state = prop_equals_string; 1892 break; 1893 default: 1894 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1895 } 1896 break; 1897 case HEXVAL: 1898 case DECVAL: 1899 switch (state) { 1900 case prop_equals: 1901 case prop_equals_integer_comma: 1902 (void) kobj_getvalue(tokbuf, &ival); 1903 tail = add_val(&val_list, tail, 1904 VAL_INTEGER, (caddr_t)(uintptr_t)ival); 1905 state = prop_equals_integer; 1906 break; 1907 default: 1908 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1909 } 1910 break; 1911 case COMMA: 1912 switch (state) { 1913 case prop_equals_string: 1914 state = prop_equals_string_comma; 1915 break; 1916 case prop_equals_integer: 1917 state = prop_equals_integer_comma; 1918 break; 1919 default: 1920 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1921 } 1922 break; 1923 case NEWLINE: 1924 kobj_newline(file); 1925 break; 1926 case POUND: 1927 /* 1928 * Skip comments. 1929 */ 1930 kobj_find_eol(file); 1931 break; 1932 case EOF: 1933 kobj_file_err(CE_WARN, file, "Unexpected EOF"); 1934 goto bad; 1935 default: 1936 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 1937 goto bad; 1938 } 1939 } while ((token = kobj_lex(file, tokbuf, linesize)) != SEMICOLON); 1940 1941 switch (state) { 1942 case prop: 1943 case prop_equals_string: 1944 case prop_equals_integer: 1945 make_prop(file, (dev_info_t *)devi, 1946 prop_name, val_list); 1947 break; 1948 1949 case hwc_begin: 1950 break; 1951 default: 1952 kobj_file_err(CE_WARN, file, "Unexpected end of line"); 1953 break; 1954 } 1955 1956 /* copy 2 relevant members of devi to hwcp */ 1957 hwcp->hwc_devi_sys_prop_ptr = devi->devi_sys_prop_ptr; 1958 hwcp->hwc_devi_name = devi->devi_name; 1959 1960 if (prop_name) 1961 kmem_free(prop_name, strlen(prop_name) + 1); 1962 if (val_list) 1963 free_val_list(val_list); 1964 1965 kmem_free(devi, sizeof (struct dev_info)); 1966 1967 return (hwcp); 1968 1969 bad: 1970 if (prop_name) 1971 kmem_free(prop_name, strlen(prop_name) + 1); 1972 if (val_list) 1973 free_val_list(val_list); 1974 1975 hwc_free(hwcp); 1976 1977 if (devi->devi_name) 1978 kmem_free(devi->devi_name, strlen(devi->devi_name) + 1); 1979 1980 kmem_free(devi, sizeof (struct dev_info)); 1981 1982 return (NULL); 1983 } 1984 1985 /* 1986 * This is the primary kernel interface to parse driver.conf files. 1987 * 1988 * Yet another bigstk thread handoff due to deep kernel stacks when booting 1989 * cache-only-clients. 1990 */ 1991 int 1992 hwc_parse(char *fname, struct par_list **pl, ddi_prop_t **props) 1993 { 1994 int ret; 1995 struct hwc_parse_mt *pltp = hwc_parse_mtalloc(fname, pl, props); 1996 1997 if (curthread != &t0) { 1998 (void) thread_create(NULL, DEFAULTSTKSZ * 2, 1999 hwc_parse_thread, pltp, 0, &p0, TS_RUN, maxclsyspri); 2000 sema_p(&pltp->sema); 2001 } else { 2002 pltp->rv = hwc_parse_now(fname, pl, props); 2003 } 2004 ret = pltp->rv; 2005 hwc_parse_mtfree(pltp); 2006 return (ret); 2007 } 2008 2009 /* 2010 * Calls to hwc_parse() are handled off to this routine in a separate 2011 * thread. 2012 */ 2013 static void 2014 hwc_parse_thread(struct hwc_parse_mt *pltp) 2015 { 2016 kmutex_t cpr_lk; 2017 callb_cpr_t cpr_i; 2018 2019 mutex_init(&cpr_lk, NULL, MUTEX_DEFAULT, NULL); 2020 CALLB_CPR_INIT(&cpr_i, &cpr_lk, callb_generic_cpr, "hwc_parse"); 2021 2022 /* 2023 * load and parse the .conf file 2024 * return the hwc_spec list (if any) to the creator of this thread 2025 */ 2026 pltp->rv = hwc_parse_now(pltp->name, pltp->pl, pltp->props); 2027 sema_v(&pltp->sema); 2028 mutex_enter(&cpr_lk); 2029 CALLB_CPR_EXIT(&cpr_i); 2030 mutex_destroy(&cpr_lk); 2031 thread_exit(); 2032 } 2033 2034 /* 2035 * allocate and initialize a hwc_parse thread control structure 2036 */ 2037 static struct hwc_parse_mt * 2038 hwc_parse_mtalloc(char *name, struct par_list **pl, ddi_prop_t **props) 2039 { 2040 struct hwc_parse_mt *pltp = kmem_zalloc(sizeof (*pltp), KM_SLEEP); 2041 2042 ASSERT(name != NULL); 2043 2044 pltp->name = kmem_alloc(strlen(name) + 1, KM_SLEEP); 2045 bcopy(name, pltp->name, strlen(name) + 1); 2046 pltp->pl = pl; 2047 pltp->props = props; 2048 2049 sema_init(&pltp->sema, 0, NULL, SEMA_DEFAULT, NULL); 2050 return (pltp); 2051 } 2052 2053 /* 2054 * free a hwc_parse thread control structure 2055 */ 2056 static void 2057 hwc_parse_mtfree(struct hwc_parse_mt *pltp) 2058 { 2059 sema_destroy(&pltp->sema); 2060 2061 kmem_free(pltp->name, strlen(pltp->name) + 1); 2062 kmem_free(pltp, sizeof (*pltp)); 2063 } 2064 2065 /* 2066 * hwc_parse -- parse an hwconf file. Ignore error lines and parse 2067 * as much as possible. 2068 */ 2069 static int 2070 hwc_parse_now(char *fname, struct par_list **pl, ddi_prop_t **props) 2071 { 2072 struct _buf *file; 2073 struct hwc_spec *hwcp; 2074 char *tokval; 2075 token_t token; 2076 2077 /* 2078 * Don't use kobj_open_path's use_moddir_suffix option, we only 2079 * expect to find conf files in the base module directory, not 2080 * an ISA-specific subdirectory. 2081 */ 2082 if ((file = kobj_open_path(fname, 1, 0)) == (struct _buf *)-1) { 2083 if (moddebug & MODDEBUG_ERRMSG) 2084 cmn_err(CE_WARN, "Cannot open %s", fname); 2085 return (-1); 2086 } 2087 2088 /* 2089 * Initialize variables 2090 */ 2091 tokval = kmem_alloc(MAX_HWC_LINESIZE, KM_SLEEP); 2092 2093 while ((token = kobj_lex(file, tokval, MAX_HWC_LINESIZE)) != EOF) { 2094 switch (token) { 2095 case POUND: 2096 /* 2097 * Skip comments. 2098 */ 2099 kobj_find_eol(file); 2100 break; 2101 case NAME: 2102 hwcp = get_hwc_spec(file, tokval, MAX_HWC_LINESIZE); 2103 if (hwcp == NULL) 2104 break; 2105 /* 2106 * No devi_name indicates global property. 2107 * Make sure parent and class not NULL. 2108 */ 2109 if (hwcp->hwc_devi_name == NULL) { 2110 if (hwcp->hwc_parent_name || 2111 hwcp->hwc_class_name) { 2112 kobj_file_err(CE_WARN, file, 2113 "missing name attribute"); 2114 hwc_free(hwcp); 2115 continue; 2116 } 2117 /* Add to global property list */ 2118 add_props(hwcp, props); 2119 break; 2120 } 2121 2122 /* 2123 * This is a node spec, either parent or class 2124 * must be specified. 2125 */ 2126 if ((hwcp->hwc_parent_name == NULL) && 2127 (hwcp->hwc_class_name == NULL)) { 2128 kobj_file_err(CE_WARN, file, 2129 "missing parent or class attribute"); 2130 hwc_free(hwcp); 2131 continue; 2132 } 2133 2134 /* add to node spec list */ 2135 add_spec(hwcp, pl); 2136 break; 2137 case NEWLINE: 2138 kobj_newline(file); 2139 break; 2140 default: 2141 kobj_file_err(CE_WARN, file, tok_err, tokval); 2142 break; 2143 } 2144 } 2145 /* 2146 * XXX - Check for clean termination. 2147 */ 2148 kmem_free(tokval, MAX_HWC_LINESIZE); 2149 kobj_close_file(file); 2150 return (0); /* always return success */ 2151 } 2152 2153 void 2154 make_aliases(struct bind **bhash) 2155 { 2156 enum { 2157 AL_NEW, AL_DRVNAME, AL_DRVNAME_COMMA, AL_ALIAS, AL_ALIAS_COMMA 2158 } state; 2159 2160 struct _buf *file; 2161 char tokbuf[MAXPATHLEN]; 2162 char drvbuf[MAXPATHLEN]; 2163 token_t token; 2164 major_t major; 2165 int done = 0; 2166 static char dupwarn[] = "!Driver alias \"%s\" conflicts with " 2167 "an existing driver name or alias."; 2168 2169 if ((file = kobj_open_file(dafile)) == (struct _buf *)-1) 2170 return; 2171 2172 state = AL_NEW; 2173 major = DDI_MAJOR_T_NONE; 2174 while (!done) { 2175 token = kobj_lex(file, tokbuf, sizeof (tokbuf)); 2176 switch (token) { 2177 case POUND: 2178 /* 2179 * Skip comments. 2180 */ 2181 kobj_find_eol(file); 2182 break; 2183 case NAME: 2184 case STRING: 2185 switch (state) { 2186 case AL_NEW: 2187 (void) strcpy(drvbuf, tokbuf); 2188 state = AL_DRVNAME; 2189 break; 2190 case AL_DRVNAME_COMMA: 2191 (void) strcat(drvbuf, tokbuf); 2192 state = AL_DRVNAME; 2193 break; 2194 case AL_ALIAS_COMMA: 2195 (void) strcat(drvbuf, tokbuf); 2196 state = AL_ALIAS; 2197 break; 2198 case AL_DRVNAME: 2199 major = mod_name_to_major(drvbuf); 2200 if (major == DDI_MAJOR_T_NONE) { 2201 kobj_find_eol(file); 2202 state = AL_NEW; 2203 } else { 2204 (void) strcpy(drvbuf, tokbuf); 2205 state = AL_ALIAS; 2206 } 2207 break; 2208 case AL_ALIAS: 2209 if (make_mbind(drvbuf, major, NULL, bhash) 2210 != 0) { 2211 cmn_err(CE_WARN, dupwarn, drvbuf); 2212 } 2213 /* 2214 * copy this token just in case that there 2215 * are multiple names on the same line. 2216 */ 2217 (void) strcpy(drvbuf, tokbuf); 2218 break; 2219 } 2220 break; 2221 case COMMA: 2222 (void) strcat(drvbuf, tokbuf); 2223 switch (state) { 2224 case AL_DRVNAME: 2225 state = AL_DRVNAME_COMMA; 2226 break; 2227 case AL_ALIAS: 2228 state = AL_ALIAS_COMMA; 2229 break; 2230 default: 2231 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 2232 } 2233 break; 2234 case EOF: 2235 done = 1; 2236 /*FALLTHROUGH*/ 2237 case NEWLINE: 2238 if (state == AL_ALIAS) { 2239 if (make_mbind(drvbuf, major, NULL, bhash) 2240 != 0) { 2241 cmn_err(CE_WARN, dupwarn, drvbuf); 2242 } 2243 } else if (state != AL_NEW) { 2244 kobj_file_err(CE_WARN, file, 2245 "Missing alias for %s", drvbuf); 2246 } 2247 2248 kobj_newline(file); 2249 state = AL_NEW; 2250 major = DDI_MAJOR_T_NONE; 2251 break; 2252 default: 2253 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 2254 } 2255 } 2256 2257 kobj_close_file(file); 2258 } 2259 2260 2261 /* 2262 * It is called for parsing these files: 2263 * - /etc/path_to_inst 2264 * - /etc/name_to_major 2265 * - /etc/name_to_sysnum 2266 * A callback "int (*line_parser)(char *, int, char *, struct bind **)" 2267 * is invoked for each line of the file. 2268 * The callback can inhash the entry into a hashtable by supplying 2269 * a pre-allocated hashtable in "struct bind **hashtab". 2270 */ 2271 int 2272 read_binding_file(char *bindfile, struct bind **hashtab, 2273 int (*line_parser)(char *, int, char *, struct bind **)) 2274 { 2275 enum { 2276 B_NEW, B_NAME, B_VAL, B_BIND_NAME 2277 } state; 2278 struct _buf *file; 2279 char tokbuf[MAXNAMELEN]; 2280 token_t token; 2281 int maxnum = 0; 2282 char *bind_name = NULL, *name = NULL, *bn = NULL; 2283 u_longlong_t val; 2284 int done = 0; 2285 2286 static char num_err[] = "Missing number on preceding line?"; 2287 static char dupwarn[] = "!The binding file entry \"%s %u\" conflicts " 2288 "with a previous entry"; 2289 2290 if (hashtab != NULL) { 2291 clear_binding_hash(hashtab); 2292 } 2293 2294 if ((file = kobj_open_file(bindfile)) == (struct _buf *)-1) 2295 panic("read_binding_file: %s file not found", bindfile); 2296 2297 state = B_NEW; 2298 2299 while (!done) { 2300 token = kobj_lex(file, tokbuf, sizeof (tokbuf)); 2301 2302 switch (token) { 2303 case POUND: 2304 /* 2305 * Skip comments. 2306 */ 2307 kobj_find_eol(file); 2308 break; 2309 case NAME: 2310 case STRING: 2311 switch (state) { 2312 case B_NEW: 2313 /* 2314 * This case is for the first name and 2315 * possibly only name in an entry. 2316 */ 2317 ASSERT(name == NULL); 2318 name = kmem_alloc(strlen(tokbuf) + 1, KM_SLEEP); 2319 (void) strcpy(name, tokbuf); 2320 state = B_NAME; 2321 break; 2322 case B_VAL: 2323 /* 2324 * This case is for a second name, which 2325 * would be the binding name if the first 2326 * name was actually a generic name. 2327 */ 2328 ASSERT(bind_name == NULL); 2329 bind_name = kmem_alloc(strlen(tokbuf) + 1, 2330 KM_SLEEP); 2331 (void) strcpy(bind_name, tokbuf); 2332 state = B_BIND_NAME; 2333 break; 2334 default: 2335 kobj_file_err(CE_WARN, file, num_err); 2336 } 2337 break; 2338 case HEXVAL: 2339 case DECVAL: 2340 if (state != B_NAME) { 2341 kobj_file_err(CE_WARN, file, "Missing name?"); 2342 state = B_NEW; 2343 continue; 2344 } 2345 (void) kobj_getvalue(tokbuf, &val); 2346 if (val > (u_longlong_t)INT_MAX) { 2347 kobj_file_err(CE_WARN, file, 2348 "value %llu too large", val); 2349 state = B_NEW; 2350 continue; 2351 } 2352 state = B_VAL; 2353 break; 2354 case EOF: 2355 done = 1; 2356 /*FALLTHROUGH*/ 2357 case NEWLINE: 2358 if ((state == B_BIND_NAME) || (state == B_VAL)) { 2359 if (state == B_BIND_NAME) 2360 bn = bind_name; 2361 else 2362 bn = NULL; 2363 2364 if (line_parser != NULL) { 2365 if ((*line_parser)(name, (int)val, bn, 2366 hashtab) == 0) 2367 maxnum = MAX((int)val, maxnum); 2368 else 2369 kobj_file_err(CE_WARN, file, 2370 dupwarn, name, (uint_t)val); 2371 } 2372 } else if (state != B_NEW) 2373 kobj_file_err(CE_WARN, file, "Syntax error?"); 2374 2375 if (name) { 2376 kmem_free(name, strlen(name) + 1); 2377 name = NULL; 2378 } 2379 if (bind_name) { 2380 kmem_free(bind_name, strlen(bind_name) + 1); 2381 bind_name = NULL; 2382 } 2383 state = B_NEW; 2384 kobj_newline(file); 2385 break; 2386 default: 2387 kobj_file_err(CE_WARN, file, "Missing name/number?"); 2388 break; 2389 } 2390 } 2391 2392 ASSERT(name == NULL); /* any leaks? */ 2393 ASSERT(bind_name == NULL); 2394 2395 kobj_close_file(file); 2396 return (maxnum); 2397 } 2398 2399 /* 2400 * read_dacf_binding_file() 2401 * Read the /etc/dacf.conf file and build the dacf_rule_t database from it. 2402 * 2403 * The syntax of a line in the dacf.conf file is: 2404 * dev-spec [module:]op-set operation options [config-args]; 2405 * 2406 * Where: 2407 * 1. dev-spec is of the format: name="data" 2408 * 2. operation is the operation that this rule matches. (i.e. pre-detach) 2409 * 3. options is a comma delimited list of options (i.e. debug,foobar) 2410 * 4. config-data is a whitespace delimited list of the format: name="data" 2411 */ 2412 int 2413 read_dacf_binding_file(char *filename) 2414 { 2415 enum { 2416 DACF_BEGIN, 2417 /* minor_nodetype="ddi_mouse:serial" */ 2418 DACF_NT_SPEC, DACF_NT_EQUALS, DACF_NT_DATA, 2419 /* consconfig:mouseconfig */ 2420 DACF_MN_MODNAME, DACF_MN_COLON, DACF_MN_OPSET, 2421 /* op */ 2422 DACF_OP_NAME, 2423 /* [ option1, option2, option3... | - ] */ 2424 DACF_OPT_OPTION, DACF_OPT_COMMA, DACF_OPT_END, 2425 /* argname1="argval1" argname2="argval2" ... */ 2426 DACF_OPARG_SPEC, DACF_OPARG_EQUALS, DACF_OPARG_DATA, 2427 DACF_ERR, DACF_ERR_NEWLINE, DACF_COMMENT 2428 } state = DACF_BEGIN; 2429 2430 struct _buf *file; 2431 char *fname; 2432 token_t token; 2433 2434 char tokbuf[MAXNAMELEN]; 2435 char mn_modname_buf[MAXNAMELEN], *mn_modnamep = NULL; 2436 char mn_opset_buf[MAXNAMELEN], *mn_opsetp = NULL; 2437 char nt_data_buf[MAXNAMELEN], *nt_datap = NULL; 2438 char arg_spec_buf[MAXNAMELEN]; 2439 2440 uint_t opts = 0; 2441 dacf_devspec_t nt_spec_type = DACF_DS_ERROR; 2442 2443 dacf_arg_t *arg_list = NULL; 2444 dacf_opid_t opid = DACF_OPID_ERROR; 2445 int done = 0; 2446 2447 static char w_syntax[] = "'%s' unexpected"; 2448 static char w_equals[] = "'=' is illegal in the current context"; 2449 static char w_baddevspec[] = "device specification '%s' unrecognized"; 2450 static char w_badop[] = "operation '%s' unrecognized"; 2451 static char w_badopt[] = "option '%s' unrecognized, ignoring"; 2452 static char w_newline[] = "rule is incomplete"; 2453 static char w_insert[] = "failed to register rule"; 2454 static char w_comment[] = "'#' not allowed except at start of line"; 2455 static char w_dupargs[] = 2456 "argument '%s' duplicates a previous argument, skipping"; 2457 static char w_nt_empty[] = "empty device specification not allowed"; 2458 2459 if (filename == NULL) { 2460 fname = dacffile; /* default binding file */ 2461 } else { 2462 fname = filename; /* user specified */ 2463 } 2464 2465 if ((file = kobj_open_file(fname)) == (struct _buf *)-1) { 2466 return (ENOENT); 2467 } 2468 2469 if (dacfdebug & DACF_DBG_MSGS) { 2470 printf("dacf debug: clearing rules database\n"); 2471 } 2472 2473 mutex_enter(&dacf_lock); 2474 dacf_clear_rules(); 2475 2476 if (dacfdebug & DACF_DBG_MSGS) { 2477 printf("dacf debug: parsing %s\n", fname); 2478 } 2479 2480 while (!done) { 2481 token = kobj_lex(file, tokbuf, sizeof (tokbuf)); 2482 2483 switch (token) { 2484 case POUND: /* comment line */ 2485 if (state != DACF_BEGIN) { 2486 kobj_file_err(CE_WARN, file, w_comment); 2487 state = DACF_ERR; 2488 break; 2489 } 2490 state = DACF_COMMENT; 2491 kobj_find_eol(file); 2492 break; 2493 2494 case EQUALS: 2495 switch (state) { 2496 case DACF_NT_SPEC: 2497 state = DACF_NT_EQUALS; 2498 break; 2499 case DACF_OPARG_SPEC: 2500 state = DACF_OPARG_EQUALS; 2501 break; 2502 default: 2503 kobj_file_err(CE_WARN, file, w_equals); 2504 state = DACF_ERR; 2505 } 2506 break; 2507 2508 case NAME: 2509 switch (state) { 2510 case DACF_BEGIN: 2511 nt_spec_type = dacf_get_devspec(tokbuf); 2512 if (nt_spec_type == DACF_DS_ERROR) { 2513 kobj_file_err(CE_WARN, file, 2514 w_baddevspec, tokbuf); 2515 state = DACF_ERR; 2516 break; 2517 } 2518 state = DACF_NT_SPEC; 2519 break; 2520 case DACF_NT_DATA: 2521 (void) strncpy(mn_modname_buf, tokbuf, 2522 sizeof (mn_modname_buf)); 2523 mn_modnamep = mn_modname_buf; 2524 state = DACF_MN_MODNAME; 2525 break; 2526 case DACF_MN_MODNAME: 2527 /* 2528 * This handles the 'optional' modname. 2529 * What we thought was the modname is really 2530 * the op-set. So it is copied over. 2531 */ 2532 ASSERT(mn_modnamep); 2533 (void) strncpy(mn_opset_buf, mn_modnamep, 2534 sizeof (mn_opset_buf)); 2535 mn_opsetp = mn_opset_buf; 2536 mn_modnamep = NULL; 2537 /* 2538 * Now, the token we just read is the opset, 2539 * so look that up and fill in opid 2540 */ 2541 if ((opid = dacf_get_op(tokbuf)) == 2542 DACF_OPID_ERROR) { 2543 kobj_file_err(CE_WARN, file, w_badop, 2544 tokbuf); 2545 state = DACF_ERR; 2546 break; 2547 } 2548 state = DACF_OP_NAME; 2549 break; 2550 case DACF_MN_COLON: 2551 (void) strncpy(mn_opset_buf, tokbuf, 2552 sizeof (mn_opset_buf)); 2553 mn_opsetp = mn_opset_buf; 2554 state = DACF_MN_OPSET; 2555 break; 2556 case DACF_MN_OPSET: 2557 if ((opid = dacf_get_op(tokbuf)) == 2558 DACF_OPID_ERROR) { 2559 kobj_file_err(CE_WARN, file, w_badop, 2560 tokbuf); 2561 state = DACF_ERR; 2562 break; 2563 } 2564 state = DACF_OP_NAME; 2565 break; 2566 case DACF_OP_NAME: 2567 /* 2568 * This case is just like DACF_OPT_COMMA below, 2569 * but we check for the sole '-' argument 2570 */ 2571 if (strcmp(tokbuf, "-") == 0) { 2572 state = DACF_OPT_END; 2573 break; 2574 } 2575 /*FALLTHROUGH*/ 2576 case DACF_OPT_COMMA: 2577 /* 2578 * figure out what option was given, but don't 2579 * make a federal case if invalid, just skip it 2580 */ 2581 if (dacf_getopt(tokbuf, &opts) != 0) { 2582 kobj_file_err(CE_WARN, file, w_badopt, 2583 tokbuf); 2584 } 2585 state = DACF_OPT_OPTION; 2586 break; 2587 case DACF_OPT_END: 2588 case DACF_OPT_OPTION: 2589 case DACF_OPARG_DATA: 2590 (void) strncpy(arg_spec_buf, tokbuf, 2591 sizeof (arg_spec_buf)); 2592 state = DACF_OPARG_SPEC; 2593 break; 2594 case DACF_OPARG_EQUALS: 2595 /* 2596 * Add the arg. Warn if it's a duplicate 2597 */ 2598 if (dacf_arg_insert(&arg_list, arg_spec_buf, 2599 tokbuf) != 0) { 2600 kobj_file_err(CE_WARN, file, w_dupargs, 2601 arg_spec_buf); 2602 } 2603 state = DACF_OPARG_DATA; 2604 break; 2605 default: 2606 kobj_file_err(CE_WARN, file, w_syntax, tokbuf); 2607 state = DACF_ERR; 2608 break; 2609 } 2610 break; 2611 2612 case STRING: 2613 /* 2614 * We need to check to see if the string has a \n in it. 2615 * If so, we had an unmatched " mark error, and lex has 2616 * already emitted an error for us, so we need to enter 2617 * the error state. Stupid lex. 2618 */ 2619 if (strchr(tokbuf, '\n')) { 2620 state = DACF_ERR; 2621 break; 2622 } 2623 switch (state) { 2624 case DACF_NT_EQUALS: 2625 if (strlen(tokbuf) == 0) { 2626 kobj_file_err(CE_WARN, file, 2627 w_nt_empty); 2628 state = DACF_ERR; 2629 break; 2630 } 2631 state = DACF_NT_DATA; 2632 nt_datap = nt_data_buf; 2633 (void) strncpy(nt_datap, tokbuf, 2634 sizeof (nt_data_buf)); 2635 break; 2636 case DACF_OPARG_EQUALS: 2637 /* 2638 * Add the arg. Warn if it's a duplicate 2639 */ 2640 if (dacf_arg_insert(&arg_list, arg_spec_buf, 2641 tokbuf) != 0) { 2642 kobj_file_err(CE_WARN, file, w_dupargs, 2643 arg_spec_buf); 2644 } 2645 state = DACF_OPARG_DATA; 2646 break; 2647 default: 2648 kobj_file_err(CE_WARN, file, w_syntax, tokbuf); 2649 state = DACF_ERR; 2650 break; 2651 } 2652 break; 2653 2654 case COMMA: 2655 switch (state) { 2656 case DACF_OPT_OPTION: 2657 state = DACF_OPT_COMMA; 2658 break; 2659 default: 2660 kobj_file_err(CE_WARN, file, w_syntax, ","); 2661 state = DACF_ERR; 2662 break; 2663 } 2664 break; 2665 2666 case COLON: 2667 if (state == DACF_MN_MODNAME) 2668 state = DACF_MN_COLON; 2669 else { 2670 kobj_file_err(CE_WARN, file, w_syntax, ":"); 2671 state = DACF_ERR; 2672 } 2673 break; 2674 2675 case EOF: 2676 done = 1; 2677 /*FALLTHROUGH*/ 2678 case NEWLINE: 2679 if (state == DACF_COMMENT || state == DACF_BEGIN) { 2680 state = DACF_BEGIN; 2681 kobj_newline(file); 2682 break; 2683 } 2684 if ((state != DACF_OPT_OPTION) && 2685 (state != DACF_OPARG_DATA) && 2686 (state != DACF_OPT_END)) { 2687 kobj_file_err(CE_WARN, file, w_newline); 2688 /* 2689 * We can't just do DACF_ERR here, since we'll 2690 * wind up eating the _next_ newline if so. 2691 */ 2692 state = DACF_ERR_NEWLINE; 2693 kobj_newline(file); 2694 break; 2695 } 2696 2697 /* 2698 * insert the rule. 2699 */ 2700 if (dacf_rule_insert(nt_spec_type, nt_datap, 2701 mn_modnamep, mn_opsetp, opid, opts, arg_list) < 0) { 2702 /* 2703 * We can't just do DACF_ERR here, since we'll 2704 * wind up eating the _next_ newline if so. 2705 */ 2706 kobj_file_err(CE_WARN, file, w_insert); 2707 state = DACF_ERR_NEWLINE; 2708 kobj_newline(file); 2709 break; 2710 } 2711 2712 state = DACF_BEGIN; 2713 kobj_newline(file); 2714 break; 2715 2716 default: 2717 kobj_file_err(CE_WARN, file, w_syntax, tokbuf); 2718 break; 2719 } /* switch */ 2720 2721 /* 2722 * Clean up after ourselves, either after a line has terminated 2723 * successfully or because of a syntax error; or when we reach 2724 * EOF (remember, we may reach EOF without being 'done' with 2725 * handling a particular line). 2726 */ 2727 if (state == DACF_ERR) { 2728 kobj_find_eol(file); 2729 } 2730 if ((state == DACF_BEGIN) || (state == DACF_ERR) || 2731 (state == DACF_ERR_NEWLINE) || done) { 2732 nt_datap = NULL; 2733 mn_modnamep = mn_opsetp = NULL; 2734 opts = 0; 2735 opid = DACF_OPID_ERROR; 2736 nt_spec_type = DACF_DS_ERROR; 2737 dacf_arglist_delete(&arg_list); 2738 state = DACF_BEGIN; 2739 } 2740 } /* while */ 2741 2742 if (dacfdebug & DACF_DBG_MSGS) { 2743 printf("\ndacf debug: done!\n"); 2744 } 2745 2746 mutex_exit(&dacf_lock); 2747 2748 kobj_close_file(file); 2749 return (0); 2750 } 2751 2752 void 2753 lock_hw_class_list() 2754 { 2755 mutex_enter(&hcl_lock); 2756 } 2757 2758 void 2759 unlock_hw_class_list() 2760 { 2761 mutex_exit(&hcl_lock); 2762 } 2763 2764 void 2765 add_class(char *exporter, char *class) 2766 { 2767 struct hwc_class *hcl; 2768 2769 /* 2770 * If exporter's major is not registered in /etc/name_to_major, 2771 * don't update hwc_class, but just return here. 2772 */ 2773 if (ddi_name_to_major(exporter) >= devcnt) { 2774 cmn_err(CE_WARN, "No major number for driver %s" 2775 " in class %s", exporter, class); 2776 return; 2777 } 2778 hcl = kmem_zalloc(sizeof (struct hwc_class), KM_SLEEP); 2779 hcl->class_exporter = kmem_alloc(strlen(exporter) + 1, KM_SLEEP); 2780 hcl->class_name = kmem_alloc(strlen(class) + 1, KM_SLEEP); 2781 (void) strcpy(hcl->class_exporter, exporter); 2782 (void) strcpy(hcl->class_name, class); 2783 lock_hw_class_list(); 2784 hcl->class_next = hcl_head; 2785 hcl_head = hcl; 2786 unlock_hw_class_list(); 2787 } 2788 2789 /* 2790 * Return the number of classes exported. If buf is not NULL, fill in 2791 * the array of the class names as well. 2792 * 2793 * Caller must hold hcl_lock to ensure the class list unmodified while 2794 * it is accessed. A typical caller will get a count first and then 2795 * allocate buf. The lock should be held by the caller. 2796 */ 2797 int 2798 get_class(const char *exporter, char **buf) 2799 { 2800 int n = 0; 2801 struct hwc_class *hcl; 2802 2803 ASSERT(mutex_owned(&hcl_lock)); 2804 for (hcl = hcl_head; hcl != NULL; hcl = hcl->class_next) { 2805 if (strcmp(exporter, hcl->class_exporter) == 0) { 2806 if (buf) 2807 buf[n] = hcl->class_name; 2808 ++n; 2809 } 2810 } 2811 2812 return (n); 2813 } 2814 2815 void 2816 read_class_file(void) 2817 { 2818 struct _buf *file; 2819 struct hwc_class *hcl, *hcl1; 2820 char tokbuf[MAXNAMELEN]; 2821 enum { 2822 C_BEGIN, C_EXPORTER, C_END 2823 } state; 2824 token_t token; 2825 int done = 0; 2826 char *exporter = NULL, *class = NULL, *name = NULL; 2827 2828 if (hcl_head != NULL) { 2829 hcl = hcl_head; 2830 while (hcl != NULL) { 2831 kmem_free(hcl->class_exporter, 2832 strlen(hcl->class_exporter) + 1); 2833 hcl1 = hcl; 2834 hcl = hcl->class_next; 2835 kmem_free(hcl1, sizeof (struct hwc_class)); 2836 } 2837 hcl_head = NULL; 2838 } 2839 2840 if ((file = kobj_open_file(class_file)) == (struct _buf *)-1) 2841 return; 2842 2843 state = C_BEGIN; 2844 while (!done) { 2845 token = kobj_lex(file, tokbuf, sizeof (tokbuf)); 2846 2847 switch (token) { 2848 case POUND: 2849 /* 2850 * Skip comments. 2851 */ 2852 kobj_find_eol(file); 2853 break; 2854 case NAME: 2855 case STRING: 2856 name = kmem_alloc(strlen(tokbuf) + 1, KM_SLEEP); 2857 (void) strcpy(name, tokbuf); 2858 switch (state) { 2859 case C_BEGIN: 2860 exporter = name; 2861 state = C_EXPORTER; 2862 break; 2863 case C_EXPORTER: 2864 class = name; 2865 add_class(exporter, class); 2866 state = C_END; 2867 break; 2868 case C_END: 2869 kobj_file_err(CE_WARN, file, 2870 "Extra noise after entry"); 2871 kmem_free(name, strlen(name) + 1); 2872 kobj_find_eol(file); 2873 break; 2874 } /* End Switch */ 2875 break; 2876 case EOF: 2877 done = 1; 2878 /*FALLTHROUGH*/ 2879 case NEWLINE: 2880 kobj_newline(file); 2881 if (state == C_EXPORTER) 2882 kobj_file_err(CE_WARN, file, 2883 "Partial entry ignored"); 2884 state = C_BEGIN; 2885 if (exporter) 2886 kmem_free(exporter, strlen(exporter) + 1); 2887 if (class) 2888 kmem_free(class, strlen(class) + 1); 2889 exporter = NULL; 2890 class = NULL; 2891 break; 2892 default: 2893 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 2894 break; 2895 } 2896 } 2897 kobj_close_file(file); 2898 } 2899 2900 /* 2901 * Given par_list, get a list of parent major number 2902 */ 2903 int 2904 impl_parlist_to_major(struct par_list *pl, char parents[]) 2905 { 2906 struct hwc_spec *hwcp; 2907 struct hwc_class *hcl; 2908 major_t major; 2909 int nmajor = 0; 2910 extern int devcnt; 2911 2912 for (; pl != NULL; pl = pl->par_next) { 2913 if ((pl->par_major < devcnt) && (parents[pl->par_major] == 0)) { 2914 parents[pl->par_major] = 1; 2915 nmajor++; 2916 continue; 2917 } 2918 2919 /* parent specs cannot be mapped to a driver */ 2920 if (pl->par_major != DDI_MAJOR_T_NONE) 2921 continue; 2922 2923 /* class spec */ 2924 hwcp = pl->par_specs; 2925 ASSERT(hwcp->hwc_class_name); 2926 ASSERT(hwcp->hwc_parent_name == NULL); 2927 2928 for (hcl = hcl_head; hcl != NULL; hcl = hcl->class_next) { 2929 if (strcmp(hwcp->hwc_class_name, hcl->class_name) != 0) 2930 continue; 2931 major = ddi_name_to_major(hcl->class_exporter); 2932 ASSERT(major != DDI_MAJOR_T_NONE); 2933 if (parents[major] == 0) { 2934 parents[major] = 1; 2935 nmajor++; 2936 } 2937 } 2938 } 2939 return (nmajor); 2940 } 2941 2942 /* 2943 * delete a parent list and all its hwc specs 2944 */ 2945 void 2946 impl_delete_par_list(struct par_list *pl) 2947 { 2948 struct par_list *saved_pl; 2949 struct hwc_spec *hp, *hp1; 2950 2951 while (pl) { 2952 hp = pl->par_specs; 2953 while (hp) { 2954 hp1 = hp; 2955 hp = hp->hwc_next; 2956 hwc_free(hp1); 2957 } 2958 saved_pl = pl; 2959 pl = pl->par_next; 2960 kmem_free(saved_pl, sizeof (*saved_pl)); 2961 } 2962 } 2963 2964 #if defined(_PSM_MODULES) 2965 void 2966 open_mach_list(void) 2967 { 2968 struct _buf *file; 2969 char tokbuf[MAXNAMELEN]; 2970 token_t token; 2971 struct psm_mach *machp; 2972 2973 if ((file = kobj_open_file(mach_file)) == (struct _buf *)-1) 2974 return; 2975 2976 while ((token = kobj_lex(file, tokbuf, sizeof (tokbuf))) != EOF) { 2977 switch (token) { 2978 case POUND: 2979 /* 2980 * Skip comments. 2981 */ 2982 kobj_find_eol(file); 2983 break; 2984 case NAME: 2985 case STRING: 2986 machp = kmem_alloc((sizeof (struct psm_mach) + 2987 strlen(tokbuf) + 1), KM_SLEEP); 2988 machp->m_next = pmach_head; 2989 machp->m_machname = (char *)(machp + 1); 2990 (void) strcpy(machp->m_machname, tokbuf); 2991 pmach_head = machp; 2992 break; 2993 case NEWLINE: 2994 kobj_newline(file); 2995 break; 2996 default: 2997 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 2998 break; 2999 } 3000 } 3001 kobj_close_file(file); 3002 } 3003 3004 void * 3005 get_next_mach(void *handle, char *buf) 3006 { 3007 struct psm_mach *machp; 3008 3009 machp = (struct psm_mach *)handle; 3010 if (machp) 3011 machp = machp->m_next; 3012 else 3013 machp = pmach_head; 3014 if (machp) 3015 (void) strcpy(buf, machp->m_machname); 3016 return (machp); 3017 } 3018 3019 void 3020 close_mach_list(void) 3021 { 3022 struct psm_mach *machp; 3023 3024 while (pmach_head) { 3025 machp = pmach_head; 3026 pmach_head = machp->m_next; 3027 kmem_free(machp, sizeof (struct psm_mach) + 3028 strlen(machp->m_machname) + 1); 3029 } 3030 } 3031 #endif /* _PSM_MODULES */ 3032 3033 #if defined(_RTC_CONFIG) 3034 /* 3035 * Read in the 'zone_lag' value from the rtc configuration file, 3036 * and return the value to the caller. Note that there is other information 3037 * in this file (zone_info), so we ignore unknown values. We do spit out 3038 * warnings if the line doesn't begin with an identifier, or if we don't find 3039 * exactly "zone_lag=value". No one should be editing this file by hand 3040 * (use the rtc command instead), but it's better to be careful. 3041 */ 3042 long 3043 process_rtc_config_file(void) 3044 { 3045 enum { 3046 R_NEW, R_NAME, R_EQUALS, R_VALUE 3047 } state; 3048 struct _buf *file; 3049 char tokbuf[MAXNAMELEN]; 3050 token_t token; 3051 long zone_lag = 0; 3052 u_longlong_t tmp; 3053 int done = 0; 3054 3055 if ((file = kobj_open_file(rtc_config_file)) == (struct _buf *)-1) 3056 return (0); 3057 3058 state = R_NEW; 3059 3060 while (!done) { 3061 token = kobj_lex(file, tokbuf, sizeof (tokbuf)); 3062 3063 switch (token) { 3064 case POUND: 3065 /* 3066 * Skip comments. 3067 */ 3068 kobj_find_eol(file); 3069 break; 3070 case NAME: 3071 case STRING: 3072 if (state == R_NEW) { 3073 if (strcmp(tokbuf, "zone_lag") == 0) 3074 state = R_NAME; 3075 else 3076 kobj_find_eol(file); /* Ignore */ 3077 } else 3078 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 3079 break; 3080 case EQUALS: 3081 if (state == R_NAME) 3082 state = R_EQUALS; 3083 else 3084 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 3085 break; 3086 case DECVAL: 3087 if (state == R_EQUALS) { 3088 if (kobj_getvalue(tokbuf, &tmp) != 0) 3089 kobj_file_err(CE_WARN, file, 3090 "Bad value %s for zone_lag", 3091 tokbuf); 3092 else 3093 zone_lag = (long)tmp; 3094 state = R_VALUE; 3095 } else 3096 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 3097 break; 3098 case EOF: 3099 done = 1; 3100 /*FALLTHROUGH*/ 3101 case NEWLINE: 3102 if (state != R_NEW && state != R_VALUE) 3103 kobj_file_err(CE_WARN, file, 3104 "Partial zone_lag entry ignored"); 3105 kobj_newline(file); 3106 state = R_NEW; 3107 break; 3108 default: 3109 kobj_file_err(CE_WARN, file, tok_err, tokbuf); 3110 break; 3111 } 3112 } 3113 kobj_close_file(file); 3114 return (zone_lag); 3115 } 3116 #endif /* _RTC_CONFIG */ 3117 3118 3119 /* 3120 * Append node spec to the end of par_list 3121 */ 3122 static void 3123 append(struct hwc_spec *spec, struct par_list *par) 3124 { 3125 struct hwc_spec *hwc, *last; 3126 3127 ASSERT(par->par_specs); 3128 for (hwc = par->par_specs; hwc; hwc = hwc->hwc_next) 3129 last = hwc; 3130 last->hwc_next = spec; 3131 } 3132 3133 /* 3134 * Given a parent=/full-pathname, see if the platform 3135 * can resolve the pathname to driver, otherwise, try 3136 * the leaf node name. 3137 */ 3138 static major_t 3139 get_major(char *parent) 3140 { 3141 major_t major = DDI_MAJOR_T_NONE; 3142 char *tmp, *driver = NULL; 3143 3144 if (*parent == '/') 3145 major = path_to_major(parent); 3146 3147 if (major != DDI_MAJOR_T_NONE) 3148 return (major); 3149 3150 /* extract the name between '/' and '@' */ 3151 if (*parent == '/') 3152 driver = strrchr(parent, '/') + 1; 3153 else 3154 driver = parent; 3155 if ((tmp = strchr(driver, '@')) != NULL) 3156 *tmp = '\0'; 3157 major = ddi_name_to_major(driver); 3158 if (tmp) 3159 *tmp = '@'; 3160 return (major); 3161 } 3162 3163 /* 3164 * Chain together specs whose parent's module name is the same. 3165 */ 3166 static void 3167 add_spec(struct hwc_spec *spec, struct par_list **par) 3168 { 3169 major_t maj; 3170 struct par_list *pl, *par_last = NULL; 3171 char *parent = spec->hwc_parent_name; 3172 char *class = spec->hwc_class_name; 3173 3174 ASSERT(parent || class); 3175 3176 /* 3177 * If given a parent=/full-pathname, see if the platform 3178 * can resolve the pathname to driver, otherwise, try 3179 * the leaf node name. 3180 * 3181 * If parent=/full-pathname doesn't resolve to a driver, 3182 * this could be cause by DR removal of the device. 3183 * We put it on the major=-2 list in case the device 3184 * is brought back into the system by DR. 3185 */ 3186 if (parent) { 3187 maj = get_major(parent); 3188 if (maj == DDI_MAJOR_T_NONE) { 3189 if ((*parent == '/') && 3190 (strncmp(parent, "/pseudo", 7) != 0)) { 3191 maj = (major_t)-2; 3192 } else { 3193 cmn_err(CE_WARN, 3194 "add_spec: No major number for %s", 3195 parent); 3196 hwc_free(spec); 3197 return; 3198 } 3199 } 3200 } else 3201 maj = DDI_MAJOR_T_NONE; 3202 3203 /* 3204 * Scan the list looking for a matching parent. When parent is 3205 * not NULL, we match the parent by major. If parent is NULL but 3206 * class is not NULL, we mache the pl by class name. 3207 */ 3208 for (pl = *par; pl; pl = pl->par_next) { 3209 if ((parent && (maj == pl->par_major)) || ((parent == NULL) && 3210 class && pl->par_specs->hwc_class_name && (strncmp(class, 3211 pl->par_specs->hwc_class_name, strlen(class)) == 0))) { 3212 append(spec, pl); 3213 return; 3214 } 3215 par_last = pl; 3216 } 3217 3218 /* 3219 * Didn't find a match on the list. Make a new parent list. 3220 */ 3221 pl = kmem_zalloc(sizeof (*pl), KM_SLEEP); 3222 pl->par_major = maj; 3223 pl->par_specs = spec; 3224 if (*par == NULL) { /* null par list */ 3225 *par = pl; 3226 return; 3227 } 3228 /* put "class=" entries last (lower pri if dups) */ 3229 if (maj == DDI_MAJOR_T_NONE) { 3230 par_last->par_next = pl; 3231 return; 3232 } 3233 3234 /* ensure unresolved "parent=/full-path" goes first */ 3235 if ((maj != (major_t)-2) && ((*par)->par_major == (major_t)-2)) 3236 par = &(*par)->par_next; 3237 pl->par_next = *par; 3238 *par = pl; 3239 } 3240 3241 /* 3242 * Add property spec to property list in original order 3243 */ 3244 static void 3245 add_props(struct hwc_spec *spec, ddi_prop_t **props) 3246 { 3247 ASSERT(spec->hwc_devi_name == NULL); 3248 3249 if (spec->hwc_devi_sys_prop_ptr) { 3250 while (*props) 3251 props = &(*props)->prop_next; 3252 *props = spec->hwc_devi_sys_prop_ptr; 3253 3254 /* remove these properties from the spec */ 3255 spec->hwc_devi_sys_prop_ptr = NULL; 3256 } 3257 hwc_free(spec); 3258 } 3259