![[BACK]](/icons/back.gif){kind=icon}
Return to subr_userconf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to subr_userconf.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: subr_userconf.c,v 1.34 2005/12/09 09:09:52 jsg Exp $ */
2:
3: /*
4: * Copyright (c) 1996-2001 Mats O Jansson <moj@stacken.kth.se>
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26: * SUCH DAMAGE.
27: */
28:
29: #include <sys/param.h>
30: #include <sys/systm.h>
31: #include <sys/device.h>
32: #include <sys/malloc.h>
33: #include <sys/time.h>
34:
35: #include <dev/cons.h>
36:
37: extern char *locnames[];
38: extern short locnamp[];
39: extern short cfroots[];
40: extern int cfroots_size;
41: extern int pv_size;
42: extern short pv[];
43: extern struct timezone tz;
44: extern char *pdevnames[];
45: extern int pdevnames_size;
46: extern struct pdevinit pdevinit[];
47:
48: int userconf_base = 16; /* Base for "large" numbers */
49: int userconf_maxdev = -1; /* # of used device slots */
50: int userconf_totdev = -1; /* # of device slots */
51: int userconf_maxlocnames = -1; /* # of locnames */
52: int userconf_cnt = -1; /* Line counter for ... */
53: int userconf_lines = 12; /* ... # of lines per page */
54: int userconf_histlen = 0;
55: int userconf_histcur = 0;
56: char userconf_history[1024];
57: int userconf_histsz = sizeof(userconf_history);
58: char userconf_argbuf[40]; /* Additional input */
59: char userconf_cmdbuf[40]; /* Command line */
60: char userconf_histbuf[40];
61:
62: void userconf_init(void);
63: int userconf_more(void);
64: void userconf_modify(char *, int *);
65: void userconf_hist_cmd(char);
66: void userconf_hist_int(int);
67: void userconf_hist_eoc(void);
68: void userconf_pnum(int);
69: void userconf_pdevnam(short);
70: void userconf_pdev(short);
71: int userconf_number(char *, int *);
72: int userconf_device(char *, int *, short *, short *);
73: int userconf_attr(char *, int *);
74: void userconf_modify(char *, int *);
75: void userconf_change(int);
76: void userconf_disable(int);
77: void userconf_enable(int);
78: void userconf_help(void);
79: void userconf_list(void);
80: void userconf_show(void);
81: void userconf_common_attr_val(short, int *, char);
82: void userconf_show_attr(char *);
83: void userconf_common_dev(char *, int, short, short, char);
84: void userconf_common_attr(char *, int, char);
85: void userconf_add_read(char *, char, char *, int, int *);
86: void userconf_add(char *, int, short, short);
87: int userconf_parse(char *);
88:
89: #define UC_CHANGE 'c'
90: #define UC_DISABLE 'd'
91: #define UC_ENABLE 'e'
92: #define UC_FIND 'f'
93: #define UC_SHOW 's'
94:
95: char *userconf_cmds[] = {
96: "add", "a",
97: "base", "b",
98: "change", "c",
99: #if defined(DDB)
100: "ddb", "D",
101: #endif
102: "disable", "d",
103: "enable", "e",
104: "exit", "q",
105: "find", "f",
106: "help", "h",
107: "list", "l",
108: "lines", "L",
109: "quit", "q",
110: "show", "s",
111: "timezone", "t",
112: "verbose", "v",
113: "?", "h",
114: "", "",
115: };
116:
117: void
118: userconf_init(void)
119: {
120: int i = 0;
121: struct cfdata *cd;
122: int ln;
123:
124: while (cfdata[i].cf_attach != 0) {
125: userconf_maxdev = i;
126: userconf_totdev = i;
127:
128: cd = &cfdata[i];
129: ln = cd->cf_locnames;
130: while (locnamp[ln] != -1) {
131: if (locnamp[ln] > userconf_maxlocnames)
132: userconf_maxlocnames = locnamp[ln];
133: ln++;
134: }
135: i++;
136: }
137:
138: while (cfdata[i].cf_attach == 0) {
139: userconf_totdev = i;
140: i++;
141: }
142: userconf_totdev = userconf_totdev - 1;
143: }
144:
145: int
146: userconf_more(void)
147: {
148: int quit = 0;
149: char c = '\0';
150:
151: if (userconf_cnt != -1) {
152: if (userconf_cnt == userconf_lines) {
153: printf("--- more ---");
154: c = cngetc();
155: userconf_cnt = 0;
156: printf("\r \r");
157: }
158: userconf_cnt++;
159: if (c == 'q' || c == 'Q')
160: quit = 1;
161: }
162: return (quit);
163: }
164:
165: void
166: userconf_hist_cmd(char cmd)
167: {
168: userconf_histcur = userconf_histlen;
169: if (userconf_histcur < userconf_histsz) {
170: userconf_history[userconf_histcur] = cmd;
171: userconf_histcur++;
172: }
173: }
174:
175: void
176: userconf_hist_int(int val)
177: {
178: snprintf(userconf_histbuf, sizeof userconf_histbuf, " %d",val);
179: if (userconf_histcur + strlen(userconf_histbuf) < userconf_histsz) {
180: bcopy(userconf_histbuf,
181: &userconf_history[userconf_histcur],
182: strlen(userconf_histbuf));
183: userconf_histcur = userconf_histcur + strlen(userconf_histbuf);
184: }
185: }
186:
187: void
188: userconf_hist_eoc(void)
189: {
190: if (userconf_histcur < userconf_histsz) {
191: userconf_history[userconf_histcur] = '\n';
192: userconf_histcur++;
193: userconf_histlen = userconf_histcur;
194: }
195: }
196:
197: void
198: userconf_pnum(int val)
199: {
200: if (val > -2 && val < 16) {
201: printf("%d",val);
202: return;
203: }
204:
205: switch (userconf_base) {
206: case 8:
207: printf("0%o",val);
208: break;
209: case 10:
210: printf("%d",val);
211: break;
212: case 16:
213: default:
214: printf("0x%x",val);
215: break;
216: }
217: }
218:
219: void
220: userconf_pdevnam(short dev)
221: {
222: struct cfdata *cd;
223:
224: cd = &cfdata[dev];
225: printf("%s", cd->cf_driver->cd_name);
226: switch (cd->cf_fstate) {
227: case FSTATE_NOTFOUND:
228: case FSTATE_DNOTFOUND:
229: printf("%d", cd->cf_unit);
230: break;
231: case FSTATE_FOUND:
232: printf("*FOUND*");
233: break;
234: case FSTATE_STAR:
235: case FSTATE_DSTAR:
236: printf("*");
237: break;
238: default:
239: printf("*UNKNOWN*");
240: break;
241: }
242: }
243:
244: void
245: userconf_pdev(short devno)
246: {
247: struct cfdata *cd;
248: short *p;
249: int *l;
250: int ln;
251: char c;
252:
253: if (devno > userconf_maxdev && devno <= userconf_totdev) {
254: printf("%3d free slot (for add)\n", devno);
255: return;
256: }
257:
258: if (devno > userconf_totdev &&
259: devno <= userconf_totdev+pdevnames_size) {
260: printf("%3d %s count %d (pseudo device)\n", devno,
261: pdevnames[devno-userconf_totdev-1],
262: pdevinit[devno-userconf_totdev-1].pdev_count);
263: return;
264: }
265:
266: if (devno > userconf_maxdev) {
267: printf("Unknown devno (max is %d)\n", userconf_maxdev);
268: return;
269: }
270:
271: cd = &cfdata[devno];
272:
273: printf("%3d ", devno);
274: userconf_pdevnam(devno);
275: printf(" at");
276: c = ' ';
277: p = cd->cf_parents;
278: if (*p == -1)
279: printf(" root");
280: while (*p != -1) {
281: printf("%c", c);
282: userconf_pdevnam(*p++);
283: c = '|';
284: }
285: switch (cd->cf_fstate) {
286: case FSTATE_NOTFOUND:
287: case FSTATE_FOUND:
288: case FSTATE_STAR:
289: break;
290: case FSTATE_DNOTFOUND:
291: case FSTATE_DSTAR:
292: printf(" disable");
293: break;
294: default:
295: printf(" ???");
296: break;
297: }
298: l = cd->cf_loc;
299: ln = cd->cf_locnames;
300: while (locnamp[ln] != -1) {
301: printf(" %s ", locnames[locnamp[ln]]);
302: ln++;
303: userconf_pnum(*l++);
304: }
305: printf(" flags 0x%x\n", cd->cf_flags);
306: }
307:
308: int
309: userconf_number(char *c, int *val)
310: {
311: u_int num = 0;
312: int neg = 0;
313: int base = 10;
314:
315: if (*c == '-') {
316: neg = 1;
317: c++;
318: }
319: if (*c == '0') {
320: base = 8;
321: c++;
322: if (*c == 'x' || *c == 'X') {
323: base = 16;
324: c++;
325: }
326: }
327: while (*c != '\n' && *c != '\t' && *c != ' ' && *c != '\0') {
328: u_char cc = *c;
329:
330: if (cc >= '0' && cc <= '9')
331: cc = cc - '0';
332: else if (cc >= 'a' && cc <= 'f')
333: cc = cc - 'a' + 10;
334: else if (cc >= 'A' && cc <= 'F')
335: cc = cc - 'A' + 10;
336: else
337: return (-1);
338:
339: if (cc > base)
340: return (-1);
341: num = num * base + cc;
342: c++;
343: }
344:
345: if (neg && num > INT_MAX) /* overflow */
346: return (1);
347: *val = neg ? - num : num;
348: return (0);
349: }
350:
351: int
352: userconf_device(char *cmd, int *len, short *unit, short *state)
353: {
354: short u = 0, s = FSTATE_FOUND;
355: int l = 0;
356: char *c;
357:
358: c = cmd;
359: while (*c >= 'a' && *c <= 'z') {
360: l++;
361: c++;
362: }
363: if (*c == '*') {
364: s = FSTATE_STAR;
365: c++;
366: } else {
367: while (*c >= '0' && *c <= '9') {
368: s = FSTATE_NOTFOUND;
369: u = u*10 + *c - '0';
370: c++;
371: }
372: }
373: while (*c == ' ' || *c == '\t' || *c == '\n')
374: c++;
375:
376: if (*c == '\0') {
377: *len = l;
378: *unit = u;
379: *state = s;
380: return(0);
381: }
382:
383: return(-1);
384: }
385:
386: int
387: userconf_attr(char *cmd, int *val)
388: {
389: char *c;
390: short attr = -1, i = 0, l = 0;
391:
392: c = cmd;
393: while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
394: c++;
395: l++;
396: }
397:
398: while (i <= userconf_maxlocnames) {
399: if (strlen(locnames[i]) == l) {
400: if (strncasecmp(cmd, locnames[i], l) == 0)
401: attr = i;
402: }
403: i++;
404: }
405:
406: if (attr == -1) {
407: return (-1);
408: }
409:
410: *val = attr;
411:
412: return(0);
413: }
414:
415: void
416: userconf_modify(char *item, int *val)
417: {
418: int ok = 0;
419: int a;
420: char *c;
421: int i;
422:
423: while (!ok) {
424: printf("%s [", item);
425: userconf_pnum(*val);
426: printf("] ? ");
427:
428: i = getsn(userconf_argbuf, sizeof(userconf_argbuf));
429:
430: c = userconf_argbuf;
431: while (*c == ' ' || *c == '\t' || *c == '\n') c++;
432:
433: if (*c != '\0') {
434: if (userconf_number(c, &a) == 0) {
435: *val = a;
436: ok = 1;
437: } else {
438: printf("Unknown argument\n");
439: }
440: } else {
441: ok = 1;
442: }
443: }
444: }
445:
446: void
447: userconf_change(int devno)
448: {
449: struct cfdata *cd;
450: char c = '\0';
451: int *l;
452: int ln;
453:
454: if (devno <= userconf_maxdev) {
455: userconf_pdev(devno);
456:
457: while (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
458: printf("change (y/n) ?");
459: c = cngetc();
460: printf("\n");
461: }
462:
463: if (c == 'y' || c == 'Y') {
464: int share = 0, i, *lk;
465:
466: /* XXX add cmd 'c' <devno> */
467: userconf_hist_cmd('c');
468: userconf_hist_int(devno);
469:
470: cd = &cfdata[devno];
471: l = cd->cf_loc;
472: ln = cd->cf_locnames;
473:
474: /*
475: * Search for some other driver sharing this
476: * locator table. if one does, we may need to
477: * replace the locators with a malloc'd copy.
478: */
479: for (i = 0; cfdata[i].cf_driver; i++)
480: if (i != devno && cfdata[i].cf_loc == l)
481: share = 1;
482: if (share) {
483: for (i = 0; locnamp[ln+i] != -1 ; i++)
484: ;
485: lk = l = (int *)malloc(sizeof(int) * i,
486: M_TEMP, M_NOWAIT);
487: if (lk == NULL) {
488: printf("out of memory.\n");
489: return;
490: }
491: bcopy(cd->cf_loc, l, sizeof(int) * i);
492: }
493:
494: while (locnamp[ln] != -1) {
495: userconf_modify(locnames[locnamp[ln]], l);
496:
497: /* XXX add *l */
498: userconf_hist_int(*l);
499:
500: ln++;
501: l++;
502: }
503: userconf_modify("flags", &cd->cf_flags);
504: userconf_hist_int(cd->cf_flags);
505:
506: if (share) {
507: if (bcmp(cd->cf_loc, lk, sizeof(int) * i))
508: cd->cf_loc = lk;
509: else
510: free(lk, M_TEMP);
511: }
512:
513: printf("%3d ", devno);
514: userconf_pdevnam(devno);
515: printf(" changed\n");
516: userconf_pdev(devno);
517: }
518: return;
519: }
520:
521: if (devno > userconf_maxdev && devno <= userconf_totdev) {
522: printf("%3d can't change free slot\n", devno);
523: return;
524: }
525:
526: if (devno > userconf_totdev &&
527: devno <= userconf_totdev+pdevnames_size) {
528: userconf_pdev(devno);
529: while (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
530: printf("change (y/n) ?");
531: c = cngetc();
532: printf("\n");
533: }
534:
535: if (c == 'y' || c == 'Y') {
536: /* XXX add cmd 'c' <devno> */
537: userconf_hist_cmd('c');
538: userconf_hist_int(devno);
539:
540: userconf_modify("count",
541: &pdevinit[devno-userconf_totdev-1].pdev_count);
542: userconf_hist_int(pdevinit[devno-userconf_totdev-1].pdev_count);
543:
544: printf("%3d %s changed\n", devno,
545: pdevnames[devno-userconf_totdev-1]);
546: userconf_pdev(devno);
547:
548: /* XXX add eoc */
549: userconf_hist_eoc();
550: }
551: return;
552: }
553:
554: printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
555: }
556:
557: void
558: userconf_disable(int devno)
559: {
560: int done = 0;
561:
562: if (devno <= userconf_maxdev) {
563: switch (cfdata[devno].cf_fstate) {
564: case FSTATE_NOTFOUND:
565: cfdata[devno].cf_fstate = FSTATE_DNOTFOUND;
566: break;
567: case FSTATE_STAR:
568: cfdata[devno].cf_fstate = FSTATE_DSTAR;
569: break;
570: case FSTATE_DNOTFOUND:
571: case FSTATE_DSTAR:
572: done = 1;
573: break;
574: default:
575: printf("Error unknown state\n");
576: break;
577: }
578:
579: printf("%3d ", devno);
580: userconf_pdevnam(devno);
581: if (done) {
582: printf(" already");
583: } else {
584: /* XXX add cmd 'd' <devno> eoc */
585: userconf_hist_cmd('d');
586: userconf_hist_int(devno);
587: userconf_hist_eoc();
588: }
589: printf(" disabled\n");
590:
591: return;
592: }
593:
594: if (devno > userconf_maxdev && devno <= userconf_totdev) {
595: printf("%3d can't disable free slot\n", devno);
596: return;
597: }
598:
599: if (devno > userconf_totdev &&
600: devno <= userconf_totdev+pdevnames_size) {
601: printf("%3d %s can't disable pseudo device\n", devno,
602: pdevnames[devno-userconf_totdev-1]);
603: return;
604: }
605:
606: printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
607: }
608:
609: void
610: userconf_enable(int devno)
611: {
612: int done = 0;
613:
614: if (devno <= userconf_maxdev) {
615: switch (cfdata[devno].cf_fstate) {
616: case FSTATE_DNOTFOUND:
617: cfdata[devno].cf_fstate = FSTATE_NOTFOUND;
618: break;
619: case FSTATE_DSTAR:
620: cfdata[devno].cf_fstate = FSTATE_STAR;
621: break;
622: case FSTATE_NOTFOUND:
623: case FSTATE_STAR:
624: done = 1;
625: break;
626: default:
627: printf("Error unknown state\n");
628: break;
629: }
630:
631: printf("%3d ", devno);
632: userconf_pdevnam(devno);
633: if (done) {
634: printf(" already");
635: } else {
636: /* XXX add cmd 'e' <devno> eoc */
637: userconf_hist_cmd('e');
638: userconf_hist_int(devno);
639: userconf_hist_eoc();
640: }
641: printf(" enabled\n");
642: return;
643: }
644:
645: if (devno > userconf_maxdev && devno <= userconf_totdev) {
646: printf("%3d can't enable free slot\n", devno);
647: return;
648: }
649:
650: if (devno > userconf_totdev &&
651: devno <= userconf_totdev+pdevnames_size) {
652: printf("%3d %s can't enable pseudo device\n", devno,
653: pdevnames[devno-userconf_totdev-1]);
654: return;
655: }
656:
657: printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
658: }
659:
660: void
661: userconf_help(void)
662: {
663: int j = 0, k;
664:
665: printf("command args description\n");
666: while (*userconf_cmds[j] != '\0') {
667: printf(userconf_cmds[j]);
668: k = strlen(userconf_cmds[j]);
669: while (k < 10) {
670: printf(" ");
671: k++;
672: }
673: switch (*userconf_cmds[j+1]) {
674: case 'L':
675: printf("[count] number of lines before more");
676: break;
677: case 'a':
678: printf("dev add a device");
679: break;
680: case 'b':
681: printf("8|10|16 base on large numbers");
682: break;
683: case 'c':
684: printf("devno|dev change devices");
685: break;
686: #if defined(DDB)
687: case 'D':
688: printf(" enter ddb");
689: break;
690: #endif
691: case 'd':
692: printf("attr val|devno|dev disable devices");
693: break;
694: case 'e':
695: printf("attr val|devno|dev enable devices");
696: break;
697: case 'f':
698: printf("devno|dev find devices");
699: break;
700: case 'h':
701: printf(" this message");
702: break;
703: case 'l':
704: printf(" list configuration");
705: break;
706: case 'q':
707: printf(" leave UKC");
708: break;
709: case 's':
710: printf("[attr [val]] "
711: "show attributes (or devices with an attribute)");
712: break;
713: case 't':
714: printf("[mins [dst]] set timezone/dst");
715: break;
716: case 'v':
717: printf(" toggle verbose booting");
718: break;
719: default:
720: printf(" don't know");
721: break;
722: }
723: printf("\n");
724: j += 2;
725: }
726: }
727:
728: void
729: userconf_list(void)
730: {
731: int i = 0;
732:
733: userconf_cnt = 0;
734:
735: while (i <= (userconf_totdev+pdevnames_size)) {
736: if (userconf_more())
737: break;
738: userconf_pdev(i++);
739: }
740:
741: userconf_cnt = -1;
742: }
743:
744: void
745: userconf_show(void)
746: {
747: int i = 0;
748:
749: userconf_cnt = 0;
750:
751: while (i <= userconf_maxlocnames) {
752: if (userconf_more())
753: break;
754: printf("%s\n", locnames[i++]);
755: }
756:
757: userconf_cnt = -1;
758: }
759:
760: void
761: userconf_common_attr_val(short attr, int *val, char routine)
762: {
763: struct cfdata *cd;
764: int *l;
765: int ln;
766: int i = 0, quit = 0;
767:
768: userconf_cnt = 0;
769:
770: while (i <= userconf_maxdev) {
771: cd = &cfdata[i];
772: l = cd->cf_loc;
773: ln = cd->cf_locnames;
774: while (locnamp[ln] != -1) {
775: if (locnamp[ln] == attr) {
776: if (val == NULL) {
777: quit = userconf_more();
778: userconf_pdev(i);
779: } else {
780: if (*val == *l) {
781: quit = userconf_more();
782: switch (routine) {
783: case UC_ENABLE:
784: userconf_enable(i);
785: break;
786: case UC_DISABLE:
787: userconf_disable(i);
788: break;
789: case UC_SHOW:
790: userconf_pdev(i);
791: break;
792: default:
793: printf("Unknown routine /%c/\n",
794: routine);
795: break;
796: }
797: }
798: }
799: }
800: if (quit)
801: break;
802: ln++;
803: l++;
804: }
805: if (quit)
806: break;
807: i++;
808: }
809:
810: userconf_cnt = -1;
811: }
812:
813: void
814: userconf_show_attr(char *cmd)
815: {
816: char *c;
817: short attr = -1, i = 0, l = 0;
818: int a;
819:
820: c = cmd;
821: while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
822: c++;
823: l++;
824: }
825: while (*c == ' ' || *c == '\t' || *c == '\n') {
826: c++;
827: }
828: while (i <= userconf_maxlocnames) {
829: if (strlen(locnames[i]) == l) {
830: if (strncasecmp(cmd, locnames[i], l) == 0) {
831: attr = i;
832: }
833: }
834: i++;
835: }
836:
837: if (attr == -1) {
838: printf("Unknown attribute\n");
839: return;
840: }
841:
842: if (*c == '\0') {
843: userconf_common_attr_val(attr, NULL, UC_SHOW);
844: } else {
845: if (userconf_number(c, &a) == 0) {
846: userconf_common_attr_val(attr, &a, UC_SHOW);
847: } else {
848: printf("Unknown argument\n");
849: }
850: }
851: }
852:
853: void
854: userconf_common_dev(char *dev, int len, short unit, short state, char routine)
855: {
856: int i = 0;
857:
858: switch (routine) {
859: case UC_CHANGE:
860: break;
861: default:
862: userconf_cnt = 0;
863: break;
864: }
865:
866: while (cfdata[i].cf_attach != 0) {
867: if (strlen(cfdata[i].cf_driver->cd_name) == len) {
868:
869: /*
870: * Ok, if device name is correct
871: * If state == FSTATE_FOUND, look for "dev"
872: * If state == FSTATE_STAR, look for "dev*"
873: * If state == FSTATE_NOTFOUND, look for "dev0"
874: */
875: if (strncasecmp(dev, cfdata[i].cf_driver->cd_name,
876: len) == 0 &&
877: (state == FSTATE_FOUND ||
878: (state == FSTATE_STAR &&
879: (cfdata[i].cf_fstate == FSTATE_STAR ||
880: cfdata[i].cf_fstate == FSTATE_DSTAR)) ||
881: (state == FSTATE_NOTFOUND &&
882: cfdata[i].cf_unit == unit &&
883: (cfdata[i].cf_fstate == FSTATE_NOTFOUND ||
884: cfdata[i].cf_fstate == FSTATE_DNOTFOUND)))) {
885: if (userconf_more())
886: break;
887: switch (routine) {
888: case UC_CHANGE:
889: userconf_change(i);
890: break;
891: case UC_ENABLE:
892: userconf_enable(i);
893: break;
894: case UC_DISABLE:
895: userconf_disable(i);
896: break;
897: case UC_FIND:
898: userconf_pdev(i);
899: break;
900: default:
901: printf("Unknown routine /%c/\n",
902: routine);
903: break;
904: }
905: }
906: }
907: i++;
908: }
909:
910: for (i = 0; i < pdevnames_size; i++) {
911: if (strncasecmp(dev, pdevnames[i], len) == 0 &&
912: state == FSTATE_FOUND) {
913: switch(routine) {
914: case UC_CHANGE:
915: userconf_change(userconf_totdev+1+i);
916: break;
917: case UC_ENABLE:
918: userconf_enable(userconf_totdev+1+i);
919: break;
920: case UC_DISABLE:
921: userconf_disable(userconf_totdev+1+i);
922: break;
923: case UC_FIND:
924: userconf_pdev(userconf_totdev+1+i);
925: break;
926: default:
927: printf("Unknown pseudo routine /%c/\n",routine);
928: break;
929: }
930: }
931: }
932:
933: switch (routine) {
934: case UC_CHANGE:
935: break;
936: default:
937: userconf_cnt = -1;
938: break;
939: }
940: }
941:
942: void
943: userconf_common_attr(char *cmd, int attr, char routine)
944: {
945: char *c;
946: short l = 0;
947: int a;
948:
949: c = cmd;
950: while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
951: c++;
952: l++;
953: }
954: while (*c == ' ' || *c == '\t' || *c == '\n')
955: c++;
956:
957: if (*c == '\0') {
958: printf("Value missing for attribute\n");
959: return;
960: }
961:
962: if (userconf_number(c, &a) == 0) {
963: userconf_common_attr_val(attr, &a, routine);
964: } else {
965: printf("Unknown argument\n");
966: }
967: }
968:
969: void
970: userconf_add_read(char *prompt, char field, char *dev, int len, int *val)
971: {
972: int ok = 0;
973: int a;
974: char *c;
975: int i;
976:
977: *val = -1;
978:
979: while (!ok) {
980: printf("%s ? ", prompt);
981:
982: i = getsn(userconf_argbuf, sizeof(userconf_argbuf));
983:
984: c = userconf_argbuf;
985: while (*c == ' ' || *c == '\t' || *c == '\n')
986: c++;
987:
988: if (*c != '\0') {
989: if (userconf_number(c, &a) == 0) {
990: if (a > userconf_maxdev) {
991: printf("Unknown devno (max is %d)\n",
992: userconf_maxdev);
993: } else if (strncasecmp(dev,
994: cfdata[a].cf_driver->cd_name, len) != 0 &&
995: field == 'a') {
996: printf("Not same device type\n");
997: } else {
998: *val = a;
999: ok = 1;
1000: }
1001: } else if (*c == '?') {
1002: userconf_common_dev(dev, len, 0,
1003: FSTATE_FOUND, UC_FIND);
1004: } else if (*c == 'q' || *c == 'Q') {
1005: ok = 1;
1006: } else {
1007: printf("Unknown argument\n");
1008: }
1009: } else {
1010: ok = 1;
1011: }
1012: }
1013: }
1014:
1015: void
1016: userconf_add(char *dev, int len, short unit, short state)
1017: {
1018: int i = 0, found = 0;
1019: struct cfdata new;
1020: int val, max_unit, star_unit, orig;
1021:
1022: bzero(&new, sizeof(struct cfdata));
1023:
1024: if (userconf_maxdev == userconf_totdev) {
1025: printf("No more space for new devices.\n");
1026: return;
1027: }
1028:
1029: if (state == FSTATE_FOUND) {
1030: printf("Device not complete number or * is missing\n");
1031: return;
1032: }
1033:
1034: for (i = 0; cfdata[i].cf_driver; i++)
1035: if (strlen(cfdata[i].cf_driver->cd_name) == len &&
1036: strncasecmp(dev, cfdata[i].cf_driver->cd_name, len) == 0)
1037: found = 1;
1038:
1039: if (!found) {
1040: printf("No device of this type exists.\n");
1041: return;
1042: }
1043:
1044: userconf_add_read("Clone Device (DevNo, 'q' or '?')",
1045: 'a', dev, len, &val);
1046:
1047: if (val != -1) {
1048: orig = val;
1049: new = cfdata[val];
1050: new.cf_unit = unit;
1051: new.cf_fstate = state;
1052: userconf_add_read("Insert before Device (DevNo, 'q' or '?')",
1053: 'i', dev, len, &val);
1054: }
1055:
1056: if (val != -1) {
1057: /* XXX add cmd 'a' <orig> <val> eoc */
1058: userconf_hist_cmd('a');
1059: userconf_hist_int(orig);
1060: userconf_hist_int(unit);
1061: userconf_hist_int(state);
1062: userconf_hist_int(val);
1063: userconf_hist_eoc();
1064:
1065: /* Insert the new record */
1066: for (i = userconf_maxdev; val <= i; i--)
1067: cfdata[i+1] = cfdata[i];
1068: cfdata[val] = new;
1069:
1070: /* Fix indexs in pv */
1071: for (i = 0; i < pv_size; i++) {
1072: if (pv[i] != -1 && pv[i] >= val)
1073: pv[i]++;
1074: }
1075:
1076: /* Fix indexs in cfroots */
1077: for (i = 0; i < cfroots_size; i++) {
1078: if (cfroots[i] != -1 && cfroots[i] >= val)
1079: cfroots[i]++;
1080: }
1081:
1082: userconf_maxdev++;
1083:
1084: max_unit = -1;
1085:
1086: /* Find max unit number of the device type */
1087:
1088: i = 0;
1089: while (cfdata[i].cf_attach != 0) {
1090: if (strlen(cfdata[i].cf_driver->cd_name) == len &&
1091: strncasecmp(dev, cfdata[i].cf_driver->cd_name,
1092: len) == 0) {
1093: switch (cfdata[i].cf_fstate) {
1094: case FSTATE_NOTFOUND:
1095: case FSTATE_DNOTFOUND:
1096: if (cfdata[i].cf_unit > max_unit)
1097: max_unit = cfdata[i].cf_unit;
1098: break;
1099: default:
1100: break;
1101: }
1102: }
1103: i++;
1104: }
1105:
1106: /*
1107: * For all * entries set unit number to max+1, and update
1108: * cf_starunit1 if necessary.
1109: */
1110: max_unit++;
1111: star_unit = -1;
1112:
1113: i = 0;
1114: while (cfdata[i].cf_attach != 0) {
1115: if (strlen(cfdata[i].cf_driver->cd_name) == len &&
1116: strncasecmp(dev, cfdata[i].cf_driver->cd_name,
1117: len) == 0) {
1118: switch (cfdata[i].cf_fstate) {
1119: case FSTATE_NOTFOUND:
1120: case FSTATE_DNOTFOUND:
1121: if (cfdata[i].cf_unit > star_unit)
1122: star_unit = cfdata[i].cf_unit;
1123: break;
1124: default:
1125: break;
1126: }
1127: }
1128: i++;
1129: }
1130: star_unit++;
1131:
1132: i = 0;
1133: while (cfdata[i].cf_attach != 0) {
1134: if (strlen(cfdata[i].cf_driver->cd_name) == len &&
1135: strncasecmp(dev, cfdata[i].cf_driver->cd_name,
1136: len) == 0) {
1137: switch (cfdata[i].cf_fstate) {
1138: case FSTATE_STAR:
1139: case FSTATE_DSTAR:
1140: cfdata[i].cf_unit = max_unit;
1141: if (cfdata[i].cf_starunit1 < star_unit)
1142: cfdata[i].cf_starunit1 =
1143: star_unit;
1144: break;
1145: default:
1146: break;
1147: }
1148: }
1149: i++;
1150: }
1151: userconf_pdev(val);
1152: }
1153:
1154: /* cf_attach, cf_driver, cf_unit, cf_fstate, cf_loc, cf_flags,
1155: cf_parents, cf_locnames, cf_locnames and cf_ivstubs */
1156: }
1157:
1158: int
1159: userconf_parse(char *cmd)
1160: {
1161: char *c, *v;
1162: int i = 0, j = 0, k, a;
1163: short unit, state;
1164:
1165: c = cmd;
1166: while (*c == ' ' || *c == '\t')
1167: c++;
1168: v = c;
1169: while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
1170: c++;
1171: i++;
1172: }
1173:
1174: k = -1;
1175: while (*userconf_cmds[j] != '\0') {
1176: if (strlen(userconf_cmds[j]) == i) {
1177: if (strncasecmp(v, userconf_cmds[j], i) == 0)
1178: k = j;
1179: }
1180: j += 2;
1181: }
1182:
1183: while (*c == ' ' || *c == '\t' || *c == '\n')
1184: c++;
1185:
1186: if (k == -1) {
1187: if (*v != '\n')
1188: printf("Unknown command, try help\n");
1189: } else {
1190: switch (*userconf_cmds[k+1]) {
1191: case 'L':
1192: if (*c == '\0')
1193: printf("Argument expected\n");
1194: else if (userconf_number(c, &a) == 0)
1195: userconf_lines = a;
1196: else
1197: printf("Unknown argument\n");
1198: break;
1199: case 'a':
1200: if (*c == '\0')
1201: printf("Dev expected\n");
1202: else if (userconf_device(c, &a, &unit, &state) == 0)
1203: userconf_add(c, a, unit, state);
1204: else
1205: printf("Unknown argument\n");
1206: break;
1207: case 'b':
1208: if (*c == '\0')
1209: printf("8|10|16 expected\n");
1210: else if (userconf_number(c, &a) == 0) {
1211: if (a == 8 || a == 10 || a == 16) {
1212: userconf_base = a;
1213: } else {
1214: printf("8|10|16 expected\n");
1215: }
1216: } else
1217: printf("Unknown argument\n");
1218: break;
1219: case 'c':
1220: if (*c == '\0')
1221: printf("DevNo or Dev expected\n");
1222: else if (userconf_number(c, &a) == 0)
1223: userconf_change(a);
1224: else if (userconf_device(c, &a, &unit, &state) == 0)
1225: userconf_common_dev(c, a, unit, state, UC_CHANGE);
1226: else
1227: printf("Unknown argument\n");
1228: break;
1229: #if defined(DDB)
1230: case 'D':
1231: Debugger();
1232: break;
1233: #endif
1234: case 'd':
1235: if (*c == '\0')
1236: printf("Attr, DevNo or Dev expected\n");
1237: else if (userconf_attr(c, &a) == 0)
1238: userconf_common_attr(c, a, UC_DISABLE);
1239: else if (userconf_number(c, &a) == 0)
1240: userconf_disable(a);
1241: else if (userconf_device(c, &a, &unit, &state) == 0)
1242: userconf_common_dev(c, a, unit, state, UC_DISABLE);
1243: else
1244: printf("Unknown argument\n");
1245: break;
1246: case 'e':
1247: if (*c == '\0')
1248: printf("Attr, DevNo or Dev expected\n");
1249: else if (userconf_attr(c, &a) == 0)
1250: userconf_common_attr(c, a, UC_ENABLE);
1251: else if (userconf_number(c, &a) == 0)
1252: userconf_enable(a);
1253: else if (userconf_device(c, &a, &unit, &state) == 0)
1254: userconf_common_dev(c, a, unit, state, UC_ENABLE);
1255: else
1256: printf("Unknown argument\n");
1257: break;
1258: case 'f':
1259: if (*c == '\0')
1260: printf("DevNo or Dev expected\n");
1261: else if (userconf_number(c, &a) == 0)
1262: userconf_pdev(a);
1263: else if (userconf_device(c, &a, &unit, &state) == 0)
1264: userconf_common_dev(c, a, unit, state, UC_FIND);
1265: else
1266: printf("Unknown argument\n");
1267: break;
1268: case 'h':
1269: userconf_help();
1270: break;
1271: case 'l':
1272: if (*c == '\0')
1273: userconf_list();
1274: else
1275: printf("Unknown argument\n");
1276: break;
1277: case 'q':
1278: /* XXX add cmd 'q' eoc */
1279: userconf_hist_cmd('q');
1280: userconf_hist_eoc();
1281: return(-1);
1282: break;
1283: case 's':
1284: if (*c == '\0')
1285: userconf_show();
1286: else
1287: userconf_show_attr(c);
1288: break;
1289: case 't':
1290: if (*c == '\0' || userconf_number(c, &a) == 0) {
1291: if (*c != '\0') {
1292: tz.tz_minuteswest = a;
1293: while (*c != '\n' && *c != '\t' &&
1294: *c != ' ' && *c != '\0')
1295: c++;
1296: while (*c == '\t' || *c == ' ')
1297: c++;
1298: if (*c != '\0' &&
1299: userconf_number(c, &a) == 0)
1300: tz.tz_dsttime = a;
1301: userconf_hist_cmd('t');
1302: userconf_hist_int(tz.tz_minuteswest);
1303: userconf_hist_int(tz.tz_dsttime);
1304: userconf_hist_eoc();
1305: }
1306: printf("timezone = %d, dst = %d\n",
1307: tz.tz_minuteswest, tz.tz_dsttime);
1308: } else
1309: printf("Unknown argument\n");
1310: break;
1311: case 'v':
1312: autoconf_verbose = !autoconf_verbose;
1313: printf("autoconf verbose %sabled\n",
1314: autoconf_verbose ? "en" : "dis");
1315: break;
1316: default:
1317: printf("Unknown command\n");
1318: break;
1319: }
1320: }
1321: return(0);
1322: }
1323:
1324: void
1325: user_config(void)
1326: {
1327: userconf_init();
1328: printf("User Kernel Config\n");
1329:
1330: while (1) {
1331: printf("UKC> ");
1332: if (getsn(userconf_cmdbuf, sizeof(userconf_cmdbuf)) > 0 &&
1333: userconf_parse(userconf_cmdbuf))
1334: break;
1335: }
1336: printf("Continuing...\n");
1337: }