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