![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddi_drv.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 / streams / src|
Return to ddi_drv.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV3 1
3:
4: /*
5: * This file contains supplementary definitions used to deal with or aid the
6: * implementation of the automatically generated device configuration code
7: * in the "conf.c" file.
8: *
9: * Note that we are in the _SYSV3 world because we touch <sys/uproc.h>
10: */
11: /*
12: *-IMPORTS:
13: * <common/ccompat.h>
14: * __USE_PROTO__
15: * __ARGS ()
16: * <common/xdebug.h>
17: * __LOCAL__
18: * <sys/debug.h>
19: * ASSERT ()
20: * <sys/types.h>
21: * cred_t
22: * n_dev_t
23: * o_dev_t
24: * makedevice ()
25: * <sys/cmn_err.h>
26: * CE_PANIC
27: * cmn_err ()
28: * <sys/file.h>
29: * FREAD
30: * FWRITE
31: * FNDELAY
32: * FNONBLOCK
33: * FEXCL
34: * <sys/open.h>
35: * OTYP_BLK
36: * OTYP_CHR
37: * OTYP_LYR
38: * <sys/uio.h>
39: * iovec_t
40: * uio_t
41: * <stddef.h>
42: * NULL
43: * <sys/errno.h>
44: * ENXIO
45: */
46:
47: #include <common/ccompat.h>
48: #include <common/xdebug.h>
49: #include <kernel/strmlib.h>
50: #include <sys/debug.h>
51: #include <sys/types.h>
52: #include <sys/cmn_err.h>
53: #include <sys/file.h>
54: #include <sys/open.h>
55: #include <sys/errno.h>
56: #include <sys/uio.h>
57: #include <stddef.h>
58:
59: #include <sys/confinfo.h>
60: #include <kernel/ddi_base.h>
61:
62: /*
63: * These are Coherent header files! Treat with all the caution you would
64: * normally use for handling toxic waste!
65: *
66: * <sys/stat.h>
67: * major ()
68: * minor ()
69: * <sys/con.h>
70: * DFBLK
71: *
72: * The following values which used to be in Coherent <sys/inode.h> have been
73: * moved here so we can use them. <sys/inode.h> is too much of a mess.
74: *
75: * <sys/file.h>
76: * IPR
77: * IPW
78: * IPNDLY
79: * IPEXCL
80: *
81: * Note that the actual magic u area variable 'u' is extern'ed in
82: * <kernel/ddi_base.h>
83: */
84:
85: #include <sys/stat.h>
86:
87: #if __COHERENT__
88:
89: #define SETUERROR(e) u.u_error = (e)
90:
91: #else
92:
93: #define SETUERROR(e) ASSERT (e == 0 || "Hit error" == NULL)
94:
95: #endif
96:
97:
98: /*
99: * This function initialises a cred_t structure from Coherent's internal data
100: * structures. This function would normally be local, but it is also called
101: * upon by code in "drv_ddi.c" to implement the drv_getparm () and
102: * drv_setparm () utilities, and also by the STREAMS equivalent to the
103: * character-driver interface routines.
104: */
105:
106: #if __USE_PROTO__
107: cred_t * (MAKE_CRED) (cred_t * credp)
108: #else
109: cred_t *
110: MAKE_CRED __ARGS ((credp))
111: cred_t * credp;
112: #endif
113: {
114: credp->cr_ref = 1;
115: credp->cr_ngroups = 0; /* no supplementary groups */
116:
117: #ifdef __MSDOS__
118: credp->cr_uid = credp->cr_ruid = credp->cr_suid = 0;
119: credp->cr_gid = credp->cr_rgid = credp->cr_sgid = 0;
120: #else
121: credp->cr_uid = u.u_uid;
122: credp->cr_gid = u.u_gid;
123: credp->cr_ruid = u.u_ruid;
124: credp->cr_rgid = u.u_rgid;
125: credp->cr_suid = u.u_euid; /* u.u_euid is saved effective uid */
126: credp->cr_sgid = u.u_egid; /* u.u_egid is saved effective gid */
127: #endif
128: return credp;
129: }
130:
131:
132: /*
133: * This local function is called to build a "uio_t" structure from Coherent's
134: * UIO structure. This function would be local, but it is called by the
135: * STREAMS equivalent of the mapping routines.
136: */
137:
138: #if __USE_PROTO__
139: uio_t * (MAKE_UIO) (uio_t * uiop, iovec_t * iovp, int mode, IO * iop)
140: #else
141: uio_t *
142: MAKE_UIO __ARGS ((uiop, iovp, mode, iop))
143: uio_t * uiop;
144: iovec_t * iovp;
145: int mode;
146: IO * iop;
147: #endif
148: {
149: uiop->uio_iov = iovp;
150: uiop->uio_iovcnt = 1;
151: uiop->uio_offset = iop->io_seek;
152: uiop->uio_segflg = iop->io_seg == IOSYS ? UIO_SYSSPACE : UIO_USERSPACE;
153: uiop->uio_fmode = mode | ((iop->io_flag & IONDLY) != 0 ? FNDELAY : 0);
154: uiop->uio_resid = iop->io_ioc;
155:
156: #ifdef _I386
157: iovp->iov_base = iop->io.vbase;
158: #else
159: iovp->iov_base = iop->io_base;
160: #endif
161: iovp->iov_len = iop->io_ioc;
162:
163: return uiop;
164: }
165:
166:
167: /*
168: * This function is used to copy back the information from a "uio_t" structure
169: * into a Coherent IO structure.
170: */
171:
172: #if __USE_PROTO__
173: void (DESTROY_UIO) (uio_t * uiop, IO * iop)
174: #else
175: void
176: DESTROY_UIO __ARGS ((uiop, iop))
177: uio_t * uiop;
178: IO * iop;
179: #endif
180: {
181: ASSERT (uiop->uio_iov != NULL);
182: ASSERT (uiop->uio_iov->iov_len == uiop->uio_resid);
183:
184: iop->io_ioc = uiop->uio_resid;
185: iop->io_seek = uiop->uio_offset;
186: #ifdef _I386
187: iop->io.vbase = uiop->uio_iov->iov_base;
188: #else
189: iop->io_base = uiop->uio_iov->iov_base;
190: #endif
191: }
192:
193:
194: /*
195: * This function is called upon by the machine-generated code in "conf.c" to
196: * forward a Coherent device open request to a System V device.
197: */
198:
199: #if __USE_PROTO__
200: int (_forward_open) (o_dev_t dev, int mode, int flags, ddi_open_t funcp)
201: #else
202: int
203: _forward_open __ARGS ((dev, mode, flags, funcp))
204: o_dev_t dev;
205: int mode;
206: int flags;
207: ddi_open_t funcp;
208: #endif
209: {
210: n_dev_t newdev = makedevice (major (dev), minor (dev));
211: cred_t cred;
212: int newmode;
213: int ret;
214:
215: newmode = 0;
216:
217: /*
218: * These are the flags documented by the Coherent driver kit. In
219: * actual fact, there are more (corresponding to the DDI/DKI flags)
220: * that are passed down from the system file table's flag entry. The
221: * fact that the others are not documented probably reflects the fact
222: * that calls to dread () either pass only IPR or IPW directly, while
223: * the existence of the other flags can only be discovered by tracing
224: * many layers of calls.
225: */
226:
227: if ((mode & IPR) != 0)
228: newmode |= FREAD;
229: if ((mode & IPW) != 0)
230: newmode |= FWRITE;
231:
232: /*
233: * And the other flags. There is no equivalent for FNONBLOCK.
234: */
235:
236: if ((mode & IPEXCL) != 0)
237: newmode |= FEXCL;
238: if ((mode & IPNDLY) != 0)
239: newmode |= FNDELAY;
240:
241: flags = (flags & DFBLK) != 0 ? OTYP_BLK : OTYP_CHR;
242:
243: ret = (* funcp) (& newdev, newmode, flags, MAKE_CRED (& cred));
244:
245: SETUERROR (ret);
246: return ret;
247: }
248:
249:
250: /*
251: * This function is called upon by the machine-generated code in "conf.c" to
252: * forward a Coherent device close request to a System V device.
253: */
254:
255: #if __USE_PROTO__
256: int (_forward_close) (o_dev_t dev, int mode, int flags, ddi_close_t funcp)
257: #else
258: int
259: _forward_close __ARGS ((dev, mode, flags, funcp))
260: o_dev_t dev;
261: int mode;
262: int flags;
263: ddi_close_t funcp;
264: #endif
265: {
266: n_dev_t newdev = makedevice (major (dev), minor (dev));
267: cred_t cred;
268: int newmode;
269: int ret;
270:
271: newmode = 0;
272:
273: /*
274: * These are the flags documented by the Coherent driver kit. In
275: * actual fact, there are more (corresponding to the DDI/DKI flags)
276: * that are passed down from the system file table's flag entry. The
277: * fact that the others are not documented probably reflects the fact
278: * that calls to dread () either pass only IPR or IPW directly, while
279: * the existence of the other flags can only be discovered by tracing
280: * many layers of calls.
281: */
282:
283: if ((mode & IPR) != 0)
284: newmode |= FREAD;
285: if ((mode & IPW) != 0)
286: newmode |= FWRITE;
287:
288: /*
289: * And the other flags. There is no equivalent for FNONBLOCK.
290: */
291:
292: if ((mode & IPEXCL) != 0)
293: newmode |= FEXCL;
294: if ((mode & IPNDLY) != 0)
295: newmode |= FNDELAY;
296:
297: flags = (flags & DFBLK) != 0 ? OTYP_BLK : OTYP_CHR;
298:
299: ret = (* funcp) (newdev, newmode, flags, MAKE_CRED (& cred));
300:
301: SETUERROR (ret);
302: return ret;
303: }
304:
305:
306: /*
307: * This function is called upon by the machine-generated code in "conf.c" to
308: * forward a Coherent device read request to a System V device.
309: */
310:
311: #if __USE_PROTO__
312: int (_forward_read) (o_dev_t dev, IO * iop, ddi_read_t funcp)
313: #else
314: int
315: _forward_read __ARGS ((dev, iop, funcp))
316: o_dev_t dev;
317: IO * iop;
318: ddi_read_t funcp;
319: #endif
320: {
321: n_dev_t newdev = makedevice (major (dev), minor (dev));
322: cred_t cred;
323: iovec_t iov;
324: uio_t uio;
325: int ret;
326:
327: ret = (* funcp) (newdev, MAKE_UIO (& uio, & iov, FREAD, iop),
328: MAKE_CRED (& cred));
329: DESTROY_UIO (& uio, iop);
330: SETUERROR (ret);
331: return ret;
332: }
333:
334:
335: /*
336: * This function is called upon by the machine-generated code in "conf.c" to
337: * forward a Coherent device write request to a System V device.
338: */
339:
340: #if __USE_PROTO__
341: int (_forward_write) (o_dev_t dev, IO * iop, ddi_write_t funcp)
342: #else
343: int
344: _forward_write __ARGS ((dev, iop, funcp))
345: o_dev_t dev;
346: IO * iop;
347: ddi_write_t funcp;
348: #endif
349: {
350: n_dev_t newdev = makedevice (major (dev), minor (dev));
351: cred_t cred;
352: iovec_t iov;
353: uio_t uio;
354: int ret;
355:
356: ret = (* funcp) (newdev, MAKE_UIO (& uio, & iov, FWRITE, iop),
357: MAKE_CRED (& cred));
358: DESTROY_UIO (& uio, iop);
359: SETUERROR (ret);
360: return ret;
361: }
362:
363:
364: /*
365: * This function is called upon by the machine-generated code in "conf.c" to
366: * forward a Coherent device ioctl request to a System V device.
367: */
368:
369: #if __USE_PROTO__
370: int (_forward_ioctl) (o_dev_t dev, int cmd, _VOID * arg, int mode,
371: ddi_ioctl_t funcp)
372: #else
373: int
374: _forward_ioctl __ARGS ((dev, cmd, arg, mode, funcp))
375: o_dev_t dev;
376: int cmd;
377: _VOID * arg;
378: int mode;
379: ddi_ioctl_t funcp;
380: #endif
381: {
382: n_dev_t newdev = makedevice (major (dev), minor (dev));
383: cred_t cred;
384: int rval;
385: int newmode;
386: int ret;
387:
388: newmode = 0;
389:
390: /*
391: * These are the flags documented by the Coherent driver kit. In
392: * actual fact, there are more (corresponding to the DDI/DKI flags)
393: * that are passed down from the system file table's flag entry. The
394: * fact that the others are not documented probably reflects the fact
395: * that calls to dread () either pass only IPR or IPW directly, while
396: * the existence of the other flags can only be discovered by tracing
397: * many layers of calls.
398: */
399:
400: if ((mode & IPR) != 0)
401: newmode |= FREAD;
402: if ((mode & IPW) != 0)
403: newmode |= FWRITE;
404:
405: /*
406: * And the other flags. There is no equivalent for FNONBLOCK.
407: */
408:
409: if ((mode & IPEXCL) != 0)
410: newmode |= FEXCL;
411: if ((mode & IPNDLY) != 0)
412: newmode |= FNDELAY;
413:
414: ret = (* funcp) (newdev, cmd, arg, mode, MAKE_CRED (& cred), & rval);
415:
416: SETUERROR (ret);
417: return rval;
418: }
419:
420:
421:
422: #if 0
423: /*
424: * This function is called upon by the machine-generated code in "conf.c" to
425: * forward a Coherent device block request to a System V device.
426: */
427:
428: #if __USE_PROTO__
429: int (_forward_strategy) (BUF * buf, ddi_strategy_t funcp)
430: #else
431: int
432: _forward_strategy __ARGS ((buf, funcp))
433: BUF * buf;
434: ddi_strategy_t funcp;
435: #endif
436: {
437: cmn_err (CE_PANIC, "DDI/DKI block drivers not yet supported");
438: }
439: #endif
440:
441:
442: /*
443: * This function is called upon by the machine-generated code in "conf.c" to
444: * forward a Coherent device poll request to a System V device.
445: */
446:
447: #if __USE_PROTO__
448: int (_forward_poll) (o_dev_t dev, int events, int msec, ddi_chpoll_t funcp)
449: #else
450: int
451: _forward_poll __ARGS ((dev, events, msec, funcp))
452: o_dev_t dev;
453: int events;
454: int msec;
455: ddi_chpoll_t funcp;
456: #endif
457: {
458: int ret;
459:
460: cmn_err (CE_PANIC, "DDI/DKI polling not yet supported");
461:
462: #if 0
463: ret = (* funcp) (newdev, events, msec == 0, & revents, pollhead);
464: #else
465: ret = EIO;
466: #endif
467: SETUERROR (ret);
468: return 0;
469: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.