![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spec_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / miscfs / specfs|
Return to spec_vnops.c CVS log | Up to [Net/2] / Net2 / miscfs / specfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)spec_vnops.c 7.37 (Berkeley) 5/30/91 ! 34: * ! 35: * PATCHES MAGIC LEVEL PATCH THAT GOT US HERE ! 36: * -------------------- ----- ---------------------- ! 37: * CURRENT PATCH LEVEL: 1 00007 ! 38: * -------------------- ----- ---------------------- ! 39: * ! 40: * 20 Aug 92 David Greenman Fixed incorrect setting of B_AGE on ! 41: */ ! 42: ! 43: #include "param.h" ! 44: #include "proc.h" ! 45: #include "systm.h" ! 46: #include "kernel.h" ! 47: #include "conf.h" ! 48: #include "buf.h" ! 49: #include "mount.h" ! 50: #include "namei.h" ! 51: #include "vnode.h" ! 52: #include "specdev.h" ! 53: #include "stat.h" ! 54: #include "errno.h" ! 55: #include "ioctl.h" ! 56: #include "file.h" ! 57: #include "dkbad.h" /* XXX */ ! 58: #include "disklabel.h" ! 59: ! 60: /* symbolic sleep message strings for devices */ ! 61: char devopn[] = "devopn"; ! 62: char devio[] = "devio"; ! 63: char devwait[] = "devwait"; ! 64: char devin[] = "devin"; ! 65: char devout[] = "devout"; ! 66: char devioc[] = "devioc"; ! 67: char devcls[] = "devcls"; ! 68: ! 69: struct vnodeops spec_vnodeops = { ! 70: spec_lookup, /* lookup */ ! 71: spec_create, /* create */ ! 72: spec_mknod, /* mknod */ ! 73: spec_open, /* open */ ! 74: spec_close, /* close */ ! 75: spec_access, /* access */ ! 76: spec_getattr, /* getattr */ ! 77: spec_setattr, /* setattr */ ! 78: spec_read, /* read */ ! 79: spec_write, /* write */ ! 80: spec_ioctl, /* ioctl */ ! 81: spec_select, /* select */ ! 82: spec_mmap, /* mmap */ ! 83: spec_fsync, /* fsync */ ! 84: spec_seek, /* seek */ ! 85: spec_remove, /* remove */ ! 86: spec_link, /* link */ ! 87: spec_rename, /* rename */ ! 88: spec_mkdir, /* mkdir */ ! 89: spec_rmdir, /* rmdir */ ! 90: spec_symlink, /* symlink */ ! 91: spec_readdir, /* readdir */ ! 92: spec_readlink, /* readlink */ ! 93: spec_abortop, /* abortop */ ! 94: spec_inactive, /* inactive */ ! 95: spec_reclaim, /* reclaim */ ! 96: spec_lock, /* lock */ ! 97: spec_unlock, /* unlock */ ! 98: spec_bmap, /* bmap */ ! 99: spec_strategy, /* strategy */ ! 100: spec_print, /* print */ ! 101: spec_islocked, /* islocked */ ! 102: spec_advlock, /* advlock */ ! 103: }; ! 104: ! 105: /* ! 106: * Trivial lookup routine that always fails. ! 107: */ ! 108: spec_lookup(vp, ndp, p) ! 109: struct vnode *vp; ! 110: struct nameidata *ndp; ! 111: struct proc *p; ! 112: { ! 113: ! 114: ndp->ni_dvp = vp; ! 115: ndp->ni_vp = NULL; ! 116: return (ENOTDIR); ! 117: } ! 118: ! 119: /* ! 120: * Open a special file: Don't allow open if fs is mounted -nodev, ! 121: * and don't allow opens of block devices that are currently mounted. ! 122: * Otherwise, call device driver open function. ! 123: */ ! 124: /* ARGSUSED */ ! 125: spec_open(vp, mode, cred, p) ! 126: register struct vnode *vp; ! 127: int mode; ! 128: struct ucred *cred; ! 129: struct proc *p; ! 130: { ! 131: dev_t dev = (dev_t)vp->v_rdev; ! 132: register int maj = major(dev); ! 133: int error; ! 134: ! 135: if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV)) ! 136: return (ENXIO); ! 137: ! 138: switch (vp->v_type) { ! 139: ! 140: case VCHR: ! 141: if ((u_int)maj >= nchrdev) ! 142: return (ENXIO); ! 143: VOP_UNLOCK(vp); ! 144: error = (*cdevsw[maj].d_open)(dev, mode, S_IFCHR, p); ! 145: VOP_LOCK(vp); ! 146: return (error); ! 147: ! 148: case VBLK: ! 149: if ((u_int)maj >= nblkdev) ! 150: return (ENXIO); ! 151: if (error = mountedon(vp)) ! 152: return (error); ! 153: return ((*bdevsw[maj].d_open)(dev, mode, S_IFBLK, p)); ! 154: } ! 155: return (0); ! 156: } ! 157: ! 158: /* ! 159: * Vnode op for read ! 160: */ ! 161: /* ARGSUSED */ ! 162: spec_read(vp, uio, ioflag, cred) ! 163: register struct vnode *vp; ! 164: register struct uio *uio; ! 165: int ioflag; ! 166: struct ucred *cred; ! 167: { ! 168: struct proc *p = uio->uio_procp; ! 169: struct buf *bp; ! 170: daddr_t bn; ! 171: long bsize, bscale; ! 172: struct partinfo dpart; ! 173: register int n, on; ! 174: int error = 0; ! 175: extern int mem_no; ! 176: ! 177: #ifdef DIAGNOSTIC ! 178: if (uio->uio_rw != UIO_READ) ! 179: panic("spec_read mode"); ! 180: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) ! 181: panic("spec_read proc"); ! 182: #endif ! 183: if (uio->uio_resid == 0) ! 184: return (0); ! 185: ! 186: switch (vp->v_type) { ! 187: ! 188: case VCHR: ! 189: /* ! 190: * Negative offsets allowed only for /dev/kmem ! 191: */ ! 192: if (uio->uio_offset < 0 && major(vp->v_rdev) != mem_no) ! 193: return (EINVAL); ! 194: VOP_UNLOCK(vp); ! 195: error = (*cdevsw[major(vp->v_rdev)].d_read) ! 196: (vp->v_rdev, uio, ioflag); ! 197: VOP_LOCK(vp); ! 198: return (error); ! 199: ! 200: case VBLK: ! 201: if (uio->uio_offset < 0) ! 202: return (EINVAL); ! 203: bsize = BLKDEV_IOSIZE; ! 204: if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART, ! 205: (caddr_t)&dpart, FREAD, p) == 0) { ! 206: if (dpart.part->p_fstype == FS_BSDFFS && ! 207: dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) ! 208: bsize = dpart.part->p_frag * ! 209: dpart.part->p_fsize; ! 210: } ! 211: bscale = bsize / DEV_BSIZE; ! 212: do { ! 213: bn = (uio->uio_offset / DEV_BSIZE) &~ (bscale - 1); ! 214: on = uio->uio_offset % bsize; ! 215: n = MIN((unsigned)(bsize - on), uio->uio_resid); ! 216: if (vp->v_lastr + bscale == bn) ! 217: error = breada(vp, bn, (int)bsize, bn + bscale, ! 218: (int)bsize, NOCRED, &bp); ! 219: else ! 220: error = bread(vp, bn, (int)bsize, NOCRED, &bp); ! 221: vp->v_lastr = bn; ! 222: n = MIN(n, bsize - bp->b_resid); ! 223: if (error) { ! 224: brelse(bp); ! 225: return (error); ! 226: } ! 227: error = uiomove(bp->b_un.b_addr + on, n, uio); ! 228: #ifdef OMIT /* 20 Aug 92*/ ! 229: if (n + on == bsize) ! 230: bp->b_flags |= B_AGE; ! 231: #endif /* OMIT*/ ! 232: brelse(bp); ! 233: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 234: return (error); ! 235: ! 236: default: ! 237: panic("spec_read type"); ! 238: } ! 239: /* NOTREACHED */ ! 240: } ! 241: ! 242: /* ! 243: * Vnode op for write ! 244: */ ! 245: /* ARGSUSED */ ! 246: spec_write(vp, uio, ioflag, cred) ! 247: register struct vnode *vp; ! 248: register struct uio *uio; ! 249: int ioflag; ! 250: struct ucred *cred; ! 251: { ! 252: struct proc *p = uio->uio_procp; ! 253: struct buf *bp; ! 254: daddr_t bn; ! 255: int bsize, blkmask; ! 256: struct partinfo dpart; ! 257: register int n, on; ! 258: int error = 0; ! 259: extern int mem_no; ! 260: ! 261: #ifdef DIAGNOSTIC ! 262: if (uio->uio_rw != UIO_WRITE) ! 263: panic("spec_write mode"); ! 264: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) ! 265: panic("spec_write proc"); ! 266: #endif ! 267: ! 268: switch (vp->v_type) { ! 269: ! 270: case VCHR: ! 271: /* ! 272: * Negative offsets allowed only for /dev/kmem ! 273: */ ! 274: if (uio->uio_offset < 0 && major(vp->v_rdev) != mem_no) ! 275: return (EINVAL); ! 276: VOP_UNLOCK(vp); ! 277: error = (*cdevsw[major(vp->v_rdev)].d_write) ! 278: (vp->v_rdev, uio, ioflag); ! 279: VOP_LOCK(vp); ! 280: return (error); ! 281: ! 282: case VBLK: ! 283: if (uio->uio_resid == 0) ! 284: return (0); ! 285: if (uio->uio_offset < 0) ! 286: return (EINVAL); ! 287: bsize = BLKDEV_IOSIZE; ! 288: if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART, ! 289: (caddr_t)&dpart, FREAD, p) == 0) { ! 290: if (dpart.part->p_fstype == FS_BSDFFS && ! 291: dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) ! 292: bsize = dpart.part->p_frag * ! 293: dpart.part->p_fsize; ! 294: } ! 295: blkmask = (bsize / DEV_BSIZE) - 1; ! 296: do { ! 297: bn = (uio->uio_offset / DEV_BSIZE) &~ blkmask; ! 298: on = uio->uio_offset % bsize; ! 299: n = MIN((unsigned)(bsize - on), uio->uio_resid); ! 300: if (n == bsize) ! 301: bp = getblk(vp, bn, bsize); ! 302: else ! 303: error = bread(vp, bn, bsize, NOCRED, &bp); ! 304: n = MIN(n, bsize - bp->b_resid); ! 305: if (error) { ! 306: brelse(bp); ! 307: return (error); ! 308: } ! 309: error = uiomove(bp->b_un.b_addr + on, n, uio); ! 310: if (n + on == bsize) { ! 311: bp->b_flags |= B_AGE; ! 312: bawrite(bp); ! 313: } else ! 314: bdwrite(bp); ! 315: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 316: return (error); ! 317: ! 318: default: ! 319: panic("spec_write type"); ! 320: } ! 321: /* NOTREACHED */ ! 322: } ! 323: ! 324: /* ! 325: * Device ioctl operation. ! 326: */ ! 327: /* ARGSUSED */ ! 328: spec_ioctl(vp, com, data, fflag, cred, p) ! 329: struct vnode *vp; ! 330: int com; ! 331: caddr_t data; ! 332: int fflag; ! 333: struct ucred *cred; ! 334: struct proc *p; ! 335: { ! 336: dev_t dev = vp->v_rdev; ! 337: ! 338: switch (vp->v_type) { ! 339: ! 340: case VCHR: ! 341: return ((*cdevsw[major(dev)].d_ioctl)(dev, com, data, ! 342: fflag, p)); ! 343: ! 344: case VBLK: ! 345: if (com == 0 && (int)data == B_TAPE) ! 346: if (bdevsw[major(dev)].d_flags & B_TAPE) ! 347: return (0); ! 348: else ! 349: return (1); ! 350: return ((*bdevsw[major(dev)].d_ioctl)(dev, com, data, ! 351: fflag, p)); ! 352: ! 353: default: ! 354: panic("spec_ioctl"); ! 355: /* NOTREACHED */ ! 356: } ! 357: } ! 358: ! 359: /* ARGSUSED */ ! 360: spec_select(vp, which, fflags, cred, p) ! 361: struct vnode *vp; ! 362: int which, fflags; ! 363: struct ucred *cred; ! 364: struct proc *p; ! 365: { ! 366: register dev_t dev; ! 367: ! 368: switch (vp->v_type) { ! 369: ! 370: default: ! 371: return (1); /* XXX */ ! 372: ! 373: case VCHR: ! 374: dev = vp->v_rdev; ! 375: return (*cdevsw[major(dev)].d_select)(dev, which, p); ! 376: } ! 377: } ! 378: ! 379: /* ! 380: * Just call the device strategy routine ! 381: */ ! 382: spec_strategy(bp) ! 383: register struct buf *bp; ! 384: { ! 385: ! 386: (*bdevsw[major(bp->b_dev)].d_strategy)(bp); ! 387: return (0); ! 388: } ! 389: ! 390: /* ! 391: * This is a noop, simply returning what one has been given. ! 392: */ ! 393: spec_bmap(vp, bn, vpp, bnp) ! 394: struct vnode *vp; ! 395: daddr_t bn; ! 396: struct vnode **vpp; ! 397: daddr_t *bnp; ! 398: { ! 399: ! 400: if (vpp != NULL) ! 401: *vpp = vp; ! 402: if (bnp != NULL) ! 403: *bnp = bn; ! 404: return (0); ! 405: } ! 406: ! 407: /* ! 408: * At the moment we do not do any locking. ! 409: */ ! 410: /* ARGSUSED */ ! 411: spec_lock(vp) ! 412: struct vnode *vp; ! 413: { ! 414: ! 415: return (0); ! 416: } ! 417: ! 418: /* ARGSUSED */ ! 419: spec_unlock(vp) ! 420: struct vnode *vp; ! 421: { ! 422: ! 423: return (0); ! 424: } ! 425: ! 426: /* ! 427: * Device close routine ! 428: */ ! 429: /* ARGSUSED */ ! 430: spec_close(vp, flag, cred, p) ! 431: register struct vnode *vp; ! 432: int flag; ! 433: struct ucred *cred; ! 434: struct proc *p; ! 435: { ! 436: dev_t dev = vp->v_rdev; ! 437: int (*devclose) __P((dev_t, int, int, struct proc *)); ! 438: int mode; ! 439: ! 440: switch (vp->v_type) { ! 441: ! 442: case VCHR: ! 443: /* ! 444: * If the vnode is locked, then we are in the midst ! 445: * of forcably closing the device, otherwise we only ! 446: * close on last reference. ! 447: */ ! 448: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) ! 449: return (0); ! 450: devclose = cdevsw[major(dev)].d_close; ! 451: mode = S_IFCHR; ! 452: break; ! 453: ! 454: case VBLK: ! 455: /* ! 456: * On last close of a block device (that isn't mounted) ! 457: * we must invalidate any in core blocks, so that ! 458: * we can, for instance, change floppy disks. ! 459: */ ! 460: vflushbuf(vp, 0); ! 461: if (vinvalbuf(vp, 1)) ! 462: return (0); ! 463: /* ! 464: * We do not want to really close the device if it ! 465: * is still in use unless we are trying to close it ! 466: * forcibly. Since every use (buffer, vnode, swap, cmap) ! 467: * holds a reference to the vnode, and because we mark ! 468: * any other vnodes that alias this device, when the ! 469: * sum of the reference counts on all the aliased ! 470: * vnodes descends to one, we are on last close. ! 471: */ ! 472: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) ! 473: return (0); ! 474: devclose = bdevsw[major(dev)].d_close; ! 475: mode = S_IFBLK; ! 476: break; ! 477: ! 478: default: ! 479: panic("spec_close: not special"); ! 480: } ! 481: ! 482: return ((*devclose)(dev, flag, mode, p)); ! 483: } ! 484: ! 485: /* ! 486: * Print out the contents of a special device vnode. ! 487: */ ! 488: spec_print(vp) ! 489: struct vnode *vp; ! 490: { ! 491: ! 492: printf("tag VT_NON, dev %d, %d\n", major(vp->v_rdev), ! 493: minor(vp->v_rdev)); ! 494: } ! 495: ! 496: /* ! 497: * Special device advisory byte-level locks. ! 498: */ ! 499: /* ARGSUSED */ ! 500: spec_advlock(vp, id, op, fl, flags) ! 501: struct vnode *vp; ! 502: caddr_t id; ! 503: int op; ! 504: struct flock *fl; ! 505: int flags; ! 506: { ! 507: ! 508: return (EOPNOTSUPP); ! 509: } ! 510: ! 511: /* ! 512: * Special device failed operation ! 513: */ ! 514: spec_ebadf() ! 515: { ! 516: ! 517: return (EBADF); ! 518: } ! 519: ! 520: /* ! 521: * Special device bad operation ! 522: */ ! 523: spec_badop() ! 524: { ! 525: ! 526: panic("spec_badop called"); ! 527: /* NOTREACHED */ ! 528: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.