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