![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src|
Return to sdev.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src |
1.1 root 1: /*
2: *-IMPORTS:
3: * <sys/compat.h>
4: * LOCAL
5: * USE_PROTO
6: * ARGS ()
7: * <stdlib.h>
8: * NULL
9: * free ()
10: * malloc ()
11: * "ehand.h"
12: * ehand_t
13: * CHAIN_ERROR ();
14: * POP_HANDLER ();
15: * PUSH_HANDLER ();
16: * throw_error ();
17: * "mdev.h"
18: * mdev_t
19: * check_errs ()
20: * find_mdev ()
21: * "symbol.h"
22: * LEX_WILD
23: * SIGNED
24: * SYM_EOF
25: * UNSIGNED
26: * read_dev_file ()
27: * read_number ()
28: * read_symbol ()
29: */
30:
31: #include <sys/compat.h>
32: #include <stdlib.h>
33:
34: #include "ehand.h"
35: #include "mdev.h"
36: #include "symbol.h"
37: #include "read.h"
38: #include "lex.h"
39: #include "input.h"
40:
41: #include "sdev.h"
42:
43: #include <string.h>
44:
45:
46: LOCAL sdev_t * _sdevices;
47:
48:
49: /*
50: * Macro to test whether some number ranges intersect; the arguments could be
51: * either a pointer to a pair of longs or a pair of ints.
52: */
53:
54: #define INTERSECT(left,right) \
55: (((left) [0] >= (right) [0] && (left) [0] <= (right) [1]) || \
56: ((left) [1] >= (right) [0] && (left) [1] <= (right) [1]))
57:
58:
59: /*
60: * This function checks all existing 'sdevice' entries to see if there is an
61: * IOA conflict.
62: *
63: * The value returned is the same value that would be returned by the matching
64: * check performed by the idcheck(1M) utility, namely:
65: * 0 if no conflict.
66: * 1 if there is a conflict.
67: * 3 if there is a conflict, but the 'mdevice' entry has the O flag set.
68: *
69: * As usual, the specification does not take into account the possibility that
70: * an IOA range may conflict with several devices with a different setting of
71: * the 'O' flag. This routine returns 3 if and only if all devices which have
72: * IOA conflicts have the 'O' flag set.
73: *
74: * If "who" is non-NULL, it will be written with the address of the sdevice
75: * entry which caused the conflict which caused the non-zero return.
76: */
77:
78: #ifdef __USE_PROTO__
79: LOCAL int (sdev_check_ioa) (sdev_t * check)
80: #else
81: LOCAL int
82: sdev_check_ioa ARGS ((check))
83: sdev_t * check;
84: #endif
85: {
86: sdev_t * sdevp;
87: int share_conflict = 0;
88:
89: if (check == NULL)
90: throw_error ("check argument is NULL in sdev_check_ioa ()");
91:
92: if (check->sd_ioa [1] == 0)
93: return 0;
94:
95: for (sdevp = _sdevices ; sdevp != NULL ; sdevp = sdevp->sd_next) {
96:
97: if (sdevp->sd_ioa [1] == 0 ||
98: ! INTERSECT (sdevp->sd_ioa, check->sd_ioa))
99: continue;
100:
101: if (mdev_flag (sdevp->sd_mdevp, MDEV_ALLOW_IOA_OVERLAP) &&
102: mdev_flag (check->sd_mdevp, MDEV_ALLOW_IOA_OVERLAP)) {
103: if (share_conflict == 0)
104: share_conflict = 3;
105: } else {
106: report_conflict (check->sd_devname->s_data,
107: sdevp->sd_devname->s_data,
108: "IOA overlap");
109: share_conflict = 1;
110: }
111: }
112: return share_conflict;
113: }
114:
115:
116: /*
117: * This function checks all existing 'sdevice' entries for a CMA conflict.
118: *
119: * The value returned will be 1 if there is a conflict and 0 if no conflict
120: * occurs. If the "who" parameter is non-NULL, it will be written with the
121: * address of the 'sdevice' entry that caused the conflict (if any).
122: */
123:
124: #ifdef __USE_PROTO__
125: LOCAL int (sdev_check_cma) (sdev_t * check)
126: #else
127: LOCAL int
128: sdev_check_cma ARGS ((check))
129: sdev_t * check;
130: #endif
131: {
132: sdev_t * sdevp;
133: int conflict = 0;
134:
135: if (check == NULL)
136: throw_error ("check argument is NULL in sdev_check_cma ()");
137:
138: if (check->sd_cma [1] == 0)
139: return 0;
140:
141: for (sdevp = _sdevices ; sdevp != NULL ; sdevp = sdevp->sd_next) {
142:
143: if (sdevp->sd_cma [1] > 0 &&
144: INTERSECT (sdevp->sd_cma, check->sd_cma)) {
145:
146: report_conflict (check->sd_devname->s_data,
147: sdevp->sd_devname->s_data,
148: "CMA overlap");
149: conflict = 1;
150: }
151: }
152:
153: return conflict;
154: }
155:
156:
157: /*
158: * This function checks all existing 'sdevice' entries to see if the interrupt
159: * vector 'vec' is in use by any of them.
160: */
161:
162: #ifdef __USE_PROTO__
163: LOCAL int (sdev_check_vector) (sdev_t * check)
164: #else
165: LOCAL int
166: sdev_check_vector ARGS ((check))
167: sdev_t * check;
168: #endif
169: {
170: sdev_t * sdevp;
171: int conflict = 0;
172:
173: if (check->sd_vector == 0)
174: return 0;
175:
176: for (sdevp = _sdevices ; sdevp != NULL ; sdevp = sdevp->sd_next) {
177:
178: if (sdevp->sd_vector != check->sd_vector)
179: continue;
180:
181: switch (sdevp->sd_itype) {
182:
183: case INT_SHAREABLE:
184: if (check->sd_itype == INT_SHAREABLE)
185: break;
186:
187: /* FALL THROUGH */
188:
189: case INT_PER_DEVICE:
190: if (sdevp->sd_devname == check->sd_devname &&
191: check->sd_itype >= INT_PER_DEVICE)
192: break;
193:
194: /* FALL THROUGH */
195:
196: case INT_PER_CHANNEL:
197: report_conflict (check->sd_devname->s_data,
198: sdevp->sd_devname->s_data,
199: "Interrupt vector conflict");
200:
201: conflict = 1;
202: break;
203:
204: case INT_NONE:
205: break;
206: }
207: }
208:
209: return conflict;
210: }
211:
212:
213: /*
214: * Regenerate an 'sdevice' entry from the stored record.
215: */
216:
217: #if USE_PROTO
218: void (write_sdevice) (sdev_t * sdevp, input_t * input)
219: #else
220: void
221: write_sdevice ARGS ((sdevp, input))
222: sdev_t * sdevp;
223: input_t * input;
224: #endif
225: {
226: if ((* input->in_filter) (input, "%s<1>%c<2>%d<3>%d<4>%d<5>%d<6>"
227: "0x%x<7>0x%x<8>0x%x<9>0x%x\n",
228: sdevp->sd_devname->s_data,
229: sdevp->sd_config ? 'Y' : 'N',
230: sdevp->sd_unit, sdevp->sd_ipl,
231: sdevp->sd_itype, sdevp->sd_vector,
232: sdevp->sd_ioa [0], sdevp->sd_ioa [1],
233: sdevp->sd_cma [0], sdevp->sd_cma [1]) < 0) {
234:
235: throw_error ("Output error");
236: }
237: }
238:
239:
240: /*
241: * Read a line from an "sdevice" file.
242: *
243: * This code is really messy. My apologies.
244: */
245:
246: #if USE_PROTO
247: LOCAL sdev_t * (read_sdevice) (input_t * input, lex_t * lexp, int * end_char)
248: #else
249: LOCAL sdev_t *
250: read_sdevice ARGS ((input, lexp, end_char))
251: input_t * input;
252: lex_t * lexp;
253: int * end_char;
254: #endif
255: {
256: VOLATILE int ch = '\n';
257: sdev_t * VOLATILE sdevp;
258: sdev_t * scan;
259: ehand_t err;
260: lex_t yesno = { NULL, NULL, "-", "ynYN", LEX_WILD };
261: symbol_t * config_flag;
262:
263: yesno.l_prev = lexp;
264:
265: if ((sdevp = (sdev_t *) malloc (sizeof (* sdevp))) == NULL)
266: throw_error ("out of memory in read_sdevice ()");
267:
268: if (PUSH_HANDLER (err) == 0) {
269: /*
270: * If the first thing on the line is EOF, that's not an error,
271: * just bail out.
272: */
273:
274: ch = read_symbol (input, lexp, & sdevp->sd_devname);
275:
276: if (sdevp->sd_devname == NULL) {
277:
278: free (sdevp);
279: sdevp = NULL;
280: goto at_eof;
281: }
282:
283: check_not_eol (ch);
284:
285: if (sdevp->sd_devname->s_size > MAX_DEVNAME)
286: throw_error ("device name must be <= %d characters",
287: MAX_DEVNAME);
288:
289: /*
290: * We read the yes/no field as a symbol, since most of the
291: * entries will be identical.
292: */
293:
294: ch = read_symbol (input, & yesno, & config_flag);
295: check_not_eol (ch);
296:
297: if (config_flag->s_size > 1)
298: throw_error ("a single Y or N is required");
299:
300: sdevp->sd_config = (config_flag->s_data [0] == 'y' ||
301: config_flag->s_data [0] == 'Y');
302:
303: /*
304: * Read the unit number; since we match both the unit number
305: * and the device name when changing an entry, we only allow
306: * one sdevice entry per unit/device combination.
307: */
308:
309: ch = read_uints (input, lexp, & sdevp->sd_unit, NO_RANGE);
310: check_not_eol (ch);
311:
312: for (scan = _sdevices ; scan != NULL ; scan = scan->sd_next)
313: if (scan->sd_devname == sdevp->sd_devname &&
314: scan->sd_unit == sdevp->sd_unit) {
315: throw_error ("Only one sdevice entry per device unit allowed");
316: }
317:
318:
319: ch = read_uints (input, lexp, & sdevp->sd_ipl, NO_RANGE);
320: check_not_eol (ch);
321:
322: if (sdevp->sd_ipl > MAX_IPL)
323: throw_error ("IPL must be in the range 0 through %d",
324: MAX_IPL);
325:
326: ch = read_uints (input, lexp, & sdevp->sd_itype, NO_RANGE);
327: check_not_eol (ch);
328:
329: if (sdevp->sd_itype > MAX_ITYPE)
330: throw_error ("interrupt type must be in the range 0 to %d",
331: MAX_ITYPE);
332:
333: ch = read_uints (input, lexp, & sdevp->sd_vector, NO_RANGE);
334: check_not_eol (ch);
335:
336:
337: /*
338: * The clock device is special-cased as the only thing that
339: * can use vector 0.
340: */
341:
342: if (strcmp (sdevp->sd_devname->s_data, "clock") != 0 &&
343: ((sdevp->sd_ipl > 0 && sdevp->sd_vector == 0) ||
344: (sdevp->sd_ipl == 0 && sdevp->sd_vector > 0))) {
345: throw_error ("IPL and vector must both be either zero or non-zero");
346: }
347:
348: if (sdevp->sd_vector > MAX_VECTOR)
349: throw_error ("vector numbers run from 0 (no vector) through %d",
350: MAX_VECTOR);
351:
352: ch = read_ulongs (input, lexp, & sdevp->sd_ioa [0], NO_RANGE);
353: check_not_eol (ch);
354:
355: ch = read_ulongs (input, lexp, & sdevp->sd_ioa [1], NO_RANGE);
356: check_not_eol (ch);
357:
358: if (sdevp->sd_ioa [0] > sdevp->sd_ioa [1])
359: throw_error ("lower bound of address range higher than upper bound");
360:
361: ch = read_ulongs (input, lexp, & sdevp->sd_cma [0], NO_RANGE);
362: check_not_eol (ch);
363:
364: ch = read_ulongs (input, lexp, & sdevp->sd_cma [1], NO_RANGE);
365:
366: if (sdevp->sd_cma [0] > sdevp->sd_cma [1])
367: throw_error ("lower bound of address range higher than upper bound");
368:
369: ch = expect_eol (input, lexp, ch);
370: } else {
371:
372: free (sdevp);
373: CHAIN_ERROR (err);
374: }
375:
376: at_eof:
377: POP_HANDLER (err);
378:
379: * end_char = ch;
380: return sdevp;
381: }
382:
383:
384: /*
385: * This function is passed as a pointer to for_all_mdevices () to aid in
386: * checking to see that enabled devices have unique major numbers.
387: */
388:
389: #if USE_PROTO
390: LOCAL void check_major (mdev_t * mdevp, mdev_t * enabled)
391: #else
392: LOCAL void
393: check_major (mdevp, enabled)
394: mdev_t * mdevp;
395: mdev_t * enabled;
396: #endif
397: {
398: CONST char * msg;
399:
400: if (mdevp == enabled || enabled->md_configure != MD_ENABLED)
401: return;
402:
403: if (mdev_flag (enabled, MDEV_BLOCK) && mdev_flag (mdevp, MDEV_BLOCK))
404: if (INTERSECT (mdevp->md_blk_maj, enabled->md_blk_maj)) {
405: msg = "Block major number overlap";
406: conflict:
407: report_conflict (mdevp->md_devname->s_data,
408: enabled->md_devname->s_data,
409: msg);
410: mdevp->md_configure = MD_DISABLED;
411: return;
412: }
413:
414: if (mdev_flag (enabled, MDEV_CHAR) && mdev_flag (mdevp, MDEV_CHAR))
415: if (INTERSECT (mdevp->md_chr_maj, enabled->md_chr_maj)) {
416: msg = "Character major number overlap";
417: goto conflict;
418: }
419:
420: if (mdev_flag (enabled, MDEV_COHERENT) &&
421: mdev_flag (mdevp, MDEV_COHERENT))
422: if (INTERSECT (mdevp->md_chr_maj, enabled->md_chr_maj)) {
423: msg = "Major number overlap";
424: goto conflict;
425: }
426: }
427:
428:
429: /*
430: * This function is passed as a parameter to read_dev_string () to read an
431: * 'mtune' entry (usually a program argument) and hook it into a global list.
432: */
433:
434: #if USE_PROTO
435: LOCAL int _read_sdev_string (input_t * input, lex_t * lexp,
436: sdev_t ** sdlistp)
437: #else
438: LOCAL int
439: _read_sdev_string (input, lexp, sdlistp)
440: input_t * input;
441: lex_t * lexp;
442: sdev_t ** sdlistp;
443: #endif
444: {
445: sdev_t * sdevp;
446: int ch;
447:
448: if ((sdevp = read_sdevice (input, lexp, & ch)) != NULL) {
449: sdevp->sd_next = * sdlistp;
450: * sdlistp = sdevp;
451: }
452:
453: return ch;
454: }
455:
456:
457: /*
458: * This function is used by _read_sdevice_file () to handle the details of
459: * linking an 'sdevice' entry into the global data structures and checking the
460: * data consistency.
461: */
462:
463: #if USE_PROTO
464: LOCAL void (link_sdevice) (sdev_t * sdevp, input_t * input)
465: #else
466: LOCAL void
467: link_sdevice ARGS ((sdevp, input))
468: sdev_t * sdevp;
469: input_t * input;
470: #endif
471: {
472: CONST char * errmsg;
473:
474: if ((sdevp->sd_mdevp = find_mdev (sdevp->sd_devname)) == NULL) {
475: errmsg = "device name does not match any master device entry";
476: have_error:
477: report_error (errmsg);
478: free (sdevp);
479: return;
480: }
481:
482: if (mdev_flag (sdevp->sd_mdevp, MDEV_ONE_SDEVICE) &&
483: sdevp->sd_mdevp->md_sdevices != NULL) {
484: errmsg = "only one sdevice entry permitted for this device";
485: goto have_error;
486: }
487:
488: if (sdevp->sd_unit < sdevp->sd_mdevp->md_minor_min ||
489: sdevp->sd_unit > sdevp->sd_mdevp->md_minor_max) {
490: errmsg = "unit number out of range for device";
491: goto have_error;
492: }
493:
494: if (sdevp->sd_ioa [1] > 0 &&
495: ! mdev_flag (sdevp->sd_mdevp, MDEV_HARDWARE)) {
496: errmsg = "software-only device cannot access I/O ports";
497: goto have_error;
498: }
499:
500: switch (sdev_check_ioa (sdevp)) {
501: case 3:
502: case 0:
503: /*
504: * Every device we might conflict with has the 'O' flag set
505: * and so do we, or there is no conflict.
506: */
507: break;
508:
509: default:
510: free (sdevp);
511: return;
512: }
513:
514: if (sdevp->sd_cma [1] > 0 &&
515: ! mdev_flag (sdevp->sd_mdevp, MDEV_HARDWARE)) {
516: errmsg = "software-only device cannot have controller memory";
517: goto have_error;
518: }
519:
520: if (sdev_check_cma (sdevp) != 0) {
521: free (sdevp);
522: return;
523: }
524:
525: if (sdevp->sd_itype > 0) {
526:
527: if (! mdev_flag (sdevp->sd_mdevp, MDEV_HARDWARE)) {
528: errmsg = "software-only device cannot have a vector";
529: goto have_error;
530: }
531:
532: sdevp->sd_mdevp->md_interrupt = 1;
533: }
534:
535:
536: if (sdev_check_vector (sdevp)) {
537: free (sdevp);
538: return;
539: }
540:
541:
542: /*
543: * After we have passed all the checks above, we commit to linking the
544: * entry in... no more gotos after this point!
545: */
546:
547: sdevp->sd_next = _sdevices;
548: _sdevices = sdevp;
549:
550: sdevp->sd_mnext = sdevp->sd_mdevp->md_sdevices;
551: sdevp->sd_mdevp->md_sdevices = sdevp;
552:
553: if (sdevp->sd_config) {
554: /*
555: * Check enabled devices for major number clashes.
556: */
557:
558: for_all_mdevices ((miter_t) check_major,
559: sdevp->sd_mdevp);
560: sdevp->sd_mdevp->md_configure = MD_ENABLED;
561: }
562:
563: write_sdevice (sdevp, input);
564: }
565:
566:
567: /*
568: * This function is passed as a pointer to read_dev_file () in order to read
569: * an 'sdevice' entry and link it into a global chain.
570: */
571:
572: #if USE_PROTO
573: LOCAL int _read_sdevice_file (input_t * input, lex_t * lexp,
574: sdev_t ** changes)
575: #else
576: LOCAL int
577: _read_sdevice_file ARGS ((input, lexp, changes))
578: input_t * input;
579: lex_t * lexp;
580: sdev_t ** changes;
581: #endif
582: {
583: sdev_t * sdevp;
584: int ch;
585:
586: if ((sdevp = read_sdevice (input, lexp, & ch)) == NULL) {
587: if (ch == READ_EOF) {
588: /*
589: * Blow remaining changes out as new entries.
590: */
591:
592: while ((sdevp = * changes) != NULL) {
593: * changes = sdevp->sd_next;
594: link_sdevice (sdevp, input);
595: }
596: }
597: return ch;
598: }
599:
600:
601: /*
602: * Link the newly-read entry into the global lists.
603: */
604:
605: if (changes) {
606: sdev_t ** scan;
607:
608: for (scan = changes ; * scan != NULL ;
609: scan = & (* scan)->sd_next) {
610:
611: if ((* scan)->sd_devname == sdevp->sd_devname &&
612: (* scan)->sd_unit == sdevp->sd_unit) {
613: /*
614: * Our current entry is being replaced by a
615: * new one.
616: */
617:
618: free (sdevp);
619:
620: if (report_mode ())
621: return ch;
622:
623: sdevp = * scan;
624: * scan = sdevp->sd_next;
625: break;
626: }
627: }
628: }
629:
630: link_sdevice (sdevp, input);
631: return ch;
632: }
633:
634:
635: /*
636: * Read in an "mtune" entry from a string and add it to a list.
637: */
638:
639: #if USE_PROTO
640: void read_sdev_string (CONST char * string, VOID * extra)
641: #else
642: void
643: read_sdev_string (string, extra)
644: CONST char * string;
645: VOID * extra;
646: #endif
647: {
648: read_dev_string (string, (dev_func_p) _read_sdev_string, extra);
649: }
650:
651:
652: /*
653: * Suck in a complete 'sdevice' file.
654: */
655:
656: #if USE_PROTO
657: void (read_sdev_file) (CONST char * inname, CONST char * outname, VOID * extra)
658: #else
659: void
660: read_sdev_file ARGS ((inname, outname, extra))
661: CONST char * inname;
662: CONST char * outname;
663: VOID * extra;
664: #endif
665: {
666: read_dev_file (inname, outname, (dev_func_p) _read_sdevice_file,
667: extra);
668: }
669:
670:
671: /*
672: * Generic insertion sort algorithm for "sdevice" entries based on a
673: * selection predicate and a comparison predicate.
674: *
675: * So that this can be a reasonably generic function, we pass it the internal
676: * offset of the "sdev_t *" member of the "sdevice" structure which will be
677: * used to link together the sorted entries.
678: *
679: * The return value is the number of items in the target list.
680: */
681:
682: #define LINK(sdevp,off) (* (sdev_t **) ((char *) (sdevp) + off))
683:
684: #if USE_PROTO
685: int (sdev_sort) (sdev_t ** sdlistp, sdev_t ** sdendp, ssel_t selpred,
686: scmp_t cmppred, size_t ptroff)
687: #else
688: int
689: sdev_sort ARGS ((sdlistp, sdendp, selpred, cmppred, ptroff))
690: sdev_t **sdlistp;
691: sdev_t **sdendp;
692: ssel_t selpred;
693: scmp_t cmppred;
694: size_t ptroff;
695: #endif
696: {
697: sdev_t * scan;
698: sdev_t * next;
699: int count;
700:
701: if (sdlistp == NULL || ptroff > sizeof (sdev_t))
702: throw_error ("bogus parameters to sdev_sort ()");
703:
704:
705: /*
706: * We'll just insert each selected member of the total list of
707: * mdevices into the output list in order by running down the output
708: * list until we compare true.
709: *
710: * We fetch "scan" before initializing the output list in case we are
711: * sorting the master device list.
712: */
713:
714: * sdlistp = NULL;
715: if (sdendp != NULL)
716: * sdendp = NULL;
717:
718: for (count = 0, scan = _sdevices ; scan != NULL ; scan = next) {
719: sdev_t * findpos;
720: sdev_t * prev;
721:
722: /*
723: * We get the "next" entry now in case we are sorting the
724: * master list. We allow a "selpred" of NULL to select all
725: * the entries.
726: */
727:
728: next = scan->sd_next;
729:
730: if (selpred != NULL && (* selpred) (scan) == 0)
731: continue;
732:
733: /*
734: * Now attempt to find the right place for the new entry and
735: * insert it there.
736: */
737:
738: prev = NULL;
739:
740: for (findpos = * sdlistp ; findpos != NULL ;
741: findpos = LINK ((prev = findpos), ptroff)) {
742: /*
743: * A "cmppred" that is NULL means that the order of
744: * output entries is irrelevant.
745: */
746:
747: if (cmppred == NULL ||
748: (* cmppred) (findpos, scan) == 0)
749: break;
750: }
751:
752: if (prev == NULL)
753: * sdlistp = scan;
754: else
755: LINK (prev, ptroff) = scan;
756:
757: if ((LINK (scan, ptroff) = findpos) == NULL && sdendp != NULL)
758: * sdendp = scan;
759:
760: count ++;
761: }
762:
763: return count;
764: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.