![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / bin / src|
Return to mkconf.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / bin / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV4 1
3:
4: /*
5: * This file contains routines for writing processed configuration data from
6: * 'devadm.c' out into a C-language configuration file, "conf.c".
7: */
8:
9: /*
10: *-IMPORTS:
11: * <sys/compat.h>
12: * CONST
13: * PROTO
14: * ARGS ()
15: * LOCAL
16: * <kernel/v_types.h>
17: * NODEV
18: * major_t
19: * minor_t
20: * <stddef.h>
21: * size_t
22: * offsetof ()
23: * NULL
24: * <stdio.h>
25: * FILE
26: * stdout
27: * fopen ()
28: * fclose ()
29: * fprintf ()
30: * <time.h>
31: * time_t
32: * strftime ()
33: * localtime ()
34: * "ehand.h"
35: * ehand_t
36: * PUSH_HANDLER ()
37: * POP_HANDLER ()
38: * CHAIN_ERROR ()
39: * throw_error ()
40: * "mdev.h"
41: * MD_ENABLED
42: * mdev_t
43: * miter_t
44: * for_all_mdevices ()
45: * "sdev.h"
46: * sdev_sort ()
47: * "symbol.h"
48: * symbol_t
49: * "assign.h"
50: * extinfo_t
51: */
52:
53: #include <sys/compat.h>
54: #include <kernel/v_types.h>
55: #include <stddef.h>
56: #include <stdio.h>
57: #include <time.h>
58: #if __COHERENT__
59: #include <string.h>
60: #endif
61:
62: #include "ehand.h"
63: #include "mdev.h"
64: #include "sdev.h"
65: #include "symbol.h"
66: #include "assign.h"
67:
68: #include "mkconf.h"
69:
70:
71: /*
72: * We define a table to ease the otherwise tedious process of building the
73: * output for the entry point specifications.
74: *
75: * Sadly, we can't use the MDEV_... constants in this table.
76: */
77:
78: struct extern_tab {
79: CONST char * flags;
80: char func;
81: CONST char * outstr;
82: };
83:
84: LOCAL struct extern_tab _exttab [] = {
85: /*
86: * For STREAMS we have to generate an external reference to the
87: * STREAMS function table. We also have to generate stubs for the
88: * character-device entry points to map the SysV calling sequence
89: * into calls to the STREAMS-device entry points.
90: *
91: * Rather than generate those stubs here, we simply call up a generic
92: * template-style macro that will generate all the stubs we need. This
93: * is necessary since we may also be generating stubs for mapping from
94: * some non-SVR4 calling convention to SVR4 for regular devices, and
95: * the macro can deal with that, building the non-SVR4 to STREAMS
96: * mapping in one step.
97: *
98: * The stub generation happens in the second part of this table along
99: * with stub generation for regular devices.
100: */
101:
102: { "Sc", 0, "DECLARE_STREAMS (%s)" },
103: { "S!c", 0, "DECLARE_MODULE (%s)" },
104:
105:
106: /*
107: * Now the regular device entry-point stuff.
108: */
109:
110: { "b", 0, "DECLARE_STRATEGY (%s)" },
111: { "b", 0, "DECLARE_PRINT (%s)" },
112:
113:
114: /*
115: * We assume that a STREAMS driver will only define the entry points
116: * below if it is also capable of acting as a block device or if the
117: * entry is applicable regardless of type.
118: *
119: * For practical reasons other parts of this system may not permit
120: * combination STREAMS and block drivers, because with a common entry
121: * point table for both types of device the block-mode entry points
122: * like open () will conflict with the stub generated for STREAMS.
123: */
124:
125: { NULL, MDEV_OPEN, "DECLARE_OPEN (%s)" },
126: { NULL, MDEV_CLOSE, "DECLARE_CLOSE (%s)" },
127: { NULL, MDEV_READ, "DECLARE_READ (%s)" },
128: { NULL, MDEV_WRITE, "DECLARE_WRITE (%s)" },
129: { NULL, MDEV_IOCTL, "DECLARE_IOCTL (%s)" },
130: { NULL, MDEV_CHPOLL, "DECLARE_CHPOLL (%s)" },
131:
132: { NULL, MDEV_INIT, "DECLARE_INIT (%s)" },
133: { NULL, MDEV_STARTUP, "DECLARE_STARTUP (%s)" },
134: { NULL, MDEV_EXIT, "DECLARE_EXIT (%s)" },
135: { NULL, MDEV_HALT, "DECLARE_HALT (%s)" },
136:
137:
138: /*
139: * For supporting Coherent drivers.
140: */
141:
142: { "C", 0, "DECLARE_DRVL (%s)" },
143:
144: /*
145: * The SVR4-MP DDI/DDK defines an optional mmap () entry point
146: * for character devices, yet there is no function code for
147: * this defined in the System Files and Devices manual. Block
148: * drivers have the same problem with the size () entry.
149: */
150:
151: { "b", MDEV_SIZE, "DECLARE_SIZE (%s)" },
152: { "c", MDEV_MMAP, "DECLARE_MMAP (%s)" }
153:
154: /*
155: * The fork (), exec (), kenter () and kexit () entry points aren't
156: * defined for device drivers. In fact, I'm not sure what they *are*
157: * for unless it's for system services - processes that run in the
158: * kernel at higher priority than any user process (but usually at a
159: * lower priority than real-time processes).
160: *
161: * Since what Coherent has can barely be called a scheduler, these
162: * aren't defined here.
163: */
164: };
165:
166:
167: /*
168: * Optionally write based on function test.
169: */
170:
171: #if USE_PROTO
172: LOCAL void (write_func) (FILE * out, mdev_t * mdevp, struct extern_tab * tab)
173: #else
174: LOCAL void
175: write_func ARGS ((out, mdevp, tab))
176: FILE * out;
177: mdev_t * mdevp;
178: struct extern_tab * tab;
179: #endif
180: {
181: CONST char * fcheck;
182:
183: if (out == NULL || mdevp == NULL || tab == NULL)
184: throw_error ("NULL pointer passed to write_func ()");
185:
186: if (tab->outstr == NULL)
187: throw_error ("bad table parameter passed to write_func ()");
188:
189: if ((fcheck = tab->flags) != NULL) {
190: /*
191: * Test for the logical "and" of the functions specified.
192: */
193:
194: while (* fcheck) {
195:
196: if (* fcheck == '!') {
197:
198: if (mdev_flag (mdevp, * ++ fcheck))
199: return;
200: fcheck ++;
201: } else if (! mdev_flag (mdevp, * fcheck ++))
202: return;
203: }
204: }
205:
206: if (tab->func && ! mdev_func (mdevp, tab->func))
207: return;
208:
209: (void) fprintf (out, tab->outstr, mdevp->md_prefix->s_data);
210: (void) fputc ('\n', out);
211: }
212:
213:
214: /*
215: * Output "extern" declarations for device-driver entry points.
216: */
217:
218: #if USE_PROTO
219: LOCAL void write_extern (FILE * out, mdev_t * mdevp)
220: #else
221: LOCAL void
222: write_extern (out, mdevp)
223: FILE * out;
224: mdev_t * mdevp;
225: #endif
226: {
227: int i;
228:
229: if (mdevp == NULL)
230: throw_error ("NULL 'mdevp' passed to write_extern ()");
231:
232: if (mdevp->md_configure != MD_ENABLED)
233: return;
234:
235: /*
236: * Test to see whether it is a driver we are dealing with.
237: */
238:
239: if (mdev_flag (mdevp, MDEV_BLOCK) || mdev_flag (mdevp, MDEV_CHAR) ||
240: mdev_flag (mdevp, MDEV_STREAM)) {
241:
242: (void) fprintf (out, "/* entry points for \"%s\" driver */\n\n",
243: mdevp->md_devname->s_data);
244: (void) fprintf (out, "extern int %sdevflag;\n",
245: mdevp->md_prefix->s_data);
246: } else
247: (void) fprintf (out, "/* entry points for \"%s\" facility */\n\n",
248: mdevp->md_devname->s_data);
249:
250: for (i = 0 ; i < sizeof (_exttab) / sizeof (* _exttab) ; i ++)
251: write_func (out, mdevp, & _exttab [i]);
252:
253: if (mdevp->md_interrupt)
254: (void) fprintf (out, "DECLARE_INTR (%s)\n",
255: mdevp->md_prefix->s_data);
256:
257: (void) fprintf (out, "\n\n");
258: }
259:
260:
261: /*
262: * Output all the extern declarations needed to generate the tables.
263: */
264:
265: #if USE_PROTO
266: void (write_externs) (FILE * out)
267: #else
268: void
269: write_externs ARGS ((out))
270: FILE * out;
271: #endif
272: {
273: for_all_mdevices ((miter_t) write_extern, out);
274: }
275:
276:
277: /*
278: * Structure for holding args to simulate local functions in C.
279: */
280:
281: struct ISEH {
282: FILE * _out;
283: char _func;
284: CONST char * _name;
285: CONST char * _capsname;
286: int _any;
287: };
288:
289: #if USE_PROTO
290: LOCAL void _write_ISEH (struct ISEH * info, mdev_t * mdevp)
291: #else
292: LOCAL void
293: _write_ISEH (info, mdevp)
294: struct ISEH * info;
295: mdev_t * mdevp;
296: #endif
297: {
298: if (mdevp->md_configure != MD_ENABLED ||
299: ! mdev_func (mdevp, info->_func))
300: return;
301:
302: if (! info->_any) {
303:
304: info->_any = 1;
305:
306: (void) fprintf (info->_out, "%s_t %stab [] = {\n",
307: info->_name, info->_name);
308: } else
309: (void) fprintf (info->_out, ",\n");
310:
311: (void) fprintf (info->_out, "\t%s (%s)", info->_capsname,
312: mdevp->md_prefix->s_data);
313: }
314:
315:
316: /*
317: * Write a table of (init, start, exit, halt) routines.
318: */
319:
320: #if USE_PROTO
321: LOCAL void (write_ISEH) (FILE * out, char func, CONST char * name,
322: CONST char * capsname)
323: #else
324: LOCAL void
325: write_ISEH ARGS ((out, func, name, capsname))
326: FILE * out;
327: char func;
328: CONST char * name;
329: CONST char * capsname;
330: #endif
331: {
332: struct ISEH info;
333:
334: info._out = out;
335: info._func = func;
336: info._name = name;
337: info._capsname = capsname;
338: info._any = 0;
339:
340: for_all_mdevices ((miter_t) _write_ISEH, & info);
341:
342: if (info._any) {
343: (void) fprintf (out, "\n};\n\nunsigned int n%s = sizeof "
344: "(%stab) / sizeof (* %stab);\n\n",
345: name, name, name);
346: } else
347: (void) fprintf (out, "%s_t %stab [1];\n\nunsigned int n%s"
348: "= 0;\n\n",
349: name, name, name);
350: }
351:
352:
353: /*
354: * Write the init, startup, exit and halt-routine tables.
355: */
356:
357: #if USE_PROTO
358: void (write_misc) (FILE * out)
359: #else
360: void
361: write_misc ARGS ((out))
362: FILE * out;
363: #endif
364: {
365: write_ISEH (out, MDEV_INIT, "init", "INIT");
366: write_ISEH (out, MDEV_STARTUP, "start","START");
367: write_ISEH (out, MDEV_EXIT, "exit", "EXIT");
368: write_ISEH (out, MDEV_HALT, "halt", "HALT");
369: }
370:
371:
372: /*
373: * A table to help simplify the process of writing out device-switch table
374: * entries.
375: */
376:
377: typedef struct {
378: char func;
379: CONST char * str;
380: CONST char * nullstr;
381: } devtab_t;
382:
383:
384: LOCAL devtab_t _cdevswtab [] = {
385: { MDEV_OPEN, "OPEN (%s)", "NULL_OPEN" },
386: { MDEV_CLOSE, "CLOSE (%s)", "NULL_CLOSE" },
387: { MDEV_READ, "READ (%s)", "NULL_READ" },
388: { MDEV_WRITE, "WRITE (%s)", "NULL_WRITE" },
389: { MDEV_IOCTL, "\n\t\tIOCTL (%s)",
390: "\n\t\tNULL_IOCTL" },
391: { MDEV_CHPOLL, "CHPOLL (%s)", "NULL_CHPOLL" },
392: { MDEV_MMAP, "MMAP (%s)", "NULL_MMAP" },
393: { 0, NULL, NULL }
394: };
395:
396:
397: LOCAL devtab_t _bdevswtab [] = {
398: { MDEV_OPEN, "OPEN (%s)", "NULL_OPEN" },
399: { MDEV_CLOSE, "CLOSE (%s)", "NULL_CLOSE" },
400: { 0, "STRATEGY (%s)", NULL },
401: { 0, "PRINT (%s)", NULL },
402: { MDEV_SIZE, "SIZE (%s)", "NULL_SIZE" },
403: { 0, NULL, NULL }
404: };
405:
406:
407: /*
408: * Output an entry for a device-switch table.
409: */
410:
411: #if USE_PROTO
412: LOCAL void (write_devsw_line) (FILE * out, mdev_t * mdevp, devtab_t * devtab)
413: #else
414: LOCAL void
415: write_devsw_line ARGS ((out, mdevp, devtab))
416: FILE * out;
417: mdev_t * mdevp;
418: devtab_t * devtab;
419: #endif
420: {
421: (void) fprintf (out, "_ENTRY (& %sdevflag, ",
422: mdevp->md_prefix->s_data);
423:
424: while (devtab->str != NULL) {
425:
426: if (devtab->func == 0 || mdev_func (mdevp, devtab->func))
427: (void) fprintf (out, devtab->str,
428: mdevp->md_prefix->s_data);
429: else
430: (void) fprintf (out, devtab->nullstr);
431:
432: if ((++ devtab)->str != NULL)
433: (void) fprintf (out, ", ");
434: }
435:
436: (void) fprintf (out, ")");
437: }
438:
439:
440: /*
441: * Write an cdevsw [] and bdevsw [] tables.
442: */
443:
444: #if USE_PROTO
445: LOCAL void (write_devsw) (FILE * out, extinfo_t * extinfop)
446: #else
447: LOCAL void
448: write_devsw ARGS ((out, extinfop))
449: FILE * out;
450: extinfo_t * extinfop;
451: #endif
452: {
453: int i;
454:
455: if (extinfop->ei_ncdevs > 0) {
456:
457: (void) fprintf (out, "cdevsw_t cdevsw [] = {\n");
458:
459: for (i = 0 ; i < extinfop->ei_ncdevs ; i ++) {
460: mdev_t * mdevp = extinfop->ei_cdevsw [i];
461:
462: if (i > 0)
463: (void) fprintf (out, ",\n");
464:
465: if (mdevp == NULL)
466: (void) fprintf (out, "\tNULL_CDEVSW ()");
467: else if (mdev_flag (mdevp, MDEV_STREAM) != 0) {
468:
469: (void) fprintf (out, "\tSTREAMS_ENTRY (%s)",
470: mdevp->md_prefix->s_data);
471: } else {
472:
473: (void) fprintf (out, "\tCDEVSW");
474:
475: write_devsw_line (out, mdevp, _cdevswtab);
476: }
477: }
478:
479: (void) fprintf (out, "\n};\n\nunsigned int ncdevsw = sizeof "
480: "(cdevsw) / sizeof (* cdevsw);\n\n");
481: } else {
482:
483: (void) fprintf (out, "cdevsw_t cdevsw [1];\n\n");
484: (void) fprintf (out, "unsigned int ncdevsw = 0;\n\n");
485: }
486:
487:
488: if (extinfop->ei_nbdevs > 0) {
489:
490: (void) fprintf (out, "bdevsw_t bdevsw [] = {\n");
491:
492: for (i = 0 ; i < extinfop->ei_nbdevs ; i ++) {
493:
494: if (i > 0)
495: (void) fprintf (out, ",\n");
496:
497: if (extinfop->ei_bdevsw [i] != NULL) {
498:
499: (void) fprintf (out, "\tBDEVSW");
500:
501: write_devsw_line (out,
502: extinfop->ei_bdevsw [i],
503: _bdevswtab);
504: } else
505: (void) fprintf (out, "\tNULL_BDEVSW ()");
506: }
507:
508: (void) fprintf (out, "\n};\n\nunsigned int nbdevsw = sizeof "
509: "(bdevsw) / sizeof (* bdevsw);\n\n");
510: } else {
511:
512: (void) fprintf (out, "bdevsw_t bdevsw [1];\n\n");
513: (void) fprintf (out, "unsigned int nbdevsw = 0;\n\n");
514: }
515: }
516:
517:
518: /*
519: * Write a STREAMS module table.
520: */
521:
522: #if USE_PROTO
523: LOCAL void (write_modtab) (FILE * out, extinfo_t * extinfop)
524: #else
525: LOCAL void
526: write_modtab ARGS ((out, extinfop))
527: FILE * out;
528: extinfo_t * extinfop;
529: #endif
530: {
531: int i;
532:
533: if (extinfop->ei_nmodules > 0) {
534:
535: (void) fprintf (out, "modsw_t modsw [] = {\n");
536:
537: for (i = 0 ; i < extinfop->ei_nmodules ; i ++) {
538:
539: if (i > 0)
540: (void) fprintf (out, ",\n");
541:
542: (void) fprintf (out, "\tMODSW_ENTRY (%s)",
543: extinfop->ei_modules [i]->md_devname->s_data);
544: }
545:
546: (void) fprintf (out, "\n};\n\nunsigned int nmodsw = sizeof "
547: "(modsw) / sizeof (* modsw);\n\n");
548: } else {
549:
550: (void) fprintf (out, "modsw_t modsw [1];\n\n");
551: (void) fprintf (out, "unsigned int nmodsw = 0;\n\n");
552: }
553: }
554:
555:
556: /*
557: * Write the external-to-internal device number mapping tables.
558: */
559:
560: #if USE_PROTO
561: LOCAL void (write_mappings) (FILE * out, extinfo_t * extinfop)
562: #else
563: LOCAL void
564: write_mappings ARGS ((out, extinfop))
565: FILE * out;
566: extinfo_t * extinfop;
567: #endif
568: {
569: int i;
570:
571: (void) fprintf (out, "__major_t _maxmajor = %d;\n\n",
572: extinfop->ei_nemajors);
573:
574: (void) fprintf (out, "__major_t _major [] = {");
575:
576: for (i = 0 ; i < extinfop->ei_nemajors ; i ++) {
577:
578: if (i % 8 == 0)
579: (void) fprintf (out, "\n\t");
580:
581: if (extinfop->ei_etoimajor [i] == NODEV)
582: (void) fprintf (out, "NODEV, ");
583: else
584: (void) fprintf (out, "%d, ",
585: extinfop->ei_etoimajor [i]);
586: }
587:
588: (void) fprintf (out, "NODEV\n};\n\n");
589:
590: (void) fprintf (out, "__minor_t _minor [] = {");
591:
592: for (i = 0 ; i < extinfop->ei_nemajors ; i ++) {
593:
594: if (i % 16 == 0)
595: (void) fprintf (out, "\n\t");
596:
597: (void) fprintf (out, "%d, ", extinfop->ei_minoroffset [i]);
598: }
599:
600: (void) fprintf (out, "0\n};\n\n");
601: }
602:
603:
604: /*
605: * Selection predicate for choosing "sdevice" entries that specify interrupt
606: * vectors.
607: */
608:
609: #if USE_PROTO
610: LOCAL int (sel_vector) (sdev_t * sdevp)
611: #else
612: LOCAL int
613: sel_vector ARGS ((sdevp))
614: sdev_t * sdevp;
615: #endif
616: {
617: return sdevp->sd_itype > 0;
618: }
619:
620:
621: /*
622: * Comparison predicate for sorting "sdevice" entries by vector number.
623: */
624:
625: #if USE_PROTO
626: LOCAL int (cmp_vector) (sdev_t * left, sdev_t * right)
627: #else
628: LOCAL int
629: cmp_vector ARGS ((left, right))
630: sdev_t * left;
631: sdev_t * right;
632: #endif
633: {
634: return left->sd_vector < right->sd_vector;
635: }
636:
637:
638: /*
639: * Function for generating tables of interrupt information.
640: */
641:
642: #if USE_PROTO
643: LOCAL void (write_vectors) (FILE * out)
644: #else
645: LOCAL void
646: write_vectors ARGS ((out))
647: FILE * out;
648: #endif
649: {
650: sdev_t * sdev_list;
651: sdev_t * sdevp;
652: int i;
653: unsigned long masks [MAX_IPL + 1];
654:
655:
656: /*
657: * We select all the "sdevice" entries that request vectors and sort
658: * them into order by vector so it's simple to determine what is
659: * going on.
660: */
661:
662: (void) sdev_sort (& sdev_list, NULL, sel_vector, cmp_vector,
663: offsetof (sdev_t, sd_link));
664:
665:
666: /*
667: * A first pass through the list determines which vectors are being
668: * used at which priority to build masks for the various levels.
669: */
670:
671: for (i = 0 ; i <= MAX_IPL ; i ++)
672: masks [i] = 0;
673:
674: for (sdevp = sdev_list ; sdevp != NULL ; sdevp = sdevp->sd_link)
675: masks [sdevp->sd_ipl] = 1UL << sdevp->sd_vector;
676:
677: (void) fprintf (out, "intmask_t _masktab [] = {");
678:
679: for (i = 0 ; i < MAX_IPL ; i ++) {
680:
681: if (i % 4 == 0)
682: (void) fprintf (out, "\n\t");
683:
684: (void) fprintf (out, "0x%xUL, ", masks [i]);
685:
686: masks [i + 1] |= masks [i];
687: }
688:
689: (void) fprintf (out, "\n\t0xFFFFFFFFUL\n};\n\n");
690:
691:
692: /*
693: * Now we generate thunks for the various interrupt entry points that
694: * can wrap up any mask-manipulation magic.
695: */
696:
697: i = -1;
698:
699: for (sdevp = sdev_list ; sdevp != NULL ; sdevp = sdevp->sd_link) {
700:
701: if (sdevp->sd_vector != i) {
702: if (i != -1)
703: (void) fprintf (out, "END_THUNK (%d)\n\n", i);
704:
705: i = sdevp->sd_vector;
706:
707: (void) fprintf (out, "BEGIN_THUNK (%d, 0x%xUL)\n",
708: i, masks [sdevp->sd_ipl]);
709: }
710:
711: (void) fprintf (out, "\tCALL_INTR (%d, %s)\n", i,
712: sdevp->sd_mdevp->md_prefix->s_data);
713: }
714:
715: if (i != -1)
716: (void) fprintf (out, "END_THUNK (%d)\n\n", i);
717:
718:
719: /*
720: * Now build a simple table which we can use to install the interrupt
721: * thunks we have built.
722: */
723:
724:
725: if (i == -1) {
726:
727: (void) fprintf (out, "intr_t inttab [1];\n\nunsigned int "
728: "nintr = 0;\n\n");
729: return;
730: }
731:
732: (void) fprintf (out, "intr_t inttab [] = {\n");
733:
734:
735: i = -1;
736:
737: for (sdevp = sdev_list ; sdevp != NULL ; sdevp = sdevp->sd_link) {
738:
739: if (sdevp->sd_vector != i) {
740: if (i != -1)
741: (void) fprintf (out, ",\n");
742:
743: i = sdevp->sd_vector;
744:
745: (void) fprintf (out, "\tINTR_THUNK (%d)", i);
746: }
747: }
748:
749: (void) fprintf (out, "\n};\n\nunsigned int nintr = sizeof (inttab) /"
750: " sizeof (* inttab);\n\n");
751: }
752:
753:
754: /*
755: * Write out a drvl [] table for old-style Coherent drivers.
756: */
757:
758: #if USE_PROTO
759: LOCAL void write_drvl (FILE * out, extinfo_t * extinfop)
760: #else
761: LOCAL void
762: write_drvl (out, extinfop)
763: FILE * out;
764: extinfo_t * extinfop;
765: #endif
766: {
767: int i;
768: mdev_t ** drv;
769:
770: (void) fprintf (out, "DRV drvl [%d] = {\n", MAJOR_RESERVED);
771:
772: for (drv = extinfop->ei_cohdrivers, i = 0 ; i < MAJOR_RESERVED ;
773: i ++) {
774: if ((* drv)->md_blk_maj [0] == i)
775: (void) fprintf (out, "\tDRVL_ENTRY (%s)",
776: (* drv ++)->md_prefix->s_data);
777: else
778: (void) fprintf (out, "\tNULL_DRVL ()");
779: (void) fprintf (out, i < MAJOR_RESERVED - 1 ? ",\n" : "\n");
780:
781: }
782:
783: (void) fprintf (out, "};\n\nint drvn = %d;\n\n", MAJOR_RESERVED);
784: }
785:
786:
787: /*
788: * Write out a C-language configuration file with definitions for all the data
789: * the implementation needs compiled from the plain-text configuration
790: * database.
791: */
792:
793: #if USE_PROTO
794: int (write_conf_c) (CONST char * name, extinfo_t * extinfop)
795: #else
796: int
797: write_conf_c ARGS ((name, extinfop))
798: CONST char * name;
799: extinfo_t * extinfop;
800: #endif
801: {
802: time_t gentime;
803: char timebuf [70];
804: FILE * VOLATILE out;
805: ehand_t err;
806:
807: if (name == NULL)
808: out = stdout;
809: else if ((out = fopen (name, "w")) == NULL)
810: throw_error ("Unable to open output file for writing");
811:
812: if (PUSH_HANDLER (err) == 0) {
813: time (& gentime);
814:
815: fprintf (out, "/*\n");
816: fprintf (out, " * The code in this file was automatically "
817: "generated. Do not hand-modify!\n");
818:
819: #if __COHERENT__
820: strncpy (timebuf, asctime (localtime (& gentime)),
821: sizeof (timebuf) - 1);
822: timebuf [sizeof (timebuf) - 1] = 0;
823: if (strchr (timebuf, '\n') != NULL)
824: * strchr (timebuf, '\n') = 0;
825: #else
826: strftime (timebuf, sizeof (timebuf) - 1, "%x %X %Z",
827: localtime (& gentime));
828: #endif
829:
830: fprintf (out, " * Generated at %s\n", timebuf);
831: fprintf (out, " */\n\n");
832: fprintf (out, "#define _KERNEL\t\t1\n");
833: fprintf (out, "#define _DDI_DKI\t1\n\n");
834: fprintf (out, "#include <sys/confinfo.h>\n\n");
835:
836: write_externs (out);
837: write_misc (out);
838: write_devsw (out, extinfop);
839: write_modtab (out, extinfop);
840: write_mappings (out, extinfop);
841: write_vectors (out);
842: #if __COHERENT__
843: write_drvl (out, extinfop);
844: #endif
845:
846: if (out != stdout)
847: fclose (out);
848: } else {
849: if (out != stdout)
850: fclose (out);
851: CHAIN_ERROR (err);
852: }
853:
854: POP_HANDLER (err);
855: return 0;
856: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.