![[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 / f / etc / conf / streams / src|
Return to ddi_drv.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / 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.