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 }