Annotation of sys/ufs/ffs/ffs_vnops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ffs_vnops.c,v 1.45 2007/06/01 23:47:57 deraadt Exp $ */
! 2: /* $NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 1989, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)ffs_vnops.c 8.10 (Berkeley) 8/10/94
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/resourcevar.h>
! 38: #include <sys/kernel.h>
! 39: #include <sys/file.h>
! 40: #include <sys/stat.h>
! 41: #include <sys/buf.h>
! 42: #include <sys/proc.h>
! 43: #include <sys/conf.h>
! 44: #include <sys/mount.h>
! 45: #include <sys/vnode.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/signalvar.h>
! 48: #include <sys/pool.h>
! 49: #include <sys/event.h>
! 50:
! 51: #include <uvm/uvm_extern.h>
! 52:
! 53: #include <miscfs/specfs/specdev.h>
! 54: #include <miscfs/fifofs/fifo.h>
! 55:
! 56: #include <ufs/ufs/quota.h>
! 57: #include <ufs/ufs/inode.h>
! 58: #include <ufs/ufs/dir.h>
! 59: #include <ufs/ufs/ufs_extern.h>
! 60: #include <ufs/ufs/ufsmount.h>
! 61:
! 62: #include <ufs/ffs/fs.h>
! 63: #include <ufs/ffs/ffs_extern.h>
! 64:
! 65: /* Global vfs data structures for ufs. */
! 66: int (**ffs_vnodeop_p)(void *);
! 67: struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
! 68: { &vop_default_desc, vn_default_error },
! 69: { &vop_lookup_desc, ufs_lookup }, /* lookup */
! 70: { &vop_create_desc, ufs_create }, /* create */
! 71: { &vop_mknod_desc, ufs_mknod }, /* mknod */
! 72: { &vop_open_desc, ufs_open }, /* open */
! 73: { &vop_close_desc, ufs_close }, /* close */
! 74: { &vop_access_desc, ufs_access }, /* access */
! 75: { &vop_getattr_desc, ufs_getattr }, /* getattr */
! 76: { &vop_setattr_desc, ufs_setattr }, /* setattr */
! 77: { &vop_read_desc, ffs_read }, /* read */
! 78: { &vop_write_desc, ffs_write }, /* write */
! 79: { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
! 80: { &vop_poll_desc, ufs_poll }, /* poll */
! 81: { &vop_kqfilter_desc, ufs_kqfilter }, /* kqfilter */
! 82: { &vop_revoke_desc, ufs_revoke }, /* revoke */
! 83: { &vop_fsync_desc, ffs_fsync }, /* fsync */
! 84: { &vop_remove_desc, ufs_remove }, /* remove */
! 85: { &vop_link_desc, ufs_link }, /* link */
! 86: { &vop_rename_desc, ufs_rename }, /* rename */
! 87: { &vop_mkdir_desc, ufs_mkdir }, /* mkdir */
! 88: { &vop_rmdir_desc, ufs_rmdir }, /* rmdir */
! 89: { &vop_symlink_desc, ufs_symlink }, /* symlink */
! 90: { &vop_readdir_desc, ufs_readdir }, /* readdir */
! 91: { &vop_readlink_desc, ufs_readlink }, /* readlink */
! 92: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
! 93: { &vop_inactive_desc, ufs_inactive }, /* inactive */
! 94: { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */
! 95: { &vop_lock_desc, ufs_lock }, /* lock */
! 96: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 97: { &vop_bmap_desc, ufs_bmap }, /* bmap */
! 98: { &vop_strategy_desc, ufs_strategy }, /* strategy */
! 99: { &vop_print_desc, ufs_print }, /* print */
! 100: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 101: { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
! 102: { &vop_advlock_desc, ufs_advlock }, /* advlock */
! 103: { &vop_reallocblks_desc, ffs_reallocblks }, /* reallocblks */
! 104: { &vop_bwrite_desc, vop_generic_bwrite },
! 105: { NULL, NULL }
! 106: };
! 107:
! 108: struct vnodeopv_desc ffs_vnodeop_opv_desc =
! 109: { &ffs_vnodeop_p, ffs_vnodeop_entries };
! 110:
! 111: int (**ffs_specop_p)(void *);
! 112: struct vnodeopv_entry_desc ffs_specop_entries[] = {
! 113: { &vop_default_desc, spec_vnoperate },
! 114: { &vop_close_desc, ufsspec_close }, /* close */
! 115: { &vop_access_desc, ufs_access }, /* access */
! 116: { &vop_getattr_desc, ufs_getattr }, /* getattr */
! 117: { &vop_setattr_desc, ufs_setattr }, /* setattr */
! 118: { &vop_read_desc, ufsspec_read }, /* read */
! 119: { &vop_write_desc, ufsspec_write }, /* write */
! 120: { &vop_fsync_desc, ffs_fsync }, /* fsync */
! 121: { &vop_inactive_desc, ufs_inactive }, /* inactive */
! 122: { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */
! 123: { &vop_lock_desc, ufs_lock }, /* lock */
! 124: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 125: { &vop_print_desc, ufs_print }, /* print */
! 126: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 127: { NULL, NULL }
! 128: };
! 129:
! 130: struct vnodeopv_desc ffs_specop_opv_desc =
! 131: { &ffs_specop_p, ffs_specop_entries };
! 132:
! 133: #ifdef FIFO
! 134: int (**ffs_fifoop_p)(void *);
! 135: struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
! 136: { &vop_default_desc, fifo_vnoperate },
! 137: { &vop_close_desc, ufsfifo_close }, /* close */
! 138: { &vop_access_desc, ufs_access }, /* access */
! 139: { &vop_getattr_desc, ufs_getattr }, /* getattr */
! 140: { &vop_setattr_desc, ufs_setattr }, /* setattr */
! 141: { &vop_read_desc, ufsfifo_read }, /* read */
! 142: { &vop_write_desc, ufsfifo_write }, /* write */
! 143: { &vop_fsync_desc, ffs_fsync }, /* fsync */
! 144: { &vop_inactive_desc, ufs_inactive }, /* inactive */
! 145: { &vop_reclaim_desc, ffsfifo_reclaim }, /* reclaim */
! 146: { &vop_lock_desc, ufs_lock }, /* lock */
! 147: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 148: { &vop_print_desc, ufs_print }, /* print */
! 149: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 150: { &vop_bwrite_desc, vop_generic_bwrite },
! 151: { NULL, NULL }
! 152: };
! 153:
! 154: struct vnodeopv_desc ffs_fifoop_opv_desc =
! 155: { &ffs_fifoop_p, ffs_fifoop_entries };
! 156: #endif /* FIFO */
! 157:
! 158: /*
! 159: * Enabling cluster read/write operations.
! 160: */
! 161: int doclusterread = 1;
! 162: int doclusterwrite = 1;
! 163:
! 164: /*
! 165: * Vnode op for reading.
! 166: */
! 167: /* ARGSUSED */
! 168: int
! 169: ffs_read(void *v)
! 170: {
! 171: struct vop_read_args *ap = v;
! 172: struct vnode *vp;
! 173: struct inode *ip;
! 174: struct uio *uio;
! 175: struct fs *fs;
! 176: struct buf *bp;
! 177: daddr64_t lbn, nextlbn;
! 178: off_t bytesinfile;
! 179: long size, xfersize, blkoffset;
! 180: mode_t mode;
! 181: int error;
! 182:
! 183: vp = ap->a_vp;
! 184: ip = VTOI(vp);
! 185: mode = DIP(ip, mode);
! 186: uio = ap->a_uio;
! 187:
! 188: #ifdef DIAGNOSTIC
! 189: if (uio->uio_rw != UIO_READ)
! 190: panic("ffs_read: mode");
! 191:
! 192: if (vp->v_type == VLNK) {
! 193: if ((int)DIP(ip, size) < vp->v_mount->mnt_maxsymlinklen ||
! 194: (vp->v_mount->mnt_maxsymlinklen == 0 &&
! 195: DIP(ip, blocks) == 0))
! 196: panic("ffs_read: short symlink");
! 197: } else if (vp->v_type != VREG && vp->v_type != VDIR)
! 198: panic("ffs_read: type %d", vp->v_type);
! 199: #endif
! 200: fs = ip->i_fs;
! 201: if ((u_int64_t)uio->uio_offset > fs->fs_maxfilesize)
! 202: return (EFBIG);
! 203:
! 204: if (uio->uio_resid == 0)
! 205: return (0);
! 206:
! 207: for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
! 208: if ((bytesinfile = DIP(ip, size) - uio->uio_offset) <= 0)
! 209: break;
! 210: lbn = lblkno(fs, uio->uio_offset);
! 211: nextlbn = lbn + 1;
! 212: size = fs->fs_bsize; /* WAS blksize(fs, ip, lbn); */
! 213: blkoffset = blkoff(fs, uio->uio_offset);
! 214: xfersize = fs->fs_bsize - blkoffset;
! 215: if (uio->uio_resid < xfersize)
! 216: xfersize = uio->uio_resid;
! 217: if (bytesinfile < xfersize)
! 218: xfersize = bytesinfile;
! 219:
! 220: if (lblktosize(fs, nextlbn) >= DIP(ip, size))
! 221: error = bread(vp, lbn, size, NOCRED, &bp);
! 222: else if (lbn - 1 == ip->i_ci.ci_lastr) {
! 223: error = bread_cluster(vp, lbn, size, &bp);
! 224: } else
! 225: error = bread(vp, lbn, size, NOCRED, &bp);
! 226:
! 227: if (error)
! 228: break;
! 229: ip->i_ci.ci_lastr = lbn;
! 230:
! 231: /*
! 232: * We should only get non-zero b_resid when an I/O error
! 233: * has occurred, which should cause us to break above.
! 234: * However, if the short read did not cause an error,
! 235: * then we want to ensure that we do not uiomove bad
! 236: * or uninitialized data.
! 237: */
! 238: size -= bp->b_resid;
! 239: if (size < xfersize) {
! 240: if (size == 0)
! 241: break;
! 242: xfersize = size;
! 243: }
! 244: error = uiomove((char *)bp->b_data + blkoffset, (int)xfersize,
! 245: uio);
! 246: if (error)
! 247: break;
! 248: brelse(bp);
! 249: }
! 250: if (bp != NULL)
! 251: brelse(bp);
! 252: ip->i_flag |= IN_ACCESS;
! 253: return (error);
! 254: }
! 255:
! 256: /*
! 257: * Vnode op for writing.
! 258: */
! 259: int
! 260: ffs_write(void *v)
! 261: {
! 262: struct vop_write_args *ap = v;
! 263: struct vnode *vp;
! 264: struct uio *uio;
! 265: struct inode *ip;
! 266: struct fs *fs;
! 267: struct buf *bp;
! 268: struct proc *p;
! 269: daddr_t lbn;
! 270: off_t osize;
! 271: int blkoffset, error, extended, flags, ioflag, resid, size, xfersize;
! 272:
! 273: extended = 0;
! 274: ioflag = ap->a_ioflag;
! 275: uio = ap->a_uio;
! 276: vp = ap->a_vp;
! 277: ip = VTOI(vp);
! 278:
! 279: #ifdef DIAGNOSTIC
! 280: if (uio->uio_rw != UIO_WRITE)
! 281: panic("ffs_write: mode");
! 282: #endif
! 283:
! 284: /*
! 285: * If writing 0 bytes, succeed and do not change
! 286: * update time or file offset (standards compliance)
! 287: */
! 288: if (uio->uio_resid == 0)
! 289: return (0);
! 290:
! 291: switch (vp->v_type) {
! 292: case VREG:
! 293: if (ioflag & IO_APPEND)
! 294: uio->uio_offset = DIP(ip, size);
! 295: if ((DIP(ip, flags) & APPEND) && uio->uio_offset != DIP(ip, size))
! 296: return (EPERM);
! 297: /* FALLTHROUGH */
! 298: case VLNK:
! 299: break;
! 300: case VDIR:
! 301: if ((ioflag & IO_SYNC) == 0)
! 302: panic("ffs_write: nonsync dir write");
! 303: break;
! 304: default:
! 305: panic("ffs_write: type");
! 306: }
! 307:
! 308: fs = ip->i_fs;
! 309: if (uio->uio_offset < 0 ||
! 310: (u_int64_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
! 311: return (EFBIG);
! 312: /*
! 313: * Maybe this should be above the vnode op call, but so long as
! 314: * file servers have no limits, I don't think it matters.
! 315: */
! 316: p = uio->uio_procp;
! 317: if (vp->v_type == VREG && p && !(ioflag & IO_NOLIMIT) &&
! 318: uio->uio_offset + uio->uio_resid >
! 319: p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
! 320: psignal(p, SIGXFSZ);
! 321: return (EFBIG);
! 322: }
! 323:
! 324: resid = uio->uio_resid;
! 325: osize = DIP(ip, size);
! 326: flags = ioflag & IO_SYNC ? B_SYNC : 0;
! 327:
! 328: for (error = 0; uio->uio_resid > 0;) {
! 329: lbn = lblkno(fs, uio->uio_offset);
! 330: blkoffset = blkoff(fs, uio->uio_offset);
! 331: xfersize = fs->fs_bsize - blkoffset;
! 332: if (uio->uio_resid < xfersize)
! 333: xfersize = uio->uio_resid;
! 334: if (fs->fs_bsize > xfersize)
! 335: flags |= B_CLRBUF;
! 336: else
! 337: flags &= ~B_CLRBUF;
! 338:
! 339: if ((error = UFS_BUF_ALLOC(ip, uio->uio_offset, xfersize,
! 340: ap->a_cred, flags, &bp)) != 0)
! 341: break;
! 342: if (uio->uio_offset + xfersize > DIP(ip, size)) {
! 343: DIP_ASSIGN(ip, size, uio->uio_offset + xfersize);
! 344: uvm_vnp_setsize(vp, DIP(ip, size));
! 345: extended = 1;
! 346: }
! 347: (void)uvm_vnp_uncache(vp);
! 348:
! 349: size = blksize(fs, ip, lbn) - bp->b_resid;
! 350: if (size < xfersize)
! 351: xfersize = size;
! 352:
! 353: error =
! 354: uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
! 355:
! 356: if (error != 0)
! 357: bzero((char *)bp->b_data + blkoffset, xfersize);
! 358:
! 359: if (ioflag & IO_SYNC)
! 360: (void)bwrite(bp);
! 361: else if (xfersize + blkoffset == fs->fs_bsize) {
! 362: if (doclusterwrite)
! 363: cluster_write(bp, &ip->i_ci, DIP(ip, size));
! 364: else
! 365: bawrite(bp);
! 366: } else
! 367: bdwrite(bp);
! 368:
! 369: if (error || xfersize == 0)
! 370: break;
! 371: ip->i_flag |= IN_CHANGE | IN_UPDATE;
! 372: }
! 373: /*
! 374: * If we successfully wrote any data, and we are not the superuser
! 375: * we clear the setuid and setgid bits as a precaution against
! 376: * tampering.
! 377: */
! 378: if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0)
! 379: DIP(ip, mode) &= ~(ISUID | ISGID);
! 380: if (resid > uio->uio_resid)
! 381: VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
! 382: if (error) {
! 383: if (ioflag & IO_UNIT) {
! 384: (void)UFS_TRUNCATE(ip, osize,
! 385: ioflag & IO_SYNC, ap->a_cred);
! 386: uio->uio_offset -= resid - uio->uio_resid;
! 387: uio->uio_resid = resid;
! 388: }
! 389: } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) {
! 390: error = UFS_UPDATE(ip, MNT_WAIT);
! 391: }
! 392: return (error);
! 393: }
! 394:
! 395: /*
! 396: * Synch an open file.
! 397: */
! 398: /* ARGSUSED */
! 399: int
! 400: ffs_fsync(void *v)
! 401: {
! 402: struct vop_fsync_args *ap = v;
! 403: struct vnode *vp = ap->a_vp;
! 404: struct buf *bp, *nbp;
! 405: int s, error, passes, skipmeta;
! 406:
! 407: if (vp->v_type == VBLK &&
! 408: vp->v_specmountpoint != NULL &&
! 409: (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
! 410: softdep_fsync_mountdev(vp, ap->a_waitfor);
! 411:
! 412: /*
! 413: * Flush all dirty buffers associated with a vnode.
! 414: */
! 415: passes = NIADDR + 1;
! 416: skipmeta = 0;
! 417: if (ap->a_waitfor == MNT_WAIT)
! 418: skipmeta = 1;
! 419: s = splbio();
! 420: loop:
! 421: for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp;
! 422: bp = LIST_NEXT(bp, b_vnbufs))
! 423: bp->b_flags &= ~B_SCANNED;
! 424: for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
! 425: nbp = LIST_NEXT(bp, b_vnbufs);
! 426: /*
! 427: * Reasons to skip this buffer: it has already been considered
! 428: * on this pass, this pass is the first time through on a
! 429: * synchronous flush request and the buffer being considered
! 430: * is metadata, the buffer has dependencies that will cause
! 431: * it to be redirtied and it has not already been deferred,
! 432: * or it is already being written.
! 433: */
! 434: if (bp->b_flags & (B_BUSY | B_SCANNED))
! 435: continue;
! 436: if ((bp->b_flags & B_DELWRI) == 0)
! 437: panic("ffs_fsync: not dirty");
! 438: if (skipmeta && bp->b_lblkno < 0)
! 439: continue;
! 440: if (ap->a_waitfor != MNT_WAIT &&
! 441: LIST_FIRST(&bp->b_dep) != NULL &&
! 442: (bp->b_flags & B_DEFERRED) == 0 &&
! 443: buf_countdeps(bp, 0, 1)) {
! 444: bp->b_flags |= B_DEFERRED;
! 445: continue;
! 446: }
! 447:
! 448: bremfree(bp);
! 449: bp->b_flags |= B_BUSY | B_SCANNED;
! 450: splx(s);
! 451: /*
! 452: * On our final pass through, do all I/O synchronously
! 453: * so that we can find out if our flush is failing
! 454: * because of write errors.
! 455: */
! 456: if (passes > 0 || ap->a_waitfor != MNT_WAIT)
! 457: (void) bawrite(bp);
! 458: else if ((error = bwrite(bp)) != 0)
! 459: return (error);
! 460: s = splbio();
! 461: /*
! 462: * Since we may have slept during the I/O, we need
! 463: * to start from a known point.
! 464: */
! 465: nbp = LIST_FIRST(&vp->v_dirtyblkhd);
! 466: }
! 467: if (skipmeta) {
! 468: skipmeta = 0;
! 469: goto loop;
! 470: }
! 471: if (ap->a_waitfor == MNT_WAIT) {
! 472: vwaitforio(vp, 0, "ffs_fsync", 0);
! 473:
! 474: /*
! 475: * Ensure that any filesystem metadata associated
! 476: * with the vnode has been written.
! 477: */
! 478: splx(s);
! 479: if ((error = softdep_sync_metadata(ap)) != 0)
! 480: return (error);
! 481: s = splbio();
! 482: if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
! 483: /*
! 484: * Block devices associated with filesystems may
! 485: * have new I/O requests posted for them even if
! 486: * the vnode is locked, so no amount of trying will
! 487: * get them clean. Thus we give block devices a
! 488: * good effort, then just give up. For all other file
! 489: * types, go around and try again until it is clean.
! 490: */
! 491: if (passes > 0) {
! 492: passes -= 1;
! 493: goto loop;
! 494: }
! 495: #ifdef DIAGNOSTIC
! 496: if (vp->v_type != VBLK)
! 497: vprint("ffs_fsync: dirty", vp);
! 498: #endif
! 499: }
! 500: }
! 501: splx(s);
! 502: return (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
! 503: }
! 504:
! 505: /*
! 506: * Reclaim an inode so that it can be used for other purposes.
! 507: */
! 508: int
! 509: ffs_reclaim(void *v)
! 510: {
! 511: struct vop_reclaim_args *ap = v;
! 512: struct vnode *vp = ap->a_vp;
! 513: struct inode *ip = VTOI(vp);
! 514: int error;
! 515:
! 516: if ((error = ufs_reclaim(vp, ap->a_p)) != 0)
! 517: return (error);
! 518:
! 519: if (ip->i_din1 != NULL) {
! 520: #ifdef FFS2
! 521: if (ip->i_ump->um_fstype == UM_UFS2)
! 522: pool_put(&ffs_dinode2_pool, ip->i_din2);
! 523: else
! 524: #endif
! 525: pool_put(&ffs_dinode1_pool, ip->i_din1);
! 526: }
! 527:
! 528: pool_put(&ffs_ino_pool, ip);
! 529:
! 530: vp->v_data = NULL;
! 531:
! 532: return (0);
! 533: }
! 534:
! 535: #ifdef FIFO
! 536: int
! 537: ffsfifo_reclaim(void *v)
! 538: {
! 539: fifo_reclaim(v);
! 540: return (ffs_reclaim(v));
! 541: }
! 542: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ffs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ffs