![[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 [Apple Darwin 0.x] / kernel / bsd / miscfs / specfs|
Return to spec_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / miscfs / specfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1989, 1993, 1995 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)spec_vnops.c 8.14 (Berkeley) 5/21/95 ! 59: */ ! 60: ! 61: #include <sys/param.h> ! 62: #include <sys/proc.h> ! 63: #include <sys/systm.h> ! 64: #include <sys/kernel.h> ! 65: #include <sys/conf.h> ! 66: #include <sys/buf.h> ! 67: #include <sys/mount.h> ! 68: #include <sys/namei.h> ! 69: #include <sys/vnode.h> ! 70: #include <sys/stat.h> ! 71: #include <sys/errno.h> ! 72: #include <sys/ioctl.h> ! 73: #include <sys/file.h> ! 74: #ifdef NeXT ! 75: #include <sys/malloc.h> ! 76: #include <bsd/dev/disk.h> ! 77: #else ! 78: #include <sys/disklabel.h> ! 79: #endif ! 80: #include <miscfs/specfs/specdev.h> ! 81: #include <vfs/vfs_support.h> ! 82: ! 83: #ifdef NeXT ! 84: extern int doclusterread, doclusterwrite; ! 85: #endif ! 86: ! 87: struct vnode *speclisth[SPECHSZ]; ! 88: ! 89: /* symbolic sleep message strings for devices */ ! 90: char devopn[] = "devopn"; ! 91: char devio[] = "devio"; ! 92: char devwait[] = "devwait"; ! 93: char devin[] = "devin"; ! 94: char devout[] = "devout"; ! 95: char devioc[] = "devioc"; ! 96: char devcls[] = "devcls"; ! 97: ! 98: int (**spec_vnodeop_p)(); ! 99: struct vnodeopv_entry_desc spec_vnodeop_entries[] = { ! 100: { &vop_default_desc, vn_default_error }, ! 101: { &vop_lookup_desc, spec_lookup }, /* lookup */ ! 102: { &vop_create_desc, err_create }, /* create */ ! 103: { &vop_mknod_desc, err_mknod }, /* mknod */ ! 104: { &vop_open_desc, spec_open }, /* open */ ! 105: { &vop_close_desc, spec_close }, /* close */ ! 106: { &vop_access_desc, spec_access }, /* access */ ! 107: { &vop_getattr_desc, spec_getattr }, /* getattr */ ! 108: { &vop_setattr_desc, spec_setattr }, /* setattr */ ! 109: { &vop_read_desc, spec_read }, /* read */ ! 110: { &vop_write_desc, spec_write }, /* write */ ! 111: { &vop_lease_desc, nop_lease }, /* lease */ ! 112: { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ ! 113: { &vop_select_desc, spec_select }, /* select */ ! 114: { &vop_revoke_desc, nop_revoke }, /* revoke */ ! 115: { &vop_mmap_desc, err_mmap }, /* mmap */ ! 116: { &vop_fsync_desc, spec_fsync }, /* fsync */ ! 117: { &vop_seek_desc, err_seek }, /* seek */ ! 118: { &vop_remove_desc, err_remove }, /* remove */ ! 119: { &vop_link_desc, err_link }, /* link */ ! 120: { &vop_rename_desc, err_rename }, /* rename */ ! 121: { &vop_mkdir_desc, err_mkdir }, /* mkdir */ ! 122: { &vop_rmdir_desc, err_rmdir }, /* rmdir */ ! 123: { &vop_symlink_desc, err_symlink }, /* symlink */ ! 124: { &vop_readdir_desc, err_readdir }, /* readdir */ ! 125: { &vop_readlink_desc, err_readlink }, /* readlink */ ! 126: { &vop_abortop_desc, err_abortop }, /* abortop */ ! 127: { &vop_inactive_desc, nop_inactive }, /* inactive */ ! 128: { &vop_reclaim_desc, nop_reclaim }, /* reclaim */ ! 129: { &vop_lock_desc, nop_lock }, /* lock */ ! 130: { &vop_unlock_desc, nop_unlock }, /* unlock */ ! 131: { &vop_bmap_desc, spec_bmap }, /* bmap */ ! 132: { &vop_strategy_desc, spec_strategy }, /* strategy */ ! 133: { &vop_print_desc, spec_print }, /* print */ ! 134: { &vop_islocked_desc, nop_islocked }, /* islocked */ ! 135: { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ ! 136: { &vop_advlock_desc, err_advlock }, /* advlock */ ! 137: { &vop_blkatoff_desc, err_blkatoff }, /* blkatoff */ ! 138: { &vop_valloc_desc, err_valloc }, /* valloc */ ! 139: { &vop_vfree_desc, err_vfree }, /* vfree */ ! 140: { &vop_truncate_desc, nop_truncate }, /* truncate */ ! 141: { &vop_update_desc, nop_update }, /* update */ ! 142: { &vop_bwrite_desc, spec_bwrite }, /* bwrite */ ! 143: #ifdef NeXT ! 144: { &vop_devblocksize_desc, spec_devblocksize }, /* devblocksize */ ! 145: #endif /* NeXT */ ! 146: { &vop_pagein_desc, spec_pagein }, /* Pagein */ ! 147: { &vop_pageout_desc, spec_pageout }, /* Pageout */ ! 148: { (struct vnodeop_desc*)NULL, (int(*)())NULL } ! 149: }; ! 150: struct vnodeopv_desc spec_vnodeop_opv_desc = ! 151: { &spec_vnodeop_p, spec_vnodeop_entries }; ! 152: ! 153: /* ! 154: * Trivial lookup routine that always fails. ! 155: */ ! 156: int ! 157: spec_lookup(ap) ! 158: struct vop_lookup_args /* { ! 159: struct vnode *a_dvp; ! 160: struct vnode **a_vpp; ! 161: struct componentname *a_cnp; ! 162: } */ *ap; ! 163: { ! 164: ! 165: *ap->a_vpp = NULL; ! 166: return (ENOTDIR); ! 167: } ! 168: ! 169: #ifdef NeXT ! 170: void ! 171: set_blocksize(struct vnode *vp, dev_t dev) ! 172: { ! 173: int (*size)(); ! 174: int rsize; ! 175: ! 176: if ((major(dev) < nblkdev) && (size = bdevsw[major(dev)].d_psize)) { ! 177: rsize = (*size)(dev); ! 178: if (rsize <= 0) /* did size fail? */ ! 179: vp->v_specsize = DEV_BSIZE; ! 180: else ! 181: vp->v_specsize = rsize; ! 182: } ! 183: else ! 184: vp->v_specsize = DEV_BSIZE; ! 185: } ! 186: #endif /* NeXT */ ! 187: ! 188: /* ! 189: * Open a special file. ! 190: */ ! 191: /* ARGSUSED */ ! 192: spec_open(ap) ! 193: struct vop_open_args /* { ! 194: struct vnode *a_vp; ! 195: int a_mode; ! 196: struct ucred *a_cred; ! 197: struct proc *a_p; ! 198: } */ *ap; ! 199: { ! 200: struct proc *p = ap->a_p; ! 201: struct vnode *bvp, *vp = ap->a_vp; ! 202: dev_t bdev, dev = (dev_t)vp->v_rdev; ! 203: int maj = major(dev); ! 204: int error; ! 205: ! 206: /* ! 207: * Don't allow open if fs is mounted -nodev. ! 208: */ ! 209: if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV)) ! 210: return (ENXIO); ! 211: ! 212: switch (vp->v_type) { ! 213: ! 214: case VCHR: ! 215: if ((u_int)maj >= nchrdev) ! 216: return (ENXIO); ! 217: if (ap->a_cred != FSCRED && (ap->a_mode & FWRITE)) { ! 218: /* ! 219: * When running in very secure mode, do not allow ! 220: * opens for writing of any disk character devices. ! 221: */ ! 222: if (securelevel >= 2 && isdisk(dev, VCHR)) ! 223: return (EPERM); ! 224: /* ! 225: * When running in secure mode, do not allow opens ! 226: * for writing of /dev/mem, /dev/kmem, or character ! 227: * devices whose corresponding block devices are ! 228: * currently mounted. ! 229: */ ! 230: if (securelevel >= 1) { ! 231: if ((bdev = chrtoblk(dev)) != NODEV && ! 232: vfinddev(bdev, VBLK, &bvp) && ! 233: bvp->v_usecount > 0 && ! 234: (error = vfs_mountedon(bvp))) ! 235: return (error); ! 236: if (iskmemdev(dev)) ! 237: return (EPERM); ! 238: } ! 239: } ! 240: if (cdevsw[maj].d_type == D_TTY) ! 241: vp->v_flag |= VISTTY; ! 242: VOP_UNLOCK(vp, 0, p); ! 243: error = (*cdevsw[maj].d_open)(dev, ap->a_mode, S_IFCHR, p); ! 244: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 245: return (error); ! 246: ! 247: case VBLK: ! 248: if ((u_int)maj >= nblkdev) ! 249: return (ENXIO); ! 250: /* ! 251: * When running in very secure mode, do not allow ! 252: * opens for writing of any disk block devices. ! 253: */ ! 254: if (securelevel >= 2 && ap->a_cred != FSCRED && ! 255: (ap->a_mode & FWRITE) && bdevsw[maj].d_type == D_DISK) ! 256: return (EPERM); ! 257: /* ! 258: * Do not allow opens of block devices that are ! 259: * currently mounted. ! 260: */ ! 261: if (error = vfs_mountedon(vp)) ! 262: return (error); ! 263: #ifdef NeXT ! 264: error = (*bdevsw[maj].d_open)(dev, ap->a_mode, S_IFBLK, p); ! 265: if (!error) { ! 266: set_blocksize(vp, dev); ! 267: } ! 268: return(error); ! 269: #else ! 270: return ((*bdevsw[maj].d_open)(dev, ap->a_mode, S_IFBLK, p)); ! 271: #endif /* NeXT */ ! 272: } ! 273: return (0); ! 274: } ! 275: ! 276: /* ! 277: * Vnode op for read ! 278: */ ! 279: /* ARGSUSED */ ! 280: spec_read(ap) ! 281: struct vop_read_args /* { ! 282: struct vnode *a_vp; ! 283: struct uio *a_uio; ! 284: int a_ioflag; ! 285: struct ucred *a_cred; ! 286: } */ *ap; ! 287: { ! 288: register struct vnode *vp = ap->a_vp; ! 289: register struct uio *uio = ap->a_uio; ! 290: struct proc *p = uio->uio_procp; ! 291: struct buf *bp; ! 292: daddr_t bn, nextbn; ! 293: long bsize, bscale; ! 294: #ifdef NeXT ! 295: int devBlockSize=0; ! 296: int firstpass, seq; ! 297: #else ! 298: struct partinfo dpart; ! 299: #endif /* NeXT */ ! 300: int n, on, majordev, (*ioctl)(); ! 301: int error = 0; ! 302: dev_t dev; ! 303: ! 304: #if DIAGNOSTIC ! 305: if (uio->uio_rw != UIO_READ) ! 306: panic("spec_read mode"); ! 307: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc()) ! 308: panic("spec_read proc"); ! 309: #endif ! 310: if (uio->uio_resid == 0) ! 311: return (0); ! 312: ! 313: switch (vp->v_type) { ! 314: ! 315: case VCHR: ! 316: VOP_UNLOCK(vp, 0, p); ! 317: error = (*cdevsw[major(vp->v_rdev)].d_read) ! 318: (vp->v_rdev, uio, ap->a_ioflag); ! 319: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 320: return (error); ! 321: ! 322: case VBLK: ! 323: if (uio->uio_offset < 0) ! 324: return (EINVAL); ! 325: #ifdef NeXT ! 326: bsize = PAGE_SIZE; ! 327: #else ! 328: bsize = BLKDEV_IOSIZE; ! 329: #endif /* NeXT */ ! 330: ! 331: dev = vp->v_rdev; ! 332: #ifndef NeXT ! 333: if ((majordev = major(dev)) < nblkdev && ! 334: (ioctl = bdevsw[majordev].d_ioctl) != NULL && ! 335: (*ioctl)(dev, DIOCGPART, (caddr_t)&dpart, FREAD, p) == 0 && ! 336: dpart.part->p_fstype == FS_BSDFFS && ! 337: dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) ! 338: bsize = dpart.part->p_frag * dpart.part->p_fsize; ! 339: #endif /* NeXT */ ! 340: #ifdef NeXT /*[ */ ! 341: devBlockSize = vp->v_specsize; ! 342: bscale = bsize / devBlockSize; ! 343: firstpass = TRUE; ! 344: ! 345: do { ! 346: on = uio->uio_offset % bsize; ! 347: ! 348: if (doclusterread && doclusterwrite) { ! 349: bn = uio->uio_offset / bsize; ! 350: ! 351: error = cluster_read(vp, (u_quad_t)0x7fffffffffffffff, bn, bsize, NOCRED, ! 352: &bp, devBlockSize, firstpass, uio->uio_resid+on, &seq); ! 353: } else { ! 354: bn = (uio->uio_offset / devBlockSize) &~ (bscale - 1); ! 355: ! 356: if (vp->v_lastr + bscale == bn) { ! 357: nextbn = bn + bscale; ! 358: error = breadn(vp, bn, (int)bsize, &nextbn, ! 359: (int *)&bsize, 1, NOCRED, &bp); ! 360: } else ! 361: error = bread(vp, bn, (int)bsize, NOCRED, &bp); ! 362: } ! 363: firstpass = FALSE; ! 364: ! 365: vp->v_lastr = bn; ! 366: n = bsize - bp->b_resid; ! 367: if ((on > n) || error) { ! 368: if (!error) ! 369: error = EINVAL; ! 370: brelse(bp); ! 371: return (error); ! 372: } ! 373: n = min((unsigned)(n - on), uio->uio_resid); ! 374: ! 375: error = uiomove((char *)bp->b_data + on, n, uio); ! 376: if (n + on == bsize) ! 377: bp->b_flags |= B_AGE; ! 378: brelse(bp); ! 379: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 380: #else /*][ */ ! 381: bscale = bsize / DEV_BSIZE; ! 382: do { ! 383: bn = (uio->uio_offset / DEV_BSIZE) &~ (bscale - 1); ! 384: on = uio->uio_offset % bsize; ! 385: n = min((unsigned)(bsize - on), uio->uio_resid); ! 386: if (vp->v_lastr + bscale == bn) { ! 387: nextbn = bn + bscale; ! 388: error = breadn(vp, bn, (int)bsize, &nextbn, ! 389: (int *)&bsize, 1, NOCRED, &bp); ! 390: } else ! 391: error = bread(vp, bn, (int)bsize, NOCRED, &bp); ! 392: vp->v_lastr = bn; ! 393: n = min(n, bsize - bp->b_resid); ! 394: if (error) { ! 395: brelse(bp); ! 396: return (error); ! 397: } ! 398: error = uiomove((char *)bp->b_data + on, n, uio); ! 399: if (n + on == bsize) ! 400: bp->b_flags |= B_AGE; ! 401: brelse(bp); ! 402: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 403: #endif NeXT /* ] */ ! 404: return (error); ! 405: ! 406: default: ! 407: panic("spec_read type"); ! 408: } ! 409: /* NOTREACHED */ ! 410: } ! 411: ! 412: /* ! 413: * Vnode op for write ! 414: */ ! 415: /* ARGSUSED */ ! 416: spec_write(ap) ! 417: struct vop_write_args /* { ! 418: struct vnode *a_vp; ! 419: struct uio *a_uio; ! 420: int a_ioflag; ! 421: struct ucred *a_cred; ! 422: } */ *ap; ! 423: { ! 424: register struct vnode *vp = ap->a_vp; ! 425: register struct uio *uio = ap->a_uio; ! 426: struct proc *p = uio->uio_procp; ! 427: struct buf *bp; ! 428: daddr_t bn; ! 429: int bsize, blkmask; ! 430: #ifdef NeXT ! 431: register int io_sync; ! 432: register int io_size; ! 433: register int forcewrite; ! 434: int devBlockSize=0; ! 435: #else ! 436: struct partinfo dpart; ! 437: #endif ! 438: register int n, on; ! 439: int error = 0; ! 440: dev_t dev; ! 441: ! 442: #if DIAGNOSTIC ! 443: if (uio->uio_rw != UIO_WRITE) ! 444: panic("spec_write mode"); ! 445: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc()) ! 446: panic("spec_write proc"); ! 447: #endif ! 448: ! 449: switch (vp->v_type) { ! 450: ! 451: case VCHR: ! 452: VOP_UNLOCK(vp, 0, p); ! 453: error = (*cdevsw[major(vp->v_rdev)].d_write) ! 454: (vp->v_rdev, uio, ap->a_ioflag); ! 455: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 456: return (error); ! 457: ! 458: case VBLK: ! 459: if (uio->uio_resid == 0) ! 460: return (0); ! 461: if (uio->uio_offset < 0) ! 462: return (EINVAL); ! 463: ! 464: #ifdef NeXT ! 465: bsize = PAGE_SIZE; ! 466: io_sync = (ap->a_ioflag & IO_SYNC); ! 467: io_size = uio->uio_resid; ! 468: #else ! 469: bsize = BLKDEV_IOSIZE; ! 470: #endif /* NeXT */ ! 471: dev = (vp->v_rdev); ! 472: #ifndef NeXT ! 473: if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART, ! 474: (caddr_t)&dpart, FREAD, p) == 0) { ! 475: if (dpart.part->p_fstype == FS_BSDFFS && ! 476: dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) ! 477: bsize = dpart.part->p_frag * ! 478: dpart.part->p_fsize; ! 479: } ! 480: #endif /* NeXT */ ! 481: #ifdef NeXT /* [ */ ! 482: devBlockSize = vp->v_specsize; ! 483: blkmask = (bsize / devBlockSize) - 1; ! 484: ! 485: do { ! 486: forcewrite = 0; ! 487: ! 488: if (doclusterread && doclusterwrite) ! 489: bn = uio->uio_offset / bsize; ! 490: else ! 491: bn = (uio->uio_offset / devBlockSize) &~ blkmask; ! 492: on = uio->uio_offset % bsize; ! 493: ! 494: n = min((unsigned)(bsize - on), uio->uio_resid); ! 495: ! 496: if (doclusterread && doclusterwrite) { ! 497: bp = getblk(vp, bn, bsize, 0, 0); ! 498: ! 499: VOP_BMAP(vp, bn, NULL, &bp->b_blkno, NULL); ! 500: ! 501: if (n != bsize && !(bp->b_flags & (B_DONE|B_DELWRI))) { ! 502: if ((on % devBlockSize) || (n % devBlockSize)) { ! 503: bp->b_flags |= B_READ; ! 504: VOP_STRATEGY(bp); ! 505: error = biowait(bp); ! 506: } else { ! 507: if (on) { ! 508: bp->b_blkno += (on / devBlockSize); ! 509: on = 0; ! 510: } ! 511: forcewrite = 1; ! 512: bp->b_bcount = n; ! 513: bp->b_flags |= B_INVAL; ! 514: } ! 515: } ! 516: } else { ! 517: if (n == bsize) ! 518: bp = getblk(vp, bn, bsize, 0, 0); ! 519: else ! 520: error = bread(vp, bn, bsize, NOCRED, &bp); ! 521: } ! 522: if (error) { ! 523: brelse(bp); ! 524: return (error); ! 525: } ! 526: n = min(n, bsize - bp->b_resid); ! 527: ! 528: error = uiomove((char *)bp->b_data + on, n, uio); ! 529: ! 530: if (forcewrite) { ! 531: if (uio->uio_resid == 0) ! 532: bwrite(bp); ! 533: else ! 534: bawrite(bp); ! 535: } else if (((io_size >= bsize) || ((n + on) == bsize)) && doclusterread && doclusterwrite) { ! 536: if (io_sync) { ! 537: if (uio->uio_resid < bsize) ! 538: bp->b_flags |= (B_CLUST_SYNC | B_CLUST_COMMIT); ! 539: else ! 540: bp->b_flags |= B_CLUST_SYNC; ! 541: ! 542: error = cluster_write(bp, (u_quad_t)0x7fffffffffffffff, devBlockSize); ! 543: } else ! 544: cluster_write(bp, (u_quad_t)0x7fffffffffffffff, devBlockSize); ! 545: } else { ! 546: bp->b_flags |= B_AGE; ! 547: ! 548: if (io_sync) ! 549: bwrite(bp); ! 550: else { ! 551: if ((n + on) == bsize) ! 552: bawrite(bp); ! 553: else ! 554: bdwrite(bp); ! 555: } ! 556: } ! 557: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 558: #else /*][ */ ! 559: blkmask = (bsize / DEV_BSIZE) - 1; ! 560: do { ! 561: bn = (uio->uio_offset / DEV_BSIZE) &~ blkmask; ! 562: on = uio->uio_offset % bsize; ! 563: n = min((unsigned)(bsize - on), uio->uio_resid); ! 564: if (n == bsize) ! 565: bp = getblk(vp, bn, bsize, 0, 0); ! 566: else ! 567: error = bread(vp, bn, bsize, NOCRED, &bp); ! 568: n = min(n, bsize - bp->b_resid); ! 569: if (error) { ! 570: brelse(bp); ! 571: return (error); ! 572: } ! 573: error = uiomove((char *)bp->b_data + on, n, uio); ! 574: if (n + on == bsize) { ! 575: bp->b_flags |= B_AGE; ! 576: bawrite(bp); ! 577: } else ! 578: bdwrite(bp); ! 579: } while (error == 0 && uio->uio_resid > 0 && n != 0); ! 580: #endif NeXT /* ] */ ! 581: return (error); ! 582: ! 583: default: ! 584: panic("spec_write type"); ! 585: } ! 586: /* NOTREACHED */ ! 587: } ! 588: ! 589: /* ! 590: * Device ioctl operation. ! 591: */ ! 592: /* ARGSUSED */ ! 593: spec_ioctl(ap) ! 594: struct vop_ioctl_args /* { ! 595: struct vnode *a_vp; ! 596: int a_command; ! 597: caddr_t a_data; ! 598: int a_fflag; ! 599: struct ucred *a_cred; ! 600: struct proc *a_p; ! 601: } */ *ap; ! 602: { ! 603: dev_t dev = ap->a_vp->v_rdev; ! 604: ! 605: switch (ap->a_vp->v_type) { ! 606: ! 607: case VCHR: ! 608: return ((*cdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data, ! 609: ap->a_fflag, ap->a_p)); ! 610: ! 611: case VBLK: ! 612: if (ap->a_command == 0 && (int)ap->a_data == B_TAPE) ! 613: if (bdevsw[major(dev)].d_type == D_TAPE) ! 614: return (0); ! 615: else ! 616: return (1); ! 617: return ((*bdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data, ! 618: ap->a_fflag, ap->a_p)); ! 619: ! 620: default: ! 621: panic("spec_ioctl"); ! 622: /* NOTREACHED */ ! 623: } ! 624: } ! 625: ! 626: /* ARGSUSED */ ! 627: spec_select(ap) ! 628: struct vop_select_args /* { ! 629: struct vnode *a_vp; ! 630: int a_which; ! 631: int a_fflags; ! 632: struct ucred *a_cred; ! 633: struct proc *a_p; ! 634: } */ *ap; ! 635: { ! 636: register dev_t dev; ! 637: ! 638: switch (ap->a_vp->v_type) { ! 639: ! 640: default: ! 641: return (1); /* XXX */ ! 642: ! 643: case VCHR: ! 644: dev = ap->a_vp->v_rdev; ! 645: return (*cdevsw[major(dev)].d_select)(dev, ap->a_which, ap->a_p); ! 646: } ! 647: } ! 648: /* ! 649: * Synch buffers associated with a block device ! 650: */ ! 651: /* ARGSUSED */ ! 652: int ! 653: spec_fsync(ap) ! 654: struct vop_fsync_args /* { ! 655: struct vnode *a_vp; ! 656: struct ucred *a_cred; ! 657: int a_waitfor; ! 658: struct proc *a_p; ! 659: } */ *ap; ! 660: { ! 661: register struct vnode *vp = ap->a_vp; ! 662: register struct buf *bp; ! 663: struct buf *nbp; ! 664: int s; ! 665: ! 666: if (vp->v_type == VCHR) ! 667: return (0); ! 668: /* ! 669: * Flush all dirty buffers associated with a block device. ! 670: */ ! 671: loop: ! 672: s = splbio(); ! 673: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) { ! 674: nbp = bp->b_vnbufs.le_next; ! 675: if ((bp->b_flags & B_BUSY)) ! 676: continue; ! 677: if ((bp->b_flags & B_DELWRI) == 0) ! 678: panic("spec_fsync: not dirty"); ! 679: bremfree(bp); ! 680: bp->b_flags |= B_BUSY; ! 681: splx(s); ! 682: bawrite(bp); ! 683: goto loop; ! 684: } ! 685: if (ap->a_waitfor == MNT_WAIT) { ! 686: while (vp->v_numoutput) { ! 687: vp->v_flag |= VBWAIT; ! 688: tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "spec_fsync", 0); ! 689: } ! 690: #if DIAGNOSTIC ! 691: if (vp->v_dirtyblkhd.lh_first) { ! 692: vprint("spec_fsync: dirty", vp); ! 693: splx(s); ! 694: goto loop; ! 695: } ! 696: #endif ! 697: } ! 698: splx(s); ! 699: return (0); ! 700: } ! 701: ! 702: /* ! 703: * Just call the device strategy routine ! 704: */ ! 705: spec_strategy(ap) ! 706: struct vop_strategy_args /* { ! 707: struct buf *a_bp; ! 708: } */ *ap; ! 709: { ! 710: (*bdevsw[major(ap->a_bp->b_dev)].d_strategy)(ap->a_bp); ! 711: return (0); ! 712: } ! 713: ! 714: /* ! 715: * This is a noop, simply returning what one has been given. ! 716: */ ! 717: spec_bmap(ap) ! 718: struct vop_bmap_args /* { ! 719: struct vnode *a_vp; ! 720: daddr_t a_bn; ! 721: struct vnode **a_vpp; ! 722: daddr_t *a_bnp; ! 723: int *a_runp; ! 724: } */ *ap; ! 725: { ! 726: ! 727: if (ap->a_vpp != NULL) ! 728: *ap->a_vpp = ap->a_vp; ! 729: if (ap->a_bnp != NULL) ! 730: #ifdef NeXT ! 731: *ap->a_bnp = ap->a_bn * (PAGE_SIZE / ap->a_vp->v_specsize); ! 732: #else ! 733: *ap->a_bnp = ap->a_bn; ! 734: #endif ! 735: if (ap->a_runp != NULL) ! 736: #ifdef NeXT ! 737: *ap->a_runp = (MAXPHYSIO / PAGE_SIZE) - 1; ! 738: #else ! 739: *ap->a_runp = 0; ! 740: #endif ! 741: return (0); ! 742: } ! 743: ! 744: /* ! 745: * Device close routine ! 746: */ ! 747: /* ARGSUSED */ ! 748: spec_close(ap) ! 749: struct vop_close_args /* { ! 750: struct vnode *a_vp; ! 751: int a_fflag; ! 752: struct ucred *a_cred; ! 753: struct proc *a_p; ! 754: } */ *ap; ! 755: { ! 756: register struct vnode *vp = ap->a_vp; ! 757: dev_t dev = vp->v_rdev; ! 758: int (*devclose) __P((dev_t, int, int, struct proc *)); ! 759: int mode, error; ! 760: ! 761: switch (vp->v_type) { ! 762: ! 763: case VCHR: ! 764: /* ! 765: * Hack: a tty device that is a controlling terminal ! 766: * has a reference from the session structure. ! 767: * We cannot easily tell that a character device is ! 768: * a controlling terminal, unless it is the closing ! 769: * process' controlling terminal. In that case, ! 770: * if the reference count is 2 (this last descriptor ! 771: * plus the session), release the reference from the session. ! 772: */ ! 773: if (vcount(vp) == 2 && ap->a_p && ! 774: vp == ap->a_p->p_session->s_ttyvp) { ! 775: vrele(vp); ! 776: ap->a_p->p_session->s_ttyvp = NULL; ! 777: } ! 778: /* ! 779: * If the vnode is locked, then we are in the midst ! 780: * of forcably closing the device, otherwise we only ! 781: * close on last reference. ! 782: */ ! 783: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) ! 784: return (0); ! 785: devclose = cdevsw[major(dev)].d_close; ! 786: mode = S_IFCHR; ! 787: break; ! 788: ! 789: case VBLK: ! 790: /* ! 791: * On last close of a block device (that isn't mounted) ! 792: * we must invalidate any in core blocks, so that ! 793: * we can, for instance, change floppy disks. ! 794: */ ! 795: if (error = vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 0, 0)) ! 796: return (error); ! 797: /* ! 798: * We do not want to really close the device if it ! 799: * is still in use unless we are trying to close it ! 800: * forcibly. Since every use (buffer, vnode, swap, cmap) ! 801: * holds a reference to the vnode, and because we mark ! 802: * any other vnodes that alias this device, when the ! 803: * sum of the reference counts on all the aliased ! 804: * vnodes descends to one, we are on last close. ! 805: */ ! 806: if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) ! 807: return (0); ! 808: devclose = bdevsw[major(dev)].d_close; ! 809: mode = S_IFBLK; ! 810: break; ! 811: ! 812: default: ! 813: panic("spec_close: not special"); ! 814: } ! 815: ! 816: return ((*devclose)(dev, ap->a_fflag, mode, ap->a_p)); ! 817: } ! 818: ! 819: /* ! 820: * Print out the contents of a special device vnode. ! 821: */ ! 822: spec_print(ap) ! 823: struct vop_print_args /* { ! 824: struct vnode *a_vp; ! 825: } */ *ap; ! 826: { ! 827: ! 828: printf("tag VT_NON, dev %d, %d\n", major(ap->a_vp->v_rdev), ! 829: minor(ap->a_vp->v_rdev)); ! 830: } ! 831: ! 832: /* ! 833: * Return POSIX pathconf information applicable to special devices. ! 834: */ ! 835: spec_pathconf(ap) ! 836: struct vop_pathconf_args /* { ! 837: struct vnode *a_vp; ! 838: int a_name; ! 839: int *a_retval; ! 840: } */ *ap; ! 841: { ! 842: ! 843: switch (ap->a_name) { ! 844: case _PC_LINK_MAX: ! 845: *ap->a_retval = LINK_MAX; ! 846: return (0); ! 847: case _PC_MAX_CANON: ! 848: *ap->a_retval = MAX_CANON; ! 849: return (0); ! 850: case _PC_MAX_INPUT: ! 851: *ap->a_retval = MAX_INPUT; ! 852: return (0); ! 853: case _PC_PIPE_BUF: ! 854: *ap->a_retval = PIPE_BUF; ! 855: return (0); ! 856: case _PC_CHOWN_RESTRICTED: ! 857: *ap->a_retval = 1; ! 858: return (0); ! 859: case _PC_VDISABLE: ! 860: *ap->a_retval = _POSIX_VDISABLE; ! 861: return (0); ! 862: default: ! 863: return (EINVAL); ! 864: } ! 865: /* NOTREACHED */ ! 866: } ! 867: ! 868: int ! 869: spec_devblocksize(ap) ! 870: struct vop_devblocksize_args /* { ! 871: struct vnode *a_vp; ! 872: int *a_retval; ! 873: } */ *ap; ! 874: { ! 875: *ap->a_retval = (ap->a_vp->v_specsize); ! 876: return (0); ! 877: } ! 878: ! 879: /* ! 880: * Special device failed operation ! 881: */ ! 882: spec_ebadf() ! 883: { ! 884: ! 885: return (EBADF); ! 886: } ! 887: ! 888: /* ! 889: * Special device bad operation ! 890: */ ! 891: spec_badop() ! 892: { ! 893: ! 894: panic("spec_badop called"); ! 895: /* NOTREACHED */ ! 896: } ! 897: /* Pagein */ ! 898: spec_pagein(ap) ! 899: struct vop_pagein_args /* { ! 900: struct vnode *a_vp; ! 901: struct uio *a_uio; ! 902: int a_ioflag; ! 903: struct ucred *a_cred; ! 904: } */ *ap; ! 905: { ! 906: /* pass thru to read */ ! 907: return (VOP_READ(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred)); ! 908: } ! 909: ! 910: /* Pageout */ ! 911: spec_pageout(ap) ! 912: struct vop_pageout_args /* { ! 913: struct vnode *a_vp; ! 914: struct uio *a_uio; ! 915: int a_ioflag; ! 916: struct ucred *a_cred; ! 917: } */ *ap; ! 918: { ! 919: /* pass thru to write */ ! 920: return (VOP_WRITE(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred)); ! 921: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.