![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to confinfo.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / usr / include / kernel|
Return to confinfo.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include / kernel |
1.1 root 1: #ifndef __KERNEL_CONFINFO_H__
2: #define __KERNEL_CONFINFO_H__
3:
4: /*
5: * This file contains definitions used by the automatically-generated
6: * configuration file "conf.c". The generated code makes heavy use of macros
7: * to allow the final result to be precisely tailored to the target system
8: * without modification to the code generator.
9: */
10: /*
11: *-IMPORTS:
12: * <common/ccompat.h>
13: * __EXTERN_C_BEGIN__
14: * __EXTERN_C_END__
15: * __USE_PROTO__
16: * __PROTO ()
17: * <common/xdebug.h>
18: * __LOCAL__
19: * <kernel/ddi_cpu.h>
20: * intmask_t
21: * <kernel/v_types.h>
22: * cred_t
23: * n_dev_t
24: * n_off_t
25: * major_t
26: * minor_t
27: * <sys/inline.h>
28: * _masktab []
29: * __GET_BASE_MASK ()
30: * __SET_BASE_MASK ()
31: * <sys/stream.h>
32: * struct streamtab
33: * <sys/uio.h>
34: * uio_t
35: */
36:
37: #include <common/ccompat.h>
38: #include <common/xdebug.h>
39: #include <kernel/ddi_cpu.h>
40: #include <kernel/v_types.h>
41: #include <sys/inline.h>
42: #include <sys/stream.h>
43: #include <sys/uio.h>
44:
45:
46: #ifdef __USE_PROTO__
47: #define DEF(ansi,k_r) ansi
48: #else
49: #define DEF(ansi,k_r) k_r
50: #endif
51:
52: /*
53: * Since we don't import the definition of "buf", let's create an incomplete
54: * definition at file scope. Same for "pollhead".
55: */
56:
57: struct buf;
58: struct pollhead;
59:
60: #define __OPEN(name) __CONCAT (name, open)
61: #define __CLOSE(name) __CONCAT (name, close)
62: #define __READ(name) __CONCAT (name, read)
63: #define __WRITE(name) __CONCAT (name, write)
64: #define __IOCTL(name) __CONCAT (name, ioctl)
65: #define __STRATEGY(name) __CONCAT (name, strategy)
66: #define __PRINT(name) __CONCAT (name, print)
67: #define __SIZE(name) __CONCAT (name, size)
68: #define __CHPOLL(name) __CONCAT (name, chpoll)
69: #define __MMAP(name) __CONCAT (name, mmap)
70: #define __INTR(name) __CONCAT (name, intr)
71: #define __INIT(name) __CONCAT (name, init)
72: #define __HALT(name) __CONCAT (name, halt)
73: #define __START(name) __CONCAT (name, start)
74: #define __EXIT(name) __CONCAT (name, exit)
75:
76: #define __INFO(name) __CONCAT (name, info)
77: #define __DEVFLAG(name) __CONCAT (name, devflag)
78:
79:
80: typedef int (* ddi_open_t) __PROTO ((n_dev_t * _devp, int _oflag,
81: int _otyp, __cred_t * _credp));
82: #define EXTERN_OPEN(name) __EXTERN_C__ \
83: int __OPEN (name) __PROTO ((n_dev_t * _devp, int _oflag,\
84: int _otyp, __cred_t * _credp))
85:
86: typedef int (* ddi_close_t) __PROTO ((n_dev_t _dev, int _oflag, int _otyp,
87: cred_t * _credp));
88: #define EXTERN_CLOSE(name) __EXTERN_C__ \
89: int __CLOSE (name) __PROTO ((n_dev_t _dev, int _oflag, int _otyp,\
90: cred_t * _credp))
91:
92: typedef int (* ddi_read_t) __PROTO ((n_dev_t _dev, uio_t * _uiop,
93: cred_t * _credp));
94: #define EXTERN_READ(name) __EXTERN_C__ \
95: int __READ (name) __PROTO ((n_dev_t _dev, uio_t * _uiop,\
96: cred_t * _credp))
97:
98: typedef int (* ddi_write_t) __PROTO ((n_dev_t _dev, uio_t * _uiop,
99: cred_t * _credp));
100: #define EXTERN_WRITE(name) __EXTERN_C__ \
101: int __WRITE (name) __PROTO ((n_dev_t _dev, uio_t * _uiop,\
102: cred_t * _credp))
103:
104: typedef int (* ddi_ioctl_t) __PROTO ((n_dev_t _dev, int _cmd, _VOID * _arg,
105: int _mode, cred_t * _credp,
106: int * _rvalp));
107: #define EXTERN_IOCTL(name) __EXTERN_C__ \
108: int __IOCTL (name) __PROTO ((n_dev_t _dev, int _cmd, _VOID * _arg,\
109: int _mode, cred_t * _credp,\
110: int * _rvalp))
111:
112: typedef int (* ddi_strategy_t) __PROTO ((struct buf * _bufp));
113: #define EXTERN_STRATEGY(name) __EXTERN_C__ \
114: int __STRATEGY (name) __PROTO ((struct buf * _bufp))
115:
116: typedef int (* ddi_print_t) __PROTO ((n_dev_t _dev, char * _str));
117: #define EXTERN_PRINT(name) __EXTERN_C__ \
118: int __PRINT (name) __PROTO ((n_dev_t _dev, char * _str))
119:
120: typedef int (* ddi_size_t) __PROTO ((n_dev_t _dev));
121: #define EXTERN_SIZE(name) __EXTERN_C__ \
122: int __SIZE (name) __PROTO ((n_dev_t _dev))
123:
124: typedef int (* ddi_chpoll_t) __PROTO ((n_dev_t _dev, short _events,
125: int _anyyet, short * _reventsp,
126: struct pollhead ** _phpp));
127: #define EXTERN_CHPOLL(name) __EXTERN_C__ \
128: int __CHPOLL (name) __PROTO ((n_dev_t _dev, short _events,\
129: int _anyyet, short * _reventsp,\
130: struct pollhead ** _phpp))
131:
132: typedef int (* ddi_mmap_t) __PROTO ((n_dev_t _dev, off_t _off,
133: int _prot));
134: #define EXTERN_MMAP(name) __EXTERN_C__ \
135: int __MMAP (name) __PROTO ((n_dev_t _dev, off_t _off,\
136: int _prot))
137:
138: typedef int (* ddi_intr_t) __PROTO ((int _ivec));
139: #define EXTERN_INTR(name) __EXTERN_C__ \
140: int __INTR (name) __PROTO ((int _ivec))
141:
142: typedef void (* ddi_init_t) __PROTO ((void));
143: #define EXTERN_INIT(name) __EXTERN_C__ \
144: void __INIT (name) __PROTO ((void))
145:
146: typedef void (* ddi_start_t) __PROTO ((void));
147: #define EXTERN_START(name) __EXTERN_C__ \
148: void __START (name) __PROTO ((void))
149:
150: typedef void (* ddi_exit_t) __PROTO ((void));
151: #define EXTERN_EXIT(name) __EXTERN_C__ \
152: void __EXIT (name) __PROTO ((void))
153:
154: typedef void (* ddi_halt_t) __PROTO ((void));
155: #define EXTERN_HALT(name) __EXTERN_C__ \
156: void __HALT (name) __PROTO ((void))
157:
158: #define NULL_OPEN ((ddi_open_t) 0)
159: #define NULL_CLOSE ((ddi_close_t) 0)
160: #define NULL_READ ((ddi_read_t) 0)
161: #define NULL_WRITE ((ddi_write_t) 0)
162: #define NULL_IOCTL ((ddi_ioctl_t) 0)
163: #define NULL_STRATEGY ((ddi_strategy_t) 0)
164: #define NULL_PRINT ((ddi_print_t) 0)
165: #define NULL_SIZE ((ddi_size_t) 0)
166: #define NULL_CHPOLL ((ddi_chpoll_t) 0)
167: #define NULL_MMAP ((ddi_mmap_t) 0)
168: #define NULL_INTR ((ddi_intr_t) 0)
169: #define NULL_INIT ((ddi_init_t) 0)
170: #define NULL_START ((ddi_start_t) 0)
171: #define NULL_EXIT ((ddi_exit_t) 0)
172: #define NULL_HALT ((ddi_halt_t) 0)
173:
174:
175: #if __COHERENT__ || defined (__MSDOS__)
176:
177: #define __KERNEL__ 2
178:
179: #if defined (__MSDOS__)
180: #include <sys/_con.h>
181: #else
182: #include <sys/buf.h>
183: #include <sys/con.h>
184: #include <sys/reg.h>
185: #endif
186:
187: #include <sys/io.h>
188:
189: #undef __KERNEL__
190:
191: __EXTERN_C_BEGIN__
192:
193: int _forward_open __PROTO ((o_dev_t _dev, int _mode, int _flags,
194: ddi_open_t _funcp));
195: int _forward_close __PROTO ((o_dev_t _dev, int _mode, int _flags,
196: ddi_close_t _funcp));
197: int _forward_read __PROTO ((o_dev_t _dev, IO * _iop,
198: ddi_read_t _funcp));
199: int _forward_write __PROTO ((o_dev_t _dev, IO * _iop,
200: ddi_write_t _funcp));
201: int _forward_ioctl __PROTO ((o_dev_t _dev, int _cmd,
202: _VOID * _arg, int mode,
203: ddi_ioctl_t _funcp));
204: #ifndef __MSDOS__
205: int _forward_strategy __PROTO ((BUF * _buf,
206: ddi_strategy_t _funcp));
207: #endif
208: int _forward_chpoll __PROTO ((o_dev_t _dev, int _events,
209: int _msec, ddi_chpoll_t _funcp));
210:
211: int _streams_open __PROTO ((o_dev_t _dev, int _mode, int _flags,
212: struct streamtab * _infop));
213: int _streams_close __PROTO ((o_dev_t _dev, int _mode, int _flags,
214: struct streamtab * _infop));
215: int _streams_read __PROTO ((o_dev_t _dev, IO * _iop,
216: struct streamtab * _infop));
217: int _streams_write __PROTO ((o_dev_t _dev, IO * _iop,
218: struct streamtab * _infop));
219: int _streams_ioctl __PROTO ((o_dev_t _dev, int _cmd,
220: _VOID * _arg, int mode,
221: struct streamtab * _infop));
222: int _streams_chpoll __PROTO ((o_dev_t _dev, int _events,
223: int _msec,
224: struct streamtab * _infop));
225:
226: __EXTERN_C_END__
227:
228: typedef struct {
229: int * cdev_flag;
230: CON cdev_con;
231: } cdevsw_t;
232:
233: /*
234: * Note that we do not have the DFPOL flag set by default. While most compilers
235: * can evaluate a "(ch) == 0 ? :" type of expression which is a constant in an
236: * initializer, the MWC compiler cannot do so reliably. We fix up the flags at
237: * startup time as a result.
238: */
239:
240: #define CDEVSW_ENTRY(fl,op,cl,re,wr,io,ch,mm) \
241: { (fl), { DFCHR, 0, \
242: (op), (cl), 0, (re), (wr), (io), 0, 0, 0, 0, (ch) } }
243:
244: #define NULL_CDEVSW() \
245: { 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
246:
247: #define STREAMS_ENTRY(name) \
248: { & __DEVFLAG (name), { DFCHR | DFPOL, 0, \
249: __CONCAT (name, openS), __CONCAT (name, closeS), \
250: 0, __CONCAT (name, readS), __CONCAT (name, writeS), \
251: __CONCAT (name, ioctlS), 0, 0, 0, 0, \
252: __CONCAT (name, chpollS) } }
253:
254: #define COH_OPEN(name,s) \
255: __LOCAL__ int __CONCAT3 (name, open, s) \
256: DEF ((o_dev_t dev, int mode, int flag),\
257: (dev, mode, flag) o_dev_t dev; int mode; int flag;)
258:
259: #define COH_CLOSE(name,s) \
260: __LOCAL__ int __CONCAT3 (name, close, s) \
261: DEF ((o_dev_t dev, int mode, int flag), \
262: (dev, mode, flag) o_dev_t dev; int mode; int flag;)
263:
264: #define COH_READ(name,s) \
265: __LOCAL__ int __CONCAT3 (name, read, s) \
266: DEF ((o_dev_t dev, IO * iop), \
267: (dev, iop) o_dev_t dev; IO * iop;)
268:
269: #define COH_WRITE(name,s) \
270: __LOCAL__ int __CONCAT3 (name, write, s) \
271: DEF ((o_dev_t dev, IO * iop), \
272: (dev, iop) o_dev_t dev; IO * iop;)
273:
274: #define COH_IOCTL(name,s) \
275: __LOCAL__ int __CONCAT3 (name, ioctl, s) \
276: DEF ((o_dev_t dev, int cmd, _VOID * arg, int mode), \
277: (dev, cmd, arg, mode) \
278: o_dev_t dev; int cmd; _VOID * arg; int mode;)
279:
280: #define COH_STRATEGY(name,s) \
281: __LOCAL__ int __CONCAT3 (name, strategy, s) \
282: DEF ((BUF * buf), \
283: (buf) BUF * buf;)
284:
285: #define COH_CHPOLL(name,s) \
286: __LOCAL__ int __CONCAT3 (name, chpoll, s) \
287: DEF ((o_dev_t dev, int events, int msec), \
288: (dev, events, msec) o_dev_t dev; int events; int msec;)
289:
290: #define DECLARE_STREAMS(name) \
291: extern struct streamtab __INFO (name); \
292: COH_OPEN (name, S) { \
293: return _streams_open (dev, mode, flag, & __INFO (name)); \
294: } \
295: COH_CLOSE (name, S) { \
296: return _streams_close (dev, mode, flag, & __INFO (name)); \
297: } \
298: COH_READ (name, S) { \
299: return _streams_read (dev, iop, & __INFO (name)); \
300: } \
301: COH_WRITE (name, S) { \
302: return _streams_write (dev, iop, & __INFO (name)); \
303: } \
304: COH_IOCTL (name, S) { \
305: return _streams_ioctl (dev, cmd, arg, mode, & __INFO (name));\
306: } \
307: COH_CHPOLL (name, S) { \
308: return _streams_chpoll (dev, events, msec, & __INFO (name)); \
309: }
310:
311: #define DECLARE_OPEN(name) \
312: COH_OPEN (name,D) { \
313: EXTERN_OPEN (name); \
314: return _forward_open (dev, mode, flag, __OPEN (name)); \
315: }
316:
317: #define DECLARE_CLOSE(name) \
318: COH_CLOSE (name,D) { \
319: EXTERN_CLOSE (name); \
320: return _forward_close (dev, mode, flag, __CLOSE (name)); \
321: }
322:
323: #define DECLARE_READ(name) \
324: COH_READ (name,D) { \
325: EXTERN_READ (name); \
326: return _forward_read (dev, iop, __READ (name)); \
327: }
328:
329: #define DECLARE_WRITE(name) \
330: COH_WRITE (name,D) { \
331: EXTERN_WRITE (name); \
332: return _forward_write (dev, iop, __WRITE (name)); \
333: }
334:
335: #define DECLARE_IOCTL(name) \
336: COH_IOCTL (name,D) { \
337: EXTERN_IOCTL (name); \
338: return _forward_ioctl (dev, cmd, arg, mode, __IOCTL (name)); \
339: }
340:
341: #define DECLARE_STRATEGY(name) \
342: COH_STRATEGY (name,D) { \
343: EXTERN_STRATEGY (name); \
344: return _forward_strategy (buf, __STRATEGY (name)); \
345: }
346:
347: #define DECLARE_CHPOLL(name) \
348: COH_CHPOLL (name,D) { \
349: EXTERN_CHPOLL (name); \
350: return _forward_chpoll (dev, events, msec, __CHPOLL (name)); \
351: }
352:
353: #define OPEN(name) __CONCAT (name, openD)
354: #define CLOSE(name) __CONCAT (name, closeD)
355: #define READ(name) __CONCAT (name, readD)
356: #define WRITE(name) __CONCAT (name, writeD)
357: #define IOCTL(name) __CONCAT (name, ioctlD)
358: #define STRATEGY(name) __CONCAT (name, strategyD)
359: #define CHPOLL(name) __CONCAT (name, chpollD)
360:
361: #endif /* __COHERENT__ || defined (__MSDOS__) */
362:
363:
364: /*
365: * Now default definitions for those things that are not overridden above.
366: */
367:
368: #if ! defined (DECLARE_STREAMS)
369: # define DECLARE_STREAMS(name) extern struct streamtab __INFO (name);
370: #endif
371:
372: #if ! defined (DECLARE_MODULE)
373: # define DECLARE_MODULE(name) extern struct streamtab __INFO (name);
374: #endif
375:
376: #if ! defined (DECLARE_OPEN) || ! defined (OPEN)
377: # define DECLARE_OPEN(name) EXTERN_OPEN (name);
378: # define OPEN(name) __OPEN (name)
379: #endif
380:
381: #if ! defined (DECLARE_CLOSE) || ! defined (CLOSE)
382: # define DECLARE_CLOSE(name) EXTERN_CLOSE (name);
383: # define CLOSE(name) __CLOSE (name)
384: #endif
385:
386: #if ! defined (DECLARE_READ) || ! defined (READ)
387: # define DECLARE_READ(name) EXTERN_READ (name);
388: # define READ(name) __READ (name)
389: #endif
390:
391: #if ! defined (DECLARE_WRITE) || ! defined (WRITE)
392: # define DECLARE_WRITE(name) EXTERN_WRITE (name);
393: # define WRITE(name) __WRITE (name)
394: #endif
395:
396: #if ! defined (DECLARE_IOCTL) || ! defined (IOCTL)
397: # define DECLARE_IOCTL(name) EXTERN_IOCTL (name);
398: # define IOCTL(name) __IOCTL (name)
399: #endif
400:
401: #if ! defined (DECLARE_CHPOLL) || ! defined (CHPOLL)
402: # define DECLARE_CHPOLL(name) EXTERN_CHPOLL (name);
403: # define CHPOLL(name) __CHPOLL (name)
404: #endif
405:
406: #if ! defined (DECLARE_MMAP) || ! defined (MMAP)
407: # define DECLARE_MMAP(name) EXTERN_MMAP (name);
408: # define MMAP(name) __MMAP (name)
409: #endif
410:
411: #if ! defined (DECLARE_STRATEGY) || ! defined (STRATEGY)
412: # define DECLARE_STRATEGY(name) EXTERN_STRATEGY (name);
413: # define STRATEGY(name) __STRATEGY (name)
414: #endif
415:
416: #if ! defined (DECLARE_PRINT) || ! defined (PRINT)
417: # define DECLARE_PRINT(name) EXTERN_PRINT (name);
418: # define PRINT(name) __PRINT (name)
419: #endif
420:
421: #if ! defined (DECLARE_SIZE) || ! defined (SIZE)
422: # define DECLARE_SIZE(name) EXTERN_SIZE (name);
423: # define SIZE(name) __SIZE (name)
424: #endif
425:
426: #if ! defined (DECLARE_INTR) || ! defined (INTR)
427: # define DECLARE_INTR(name) EXTERN_INTR (name);
428: # define INTR(name) __INTR (name)
429: #endif
430:
431: #if ! defined (DECLARE_INIT) || ! defined (INIT)
432: # define DECLARE_INIT(name) EXTERN_INIT (name);
433: # define INIT(name) __INIT (name)
434: #endif
435:
436: #if ! defined (DECLARE_START) || ! defined (START)
437: # define DECLARE_START(name) EXTERN_START (name);
438: # define START(name) __START (name)
439: #endif
440:
441: #if ! defined (DECLARE_EXIT) || ! defined (EXIT)
442: # define DECLARE_EXIT(name) EXTERN_EXIT (name);
443: # define EXIT(name) __EXIT (name)
444: #endif
445:
446: #if ! defined (DECLARE_HALT) || ! defined (HALT)
447: # define DECLARE_HALT(name) EXTERN_HALT (name);
448: # define HALT(name) __EXIT (halt)
449: #endif
450:
451: #ifndef CDEVSW_ENTRY
452:
453: typedef struct {
454: int * cdev_flag;
455: struct streamtab
456: * cdev_stream;
457: ddi_open_t cdev_open;
458: ddi_close_t cdev_close;
459: ddi_read_t cdev_read;
460: ddi_write_t cdev_write;
461: ddi_ioctl_t cdev_ioctl;
462: ddi_chpoll_t cdev_chpoll;
463: ddi_mmap_t cdev_mmap;
464: } cdevsw_t;
465:
466: #define CDEVSW_ENTRY(fl,op,cl,re,wr,io,ch,mm) \
467: { (fl), 0, (op), (cl), (re), (wr), (io), (ch), (mm) }
468:
469: #define STREAMS_ENTRY(name) \
470: { & __DEVFLAG (name), & __INFO (name), 0, 0, 0, 0, 0, 0 }
471:
472: #define NULL_CDEVSW() \
473: { 0, 0, 0, 0, 0, 0, 0, 0 }
474:
475: #endif /* ! defined (CDEVSW_ENTRY) */
476:
477: #ifndef BDEVSW_ENTRY
478:
479: typedef struct {
480: int * bdev_flag;
481: ddi_open_t bdev_open;
482: ddi_close_t bdev_close;
483: ddi_strategy_t bdev_strategy;
484: ddi_print_t bdev_print;
485: ddi_size_t bdev_size;
486: } bdevsw_t;
487:
488: #define BDEVSW_ENTRY(fl,op,cl,st,pr,si) \
489: { (fl), (op), (cl), (st), (pr), (si) }
490:
491: #define NULL_BDEVSW() \
492: { 0, 0, 0, 0, 0, 0 }
493:
494: #endif /* ! defined (BDEVSW_ENTRY) */
495:
496:
497: #ifndef MODSW_ENTRY
498:
499: typedef struct {
500: int * mod_flag;
501: struct streamtab
502: * mod_stream;
503: } modsw_t;
504:
505: #define MODSW_ENTRY(name) { & __DEVFLAG (name), & __INFO (name) }
506:
507: #define NULL_MODSW() { 0, 0 }
508:
509: #endif /* ! defined (MODSW_ENTRY) */
510:
511:
512: #define __VECTOR(vec) __CONCAT (vector, vec)
513: #define __PREV(vec) __CONCAT3 (vector, vec, _prev)
514:
515:
516: #ifdef __BORLANDC__
517:
518: /*
519: * Under MS-DOS, we have to avoid disrupting the existing software. That means
520: * we have to take care to chain to the appropriate previous handlers; given
521: * that Borland C++ has support for this, interrupts under C++ are supported
522: * using native facilities rather than a generic trap layer. A generic trap
523: * layer should be doing similar things, of course.
524: */
525:
526: typedef interrupt void (* intthunk_t) __PROTO ((__ANY_ARGS__));
527:
528: __EXTERN_C_BEGIN__
529:
530: void _chain_intr (intthunk_t _prev_int); /* Borland C++ library */
531: void CHECK_DEFER (void);
532:
533: __EXTERN_C_END__
534:
535:
536: typedef struct {
537: int int_vector;
538: intthunk_t int_thunk;
539: intthunk_t * int_prev;
540: } intr_t;
541:
542: #define BEGIN_THUNK(vec,mask) \
543: __LOCAL__ intthunk_t __PREV (vec); \
544: __LOCAL__ interrupt void __VECTOR (vec) \
545: DEF ((__ANY_ARGS__), __ARGS (())) { \
546: intmask_t oldmask = __GET_BASE_MASK (); \
547: pl_t prev_pl; \
548: if (__PREV (vec) != 0) \
549: (* __PREV (vec)) (); \
550: __SET_BASE_MASK (oldmask | (mask)); \
551: ddi_cpu_data ()->dc_int_level ++; \
552: prev_pl = spltimeout (); \
553: __SEND_EOI (vec); \
554: __CHEAP_ENABLE_INTS ();
555:
556: #define CALL_INTR(vec,name) (void) __INTR (name) (vec);
557:
558: #define END_THUNK(vec) \
559: __CHEAP_DISABLE_INTS (); \
560: __SET_BASE_MASK (oldmask); \
561: splx (prev_pl); \
562: if (ddi_cpu_data ()->dc_int_level == 1 && \
563: ddi_cpu_data ()->dc_ipl == plbase) \
564: CHECK_DEFER (); \
565: ddi_cpu_data ()->dc_int_level --; \
566: }
567:
568: #define INTR_THUNK(vec) { vec, __VECTOR (vec), & __PREV (vec) }
569:
570: #else
571:
572: typedef void (* intthunk_t) __PROTO ((__ANY_ARGS__));
573:
574: typedef struct {
575: int int_vector;
576: intthunk_t int_thunk;
577: } intr_t;
578:
579: #define BEGIN_THUNK(vec,mask) \
580: __LOCAL__ void __VECTOR (vec) \
581: DEF ((void), __ARGS (())) { \
582: intmask_t oldmask = __GET_BASE_MASK (); \
583: __SET_BASE_MASK (oldmask | (mask)); \
584: ddi_cpu_data ()->dc_int_level ++;
585:
586: #define CALL_INTR(vec,name) (void) __INTR (name) (vec);
587:
588: #define END_THUNK(vec) \
589: ddi_cpu_data ()->dc_int_level --; \
590: __SET_BASE_MASK (oldmask); \
591: }
592:
593: #define INTR_THUNK(vec) { vec, __VECTOR (vec) }
594:
595: #endif
596:
597:
598: typedef ddi_init_t init_t;
599: typedef ddi_start_t start_t;
600: typedef ddi_exit_t exit_t;
601: typedef ddi_halt_t halt_t;
602:
603: extern init_t inittab [];
604: extern unsigned int ninit;
605:
606: extern start_t starttab [];
607: extern unsigned int nstart;
608:
609: extern exit_t exittab [];
610: extern unsigned int nexit;
611:
612: extern halt_t halttab [];
613: extern unsigned int nhalt;
614:
615: extern cdevsw_t cdevsw [];
616: extern unsigned int ncdevsw;
617:
618: extern bdevsw_t bdevsw [];
619: extern unsigned int nbdevsw;
620:
621: extern modsw_t modsw [];
622: extern unsigned int nmodsw;
623:
624: extern major_t _maxmajor;
625: extern major_t _major [];
626: extern minor_t _minor [];
627:
628: extern intr_t inttab [];
629: extern unsigned int nintr;
630:
631: #endif /* ! defined (__KERNEL_CONFINFO_H__) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.