![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to config.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc / config|
Return to config.y CVS log | Up to [CSRG BSD Unix] / 43BSD / etc / config |
1.1 root 1: %union {
2: char *str;
3: int val;
4: struct file_list *file;
5: struct idlst *lst;
6: }
7:
8: %token AND
9: %token ANY
10: %token ARGS
11: %token AT
12: %token COMMA
13: %token CONFIG
14: %token CONTROLLER
15: %token CPU
16: %token CSR
17: %token DEVICE
18: %token DISK
19: %token DRIVE
20: %token DST
21: %token DUMPS
22: %token EQUALS
23: %token FLAGS
24: %token HZ
25: %token IDENT
26: %token MACHINE
27: %token MAJOR
28: %token MASTER
29: %token MAXUSERS
30: %token MBA
31: %token MINOR
32: %token MINUS
33: %token NEXUS
34: %token ON
35: %token OPTIONS
36: %token MAKEOPTIONS
37: %token PRIORITY
38: %token PSEUDO_DEVICE
39: %token ROOT
40: %token SEMICOLON
41: %token SIZE
42: %token SLAVE
43: %token SWAP
44: %token TIMEZONE
45: %token TRACE
46: %token UBA
47: %token VECTOR
48:
49: %token <str> ID
50: %token <val> NUMBER
51: %token <val> FPNUMBER
52:
53: %type <str> Save_id
54: %type <str> Opt_value
55: %type <str> Dev
56: %type <lst> Id_list
57: %type <val> optional_size
58: %type <str> device_name
59: %type <val> major_minor
60: %type <val> arg_device_spec
61: %type <val> root_device_spec
62: %type <val> dump_device_spec
63: %type <file> swap_device_spec
64:
65: %{
66:
67: /*
68: * Copyright (c) 1980 Regents of the University of California.
69: * All rights reserved. The Berkeley software License Agreement
70: * specifies the terms and conditions for redistribution.
71: *
72: * @(#)config.y 5.2 (Berkeley) 4/18/86
73: */
74:
75: #include "config.h"
76: #include <ctype.h>
77: #include <stdio.h>
78:
79: struct device cur;
80: struct device *curp = 0;
81: char *temp_id;
82: char *val_id;
83: char *malloc();
84:
85: %}
86: %%
87: Configuration:
88: Many_specs
89: = { verifysystemspecs(); }
90: ;
91:
92: Many_specs:
93: Many_specs Spec
94: |
95: /* lambda */
96: ;
97:
98: Spec:
99: Device_spec SEMICOLON
100: = { newdev(&cur); } |
101: Config_spec SEMICOLON
102: |
103: TRACE SEMICOLON
104: = { do_trace = !do_trace; } |
105: SEMICOLON
106: |
107: error SEMICOLON
108: ;
109:
110: Config_spec:
111: MACHINE Save_id
112: = {
113: if (!strcmp($2, "vax")) {
114: machine = MACHINE_VAX;
115: machinename = "vax";
116: } else if (!strcmp($2, "sun")) {
117: machine = MACHINE_SUN;
118: machinename = "sun";
119: } else
120: yyerror("Unknown machine type");
121: } |
122: CPU Save_id
123: = {
124: struct cputype *cp =
125: (struct cputype *)malloc(sizeof (struct cputype));
126: cp->cpu_name = ns($2);
127: cp->cpu_next = cputype;
128: cputype = cp;
129: free(temp_id);
130: } |
131: OPTIONS Opt_list
132: |
133: MAKEOPTIONS Mkopt_list
134: |
135: IDENT ID
136: = { ident = ns($2); } |
137: System_spec
138: |
139: HZ NUMBER
140: = { yyerror("HZ specification obsolete; delete"); } |
141: TIMEZONE NUMBER
142: = { timezone = 60 * $2; check_tz(); } |
143: TIMEZONE NUMBER DST NUMBER
144: = { timezone = 60 * $2; dst = $4; check_tz(); } |
145: TIMEZONE NUMBER DST
146: = { timezone = 60 * $2; dst = 1; check_tz(); } |
147: TIMEZONE FPNUMBER
148: = { timezone = $2; check_tz(); } |
149: TIMEZONE FPNUMBER DST NUMBER
150: = { timezone = $2; dst = $4; check_tz(); } |
151: TIMEZONE FPNUMBER DST
152: = { timezone = $2; dst = 1; check_tz(); } |
153: TIMEZONE MINUS NUMBER
154: = { timezone = -60 * $3; check_tz(); } |
155: TIMEZONE MINUS NUMBER DST NUMBER
156: = { timezone = -60 * $3; dst = $5; check_tz(); } |
157: TIMEZONE MINUS NUMBER DST
158: = { timezone = -60 * $3; dst = 1; check_tz(); } |
159: TIMEZONE MINUS FPNUMBER
160: = { timezone = -$3; check_tz(); } |
161: TIMEZONE MINUS FPNUMBER DST NUMBER
162: = { timezone = -$3; dst = $5; check_tz(); } |
163: TIMEZONE MINUS FPNUMBER DST
164: = { timezone = -$3; dst = 1; check_tz(); } |
165: MAXUSERS NUMBER
166: = { maxusers = $2; };
167:
168: System_spec:
169: System_id System_parameter_list
170: = { checksystemspec(*confp); }
171: ;
172:
173: System_id:
174: CONFIG Save_id
175: = { mkconf($2); }
176: ;
177:
178: System_parameter_list:
179: System_parameter_list System_parameter
180: | System_parameter
181: ;
182:
183: System_parameter:
184: swap_spec
185: | root_spec
186: | dump_spec
187: | arg_spec
188: ;
189:
190: swap_spec:
191: SWAP optional_on swap_device_list
192: ;
193:
194: swap_device_list:
195: swap_device_list AND swap_device
196: | swap_device
197: ;
198:
199: swap_device:
200: swap_device_spec optional_size
201: = { mkswap(*confp, $1, $2); }
202: ;
203:
204: swap_device_spec:
205: device_name
206: = {
207: struct file_list *fl = newswap();
208:
209: if (eq($1, "generic"))
210: fl->f_fn = $1;
211: else {
212: fl->f_swapdev = nametodev($1, 0, 'b');
213: fl->f_fn = devtoname(fl->f_swapdev);
214: }
215: $$ = fl;
216: }
217: | major_minor
218: = {
219: struct file_list *fl = newswap();
220:
221: fl->f_swapdev = $1;
222: fl->f_fn = devtoname($1);
223: $$ = fl;
224: }
225: ;
226:
227: root_spec:
228: ROOT optional_on root_device_spec
229: = {
230: struct file_list *fl = *confp;
231:
232: if (fl && fl->f_rootdev != NODEV)
233: yyerror("extraneous root device specification");
234: else
235: fl->f_rootdev = $3;
236: }
237: ;
238:
239: root_device_spec:
240: device_name
241: = { $$ = nametodev($1, 0, 'a'); }
242: | major_minor
243: ;
244:
245: dump_spec:
246: DUMPS optional_on dump_device_spec
247: = {
248: struct file_list *fl = *confp;
249:
250: if (fl && fl->f_dumpdev != NODEV)
251: yyerror("extraneous dump device specification");
252: else
253: fl->f_dumpdev = $3;
254: }
255:
256: ;
257:
258: dump_device_spec:
259: device_name
260: = { $$ = nametodev($1, 0, 'b'); }
261: | major_minor
262: ;
263:
264: arg_spec:
265: ARGS optional_on arg_device_spec
266: = {
267: struct file_list *fl = *confp;
268:
269: if (fl && fl->f_argdev != NODEV)
270: yyerror("extraneous arg device specification");
271: else
272: fl->f_argdev = $3;
273: }
274: ;
275:
276: arg_device_spec:
277: device_name
278: = { $$ = nametodev($1, 0, 'b'); }
279: | major_minor
280: ;
281:
282: major_minor:
283: MAJOR NUMBER MINOR NUMBER
284: = { $$ = makedev($2, $4); }
285: ;
286:
287: optional_on:
288: ON
289: | /* empty */
290: ;
291:
292: optional_size:
293: SIZE NUMBER
294: = { $$ = $2; }
295: | /* empty */
296: = { $$ = 0; }
297: ;
298:
299: device_name:
300: Save_id
301: = { $$ = $1; }
302: | Save_id NUMBER
303: = {
304: char buf[80];
305:
306: (void) sprintf(buf, "%s%d", $1, $2);
307: $$ = ns(buf); free($1);
308: }
309: | Save_id NUMBER ID
310: = {
311: char buf[80];
312:
313: (void) sprintf(buf, "%s%d%s", $1, $2, $3);
314: $$ = ns(buf); free($1);
315: }
316: ;
317:
318: Opt_list:
319: Opt_list COMMA Option
320: |
321: Option
322: ;
323:
324: Option:
325: Save_id
326: = {
327: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
328: op->op_name = ns($1);
329: op->op_next = opt;
330: op->op_value = 0;
331: opt = op;
332: free(temp_id);
333: } |
334: Save_id EQUALS Opt_value
335: = {
336: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
337: op->op_name = ns($1);
338: op->op_next = opt;
339: op->op_value = ns($3);
340: opt = op;
341: free(temp_id);
342: free(val_id);
343: } ;
344:
345: Opt_value:
346: ID
347: = { $$ = val_id = ns($1); } |
348: NUMBER
349: = { char nb[16]; $$ = val_id = ns(sprintf(nb, "%d", $1)); };
350:
351:
352: Save_id:
353: ID
354: = { $$ = temp_id = ns($1); }
355: ;
356:
357: Mkopt_list:
358: Mkopt_list COMMA Mkoption
359: |
360: Mkoption
361: ;
362:
363: Mkoption:
364: Save_id EQUALS Opt_value
365: = {
366: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
367: op->op_name = ns($1);
368: op->op_next = mkopt;
369: op->op_value = ns($3);
370: mkopt = op;
371: free(temp_id);
372: free(val_id);
373: } ;
374:
375: Dev:
376: UBA
377: = { $$ = ns("uba"); } |
378: MBA
379: = { $$ = ns("mba"); } |
380: ID
381: = { $$ = ns($1); }
382: ;
383:
384: Device_spec:
385: DEVICE Dev_name Dev_info Int_spec
386: = { cur.d_type = DEVICE; } |
387: MASTER Dev_name Dev_info Int_spec
388: = { cur.d_type = MASTER; } |
389: DISK Dev_name Dev_info Int_spec
390: = { cur.d_dk = 1; cur.d_type = DEVICE; } |
391: CONTROLLER Dev_name Dev_info Int_spec
392: = { cur.d_type = CONTROLLER; } |
393: PSEUDO_DEVICE Init_dev Dev
394: = {
395: cur.d_name = $3;
396: cur.d_type = PSEUDO_DEVICE;
397: } |
398: PSEUDO_DEVICE Init_dev Dev NUMBER
399: = {
400: cur.d_name = $3;
401: cur.d_type = PSEUDO_DEVICE;
402: cur.d_slave = $4;
403: };
404:
405: Dev_name:
406: Init_dev Dev NUMBER
407: = {
408: cur.d_name = $2;
409: if (eq($2, "mba"))
410: seen_mba = 1;
411: else if (eq($2, "uba"))
412: seen_uba = 1;
413: cur.d_unit = $3;
414: };
415:
416: Init_dev:
417: /* lambda */
418: = { init_dev(&cur); };
419:
420: Dev_info:
421: Con_info Info_list
422: |
423: /* lambda */
424: ;
425:
426: Con_info:
427: AT Dev NUMBER
428: = {
429: if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba"))
430: yyerror(sprintf(errbuf,
431: "%s must be connected to a nexus", cur.d_name));
432: cur.d_conn = connect($2, $3);
433: } |
434: AT NEXUS NUMBER
435: = { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS; };
436:
437: Info_list:
438: Info_list Info
439: |
440: /* lambda */
441: ;
442:
443: Info:
444: CSR NUMBER
445: = { cur.d_addr = $2; } |
446: DRIVE NUMBER
447: = { cur.d_drive = $2; } |
448: SLAVE NUMBER
449: = {
450: if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS &&
451: cur.d_conn->d_type == MASTER)
452: cur.d_slave = $2;
453: else
454: yyerror("can't specify slave--not to master");
455: } |
456: FLAGS NUMBER
457: = { cur.d_flags = $2; };
458:
459: Int_spec:
460: VECTOR Id_list
461: = { cur.d_vec = $2; } |
462: PRIORITY NUMBER
463: = { cur.d_pri = $2; } |
464: /* lambda */
465: ;
466:
467: Id_list:
468: Save_id
469: = {
470: struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
471: a->id = $1; a->id_next = 0; $$ = a;
472: } |
473: Save_id Id_list =
474: {
475: struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
476: a->id = $1; a->id_next = $2; $$ = a;
477: };
478:
479: %%
480:
481: yyerror(s)
482: char *s;
483: {
484:
485: fprintf(stderr, "config: line %d: %s\n", yyline, s);
486: }
487:
488: /*
489: * return the passed string in a new space
490: */
491: char *
492: ns(str)
493: register char *str;
494: {
495: register char *cp;
496:
497: cp = malloc((unsigned)(strlen(str)+1));
498: (void) strcpy(cp, str);
499: return (cp);
500: }
501:
502: /*
503: * add a device to the list of devices
504: */
505: newdev(dp)
506: register struct device *dp;
507: {
508: register struct device *np;
509:
510: np = (struct device *) malloc(sizeof *np);
511: *np = *dp;
512: if (curp == 0)
513: dtab = np;
514: else
515: curp->d_next = np;
516: curp = np;
517: }
518:
519: /*
520: * note that a configuration should be made
521: */
522: mkconf(sysname)
523: char *sysname;
524: {
525: register struct file_list *fl, **flp;
526:
527: fl = (struct file_list *) malloc(sizeof *fl);
528: fl->f_type = SYSTEMSPEC;
529: fl->f_needs = sysname;
530: fl->f_rootdev = NODEV;
531: fl->f_argdev = NODEV;
532: fl->f_dumpdev = NODEV;
533: fl->f_fn = 0;
534: fl->f_next = 0;
535: for (flp = confp; *flp; flp = &(*flp)->f_next)
536: ;
537: *flp = fl;
538: confp = flp;
539: }
540:
541: struct file_list *
542: newswap()
543: {
544: struct file_list *fl = (struct file_list *)malloc(sizeof (*fl));
545:
546: fl->f_type = SWAPSPEC;
547: fl->f_next = 0;
548: fl->f_swapdev = NODEV;
549: fl->f_swapsize = 0;
550: fl->f_needs = 0;
551: fl->f_fn = 0;
552: return (fl);
553: }
554:
555: /*
556: * Add a swap device to the system's configuration
557: */
558: mkswap(system, fl, size)
559: struct file_list *system, *fl;
560: int size;
561: {
562: register struct file_list **flp;
563: char *cp, name[80];
564:
565: if (system == 0 || system->f_type != SYSTEMSPEC) {
566: yyerror("\"swap\" spec precedes \"config\" specification");
567: return;
568: }
569: if (size < 0) {
570: yyerror("illegal swap partition size");
571: return;
572: }
573: /*
574: * Append swap description to the end of the list.
575: */
576: flp = &system->f_next;
577: for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next)
578: ;
579: fl->f_next = *flp;
580: *flp = fl;
581: fl->f_swapsize = size;
582: /*
583: * If first swap device for this system,
584: * set up f_fn field to insure swap
585: * files are created with unique names.
586: */
587: if (system->f_fn)
588: return;
589: if (eq(fl->f_fn, "generic"))
590: system->f_fn = ns(fl->f_fn);
591: else
592: system->f_fn = ns(system->f_needs);
593: }
594:
595: /*
596: * find the pointer to connect to the given device and number.
597: * returns 0 if no such device and prints an error message
598: */
599: struct device *
600: connect(dev, num)
601: register char *dev;
602: register int num;
603: {
604: register struct device *dp;
605: struct device *huhcon();
606:
607: if (num == QUES)
608: return (huhcon(dev));
609: for (dp = dtab; dp != 0; dp = dp->d_next) {
610: if ((num != dp->d_unit) || !eq(dev, dp->d_name))
611: continue;
612: if (dp->d_type != CONTROLLER && dp->d_type != MASTER) {
613: yyerror(sprintf(errbuf,
614: "%s connected to non-controller", dev));
615: return (0);
616: }
617: return (dp);
618: }
619: yyerror(sprintf(errbuf, "%s %d not defined", dev, num));
620: return (0);
621: }
622:
623: /*
624: * connect to an unspecific thing
625: */
626: struct device *
627: huhcon(dev)
628: register char *dev;
629: {
630: register struct device *dp, *dcp;
631: struct device rdev;
632: int oldtype;
633:
634: /*
635: * First make certain that there are some of these to wildcard on
636: */
637: for (dp = dtab; dp != 0; dp = dp->d_next)
638: if (eq(dp->d_name, dev))
639: break;
640: if (dp == 0) {
641: yyerror(sprintf(errbuf, "no %s's to wildcard", dev));
642: return (0);
643: }
644: oldtype = dp->d_type;
645: dcp = dp->d_conn;
646: /*
647: * Now see if there is already a wildcard entry for this device
648: * (e.g. Search for a "uba ?")
649: */
650: for (; dp != 0; dp = dp->d_next)
651: if (eq(dev, dp->d_name) && dp->d_unit == -1)
652: break;
653: /*
654: * If there isn't, make one because everything needs to be connected
655: * to something.
656: */
657: if (dp == 0) {
658: dp = &rdev;
659: init_dev(dp);
660: dp->d_unit = QUES;
661: dp->d_name = ns(dev);
662: dp->d_type = oldtype;
663: newdev(dp);
664: dp = curp;
665: /*
666: * Connect it to the same thing that other similar things are
667: * connected to, but make sure it is a wildcard unit
668: * (e.g. up connected to sc ?, here we make connect sc? to a
669: * uba?). If other things like this are on the NEXUS or
670: * if they aren't connected to anything, then make the same
671: * connection, else call ourself to connect to another
672: * unspecific device.
673: */
674: if (dcp == TO_NEXUS || dcp == 0)
675: dp->d_conn = dcp;
676: else
677: dp->d_conn = connect(dcp->d_name, QUES);
678: }
679: return (dp);
680: }
681:
682: init_dev(dp)
683: register struct device *dp;
684: {
685:
686: dp->d_name = "OHNO!!!";
687: dp->d_type = DEVICE;
688: dp->d_conn = 0;
689: dp->d_vec = 0;
690: dp->d_addr = dp->d_pri = dp->d_flags = dp->d_dk = 0;
691: dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN;
692: }
693:
694: /*
695: * make certain that this is a reasonable type of thing to connect to a nexus
696: */
697: check_nexus(dev, num)
698: register struct device *dev;
699: int num;
700: {
701:
702: switch (machine) {
703:
704: case MACHINE_VAX:
705: if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba"))
706: yyerror("only uba's and mba's should be connected to the nexus");
707: if (num != QUES)
708: yyerror("can't give specific nexus numbers");
709: break;
710:
711: case MACHINE_SUN:
712: if (!eq(dev->d_name, "mb"))
713: yyerror("only mb's should be connected to the nexus");
714: break;
715: }
716: }
717:
718: /*
719: * Check the timezone to make certain it is sensible
720: */
721:
722: check_tz()
723: {
724: if (abs(timezone) > 12 * 60)
725: yyerror("timezone is unreasonable");
726: else
727: hadtz = 1;
728: }
729:
730: /*
731: * Check system specification and apply defaulting
732: * rules on root, argument, dump, and swap devices.
733: */
734: checksystemspec(fl)
735: register struct file_list *fl;
736: {
737: char buf[BUFSIZ];
738: register struct file_list *swap;
739: int generic;
740:
741: if (fl == 0 || fl->f_type != SYSTEMSPEC) {
742: yyerror("internal error, bad system specification");
743: exit(1);
744: }
745: swap = fl->f_next;
746: generic = swap && swap->f_type == SWAPSPEC && eq(swap->f_fn, "generic");
747: if (fl->f_rootdev == NODEV && !generic) {
748: yyerror("no root device specified");
749: exit(1);
750: }
751: /*
752: * Default swap area to be in 'b' partition of root's
753: * device. If root specified to be other than on 'a'
754: * partition, give warning, something probably amiss.
755: */
756: if (swap == 0 || swap->f_type != SWAPSPEC) {
757: dev_t dev;
758:
759: swap = newswap();
760: dev = fl->f_rootdev;
761: if (minor(dev) & 07) {
762: sprintf(buf,
763: "Warning, swap defaulted to 'b' partition with root on '%c' partition",
764: (minor(dev) & 07) + 'a');
765: yyerror(buf);
766: }
767: swap->f_swapdev =
768: makedev(major(dev), (minor(dev) &~ 07) | ('b' - 'a'));
769: swap->f_fn = devtoname(swap->f_swapdev);
770: mkswap(fl, swap, 0);
771: }
772: /*
773: * Make sure a generic swap isn't specified, along with
774: * other stuff (user must really be confused).
775: */
776: if (generic) {
777: if (fl->f_rootdev != NODEV)
778: yyerror("root device specified with generic swap");
779: if (fl->f_argdev != NODEV)
780: yyerror("arg device specified with generic swap");
781: if (fl->f_dumpdev != NODEV)
782: yyerror("dump device specified with generic swap");
783: return;
784: }
785: /*
786: * Default argument device and check for oddball arrangements.
787: */
788: if (fl->f_argdev == NODEV)
789: fl->f_argdev = swap->f_swapdev;
790: if (fl->f_argdev != swap->f_swapdev)
791: yyerror("Warning, arg device different than primary swap");
792: /*
793: * Default dump device and warn if place is not a
794: * swap area or the argument device partition.
795: */
796: if (fl->f_dumpdev == NODEV)
797: fl->f_dumpdev = swap->f_swapdev;
798: if (fl->f_dumpdev != swap->f_swapdev && fl->f_dumpdev != fl->f_argdev) {
799: struct file_list *p = swap->f_next;
800:
801: for (; p && p->f_type == SWAPSPEC; p = p->f_next)
802: if (fl->f_dumpdev == p->f_swapdev)
803: return;
804: sprintf(buf, "Warning, orphaned dump device, %s",
805: "do you know what you're doing");
806: yyerror(buf);
807: }
808: }
809:
810: /*
811: * Verify all devices specified in the system specification
812: * are present in the device specifications.
813: */
814: verifysystemspecs()
815: {
816: register struct file_list *fl;
817: dev_t checked[50], *verifyswap();
818: register dev_t *pchecked = checked;
819:
820: for (fl = conf_list; fl; fl = fl->f_next) {
821: if (fl->f_type != SYSTEMSPEC)
822: continue;
823: if (!finddev(fl->f_rootdev))
824: deverror(fl->f_needs, "root");
825: *pchecked++ = fl->f_rootdev;
826: pchecked = verifyswap(fl->f_next, checked, pchecked);
827: #define samedev(dev1, dev2) \
828: ((minor(dev1) &~ 07) != (minor(dev2) &~ 07))
829: if (!alreadychecked(fl->f_dumpdev, checked, pchecked)) {
830: if (!finddev(fl->f_dumpdev))
831: deverror(fl->f_needs, "dump");
832: *pchecked++ = fl->f_dumpdev;
833: }
834: if (!alreadychecked(fl->f_argdev, checked, pchecked)) {
835: if (!finddev(fl->f_argdev))
836: deverror(fl->f_needs, "arg");
837: *pchecked++ = fl->f_argdev;
838: }
839: }
840: }
841:
842: /*
843: * Do as above, but for swap devices.
844: */
845: dev_t *
846: verifyswap(fl, checked, pchecked)
847: register struct file_list *fl;
848: dev_t checked[];
849: register dev_t *pchecked;
850: {
851:
852: for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) {
853: if (eq(fl->f_fn, "generic"))
854: continue;
855: if (alreadychecked(fl->f_swapdev, checked, pchecked))
856: continue;
857: if (!finddev(fl->f_swapdev))
858: fprintf(stderr,
859: "config: swap device %s not configured", fl->f_fn);
860: *pchecked++ = fl->f_swapdev;
861: }
862: return (pchecked);
863: }
864:
865: /*
866: * Has a device already been checked
867: * for it's existence in the configuration?
868: */
869: alreadychecked(dev, list, last)
870: dev_t dev, list[];
871: register dev_t *last;
872: {
873: register dev_t *p;
874:
875: for (p = list; p < last; p++)
876: if (samedev(*p, dev))
877: return (1);
878: return (0);
879: }
880:
881: deverror(systemname, devtype)
882: char *systemname, *devtype;
883: {
884:
885: fprintf(stderr, "config: %s: %s device not configured\n",
886: systemname, devtype);
887: }
888:
889: /*
890: * Look for the device in the list of
891: * configured hardware devices. Must
892: * take into account stuff wildcarded.
893: */
894: finddev(dev)
895: dev_t dev;
896: {
897:
898: /* punt on this right now */
899: return (1);
900: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.