changes for whiteouts and union filesystem

[unix-history] / usr / src / sys / ufs / ffs / ffs_vnops.c

diff --git a/usr/src/sys/ufs/ffs/ffs_vnops.c b/usr/src/sys/ufs/ffs/ffs_vnops.c
index 31f5e0a..f49458c 100644 (file)
--- a/usr/src/sys/ufs/ffs/ffs_vnops.c
+++ b/usr/src/sys/ufs/ffs/ffs_vnops.c
@@ -1,10 +1,10 @@
 /*
 /*

- * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)ffs_vnops.c 7.69 (Berkeley) %G%
+ *     @(#)ffs_vnops.c 8.9 (Berkeley) %G%

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>


@@ -18,10 +18,13 @@
 #include <sys/conf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/conf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>

-#include <sys/specdev.h>
-#include <sys/fifo.h>

 #include <sys/malloc.h>
 
 #include <sys/malloc.h>
 

+#include <vm/vm.h>
+
+#include <miscfs/specfs/specdev.h>
+#include <miscfs/fifofs/fifo.h>
+

 #include <ufs/ufs/lockf.h>
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 #include <ufs/ufs/lockf.h>
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>


@@ -32,365 +35,248 @@
 #include <ufs/ffs/ffs_extern.h>
 
 /* Global vfs data structures for ufs. */
 #include <ufs/ffs/ffs_extern.h>
 
 /* Global vfs data structures for ufs. */

-struct vnodeops ffs_vnodeops = {
-       ufs_lookup,             /* lookup */
-       ufs_create,             /* create */
-       ufs_mknod,              /* mknod */
-       ufs_open,               /* open */
-       ufs_close,              /* close */
-       ufs_access,             /* access */
-       ufs_getattr,            /* getattr */
-       ufs_setattr,            /* setattr */
-       ffs_read,               /* read */
-       ffs_write,              /* write */
-       ufs_ioctl,              /* ioctl */
-       ufs_select,             /* select */
-       ufs_mmap,               /* mmap */
-       ffs_fsync,              /* fsync */
-       ufs_seek,               /* seek */
-       ufs_remove,             /* remove */
-       ufs_link,               /* link */
-       ufs_rename,             /* rename */
-       ufs_mkdir,              /* mkdir */
-       ufs_rmdir,              /* rmdir */
-       ufs_symlink,            /* symlink */
-       ufs_readdir,            /* readdir */
-       ufs_readlink,           /* readlink */
-       ufs_abortop,            /* abortop */
-       ffs_inactive,           /* inactive */
-       ufs_reclaim,            /* reclaim */
-       ufs_lock,               /* lock */
-       ufs_unlock,             /* unlock */
-       ffs_bmap,               /* bmap */
-       ufs_strategy,           /* strategy */
-       ufs_print,              /* print */
-       ufs_islocked,           /* islocked */
-       ufs_advlock,            /* advlock */
-       ffs_blkatoff,           /* blkatoff */
-       ffs_vget,               /* vget */
-       ffs_valloc,             /* valloc */
-       ffs_vfree,              /* vfree */
-       ffs_truncate,           /* truncate */
-       ffs_update,             /* update */
-       bwrite,                 /* bwrite */
+int (**ffs_vnodeop_p)();
+struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
+       { &vop_default_desc, vn_default_error },
+       { &vop_lookup_desc, ufs_lookup },               /* lookup */
+       { &vop_create_desc, ufs_create },               /* create */
+       { &vop_whiteout_desc, ufs_whiteout },           /* whiteout */
+       { &vop_mknod_desc, ufs_mknod },                 /* mknod */
+       { &vop_open_desc, ufs_open },                   /* open */
+       { &vop_close_desc, ufs_close },                 /* close */
+       { &vop_access_desc, ufs_access },               /* access */
+       { &vop_getattr_desc, ufs_getattr },             /* getattr */
+       { &vop_setattr_desc, ufs_setattr },             /* setattr */
+       { &vop_read_desc, ffs_read },                   /* read */
+       { &vop_write_desc, ffs_write },                 /* write */
+       { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
+       { &vop_select_desc, ufs_select },               /* select */
+       { &vop_mmap_desc, ufs_mmap },                   /* mmap */
+       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
+       { &vop_seek_desc, ufs_seek },                   /* seek */
+       { &vop_remove_desc, ufs_remove },               /* remove */
+       { &vop_link_desc, ufs_link },                   /* link */
+       { &vop_rename_desc, ufs_rename },               /* rename */
+       { &vop_mkdir_desc, ufs_mkdir },                 /* mkdir */
+       { &vop_rmdir_desc, ufs_rmdir },                 /* rmdir */
+       { &vop_symlink_desc, ufs_symlink },             /* symlink */
+       { &vop_readdir_desc, ufs_readdir },             /* readdir */
+       { &vop_readlink_desc, ufs_readlink },           /* readlink */
+       { &vop_abortop_desc, ufs_abortop },             /* abortop */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
+       { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
+       { &vop_lock_desc, ufs_lock },                   /* lock */
+       { &vop_unlock_desc, ufs_unlock },               /* unlock */
+       { &vop_bmap_desc, ufs_bmap },                   /* bmap */
+       { &vop_strategy_desc, ufs_strategy },           /* strategy */
+       { &vop_print_desc, ufs_print },                 /* print */
+       { &vop_islocked_desc, ufs_islocked },           /* islocked */
+       { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */
+       { &vop_advlock_desc, ufs_advlock },             /* advlock */
+       { &vop_blkatoff_desc, ffs_blkatoff },           /* blkatoff */
+       { &vop_valloc_desc, ffs_valloc },               /* valloc */
+       { &vop_reallocblks_desc, ffs_reallocblks },     /* reallocblks */
+       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
+       { &vop_truncate_desc, ffs_truncate },           /* truncate */
+       { &vop_update_desc, ffs_update },               /* update */
+       { &vop_bwrite_desc, vn_bwrite },
+       { (struct vnodeop_desc*)NULL, (int(*)())NULL }

 };
 };

+struct vnodeopv_desc ffs_vnodeop_opv_desc =
+       { &ffs_vnodeop_p, ffs_vnodeop_entries };

 
 

-struct vnodeops ffs_specops = {
-       spec_lookup,            /* lookup */
-       spec_create,            /* create */
-       spec_mknod,             /* mknod */
-       spec_open,              /* open */
-       ufsspec_close,          /* close */
-       ufs_access,             /* access */
-       ufs_getattr,            /* getattr */
-       ufs_setattr,            /* setattr */
-       ufsspec_read,           /* read */
-       ufsspec_write,          /* write */
-       spec_ioctl,             /* ioctl */
-       spec_select,            /* select */
-       spec_mmap,              /* mmap */
-       spec_fsync,             /* fsync */
-       spec_seek,              /* seek */
-       spec_remove,            /* remove */
-       spec_link,              /* link */
-       spec_rename,            /* rename */
-       spec_mkdir,             /* mkdir */
-       spec_rmdir,             /* rmdir */
-       spec_symlink,           /* symlink */
-       spec_readdir,           /* readdir */
-       spec_readlink,          /* readlink */
-       spec_abortop,           /* abortop */
-       ffs_inactive,           /* inactive */
-       ufs_reclaim,            /* reclaim */
-       ufs_lock,               /* lock */
-       ufs_unlock,             /* unlock */
-       spec_bmap,              /* bmap */
-       spec_strategy,          /* strategy */
-       ufs_print,              /* print */
-       ufs_islocked,           /* islocked */
-       spec_advlock,           /* advlock */
-       spec_blkatoff,          /* blkatoff */
-       spec_vget,              /* vget */
-       spec_valloc,            /* valloc */
-       spec_vfree,             /* vfree */
-       spec_truncate,          /* truncate */
-       ffs_update,             /* update */
-       bwrite,                 /* bwrite */
+int (**ffs_specop_p)();
+struct vnodeopv_entry_desc ffs_specop_entries[] = {
+       { &vop_default_desc, vn_default_error },
+       { &vop_lookup_desc, spec_lookup },              /* lookup */
+       { &vop_create_desc, spec_create },              /* create */
+       { &vop_mknod_desc, spec_mknod },                /* mknod */
+       { &vop_open_desc, spec_open },                  /* open */
+       { &vop_close_desc, ufsspec_close },             /* close */
+       { &vop_access_desc, ufs_access },               /* access */
+       { &vop_getattr_desc, ufs_getattr },             /* getattr */
+       { &vop_setattr_desc, ufs_setattr },             /* setattr */
+       { &vop_read_desc, ufsspec_read },               /* read */
+       { &vop_write_desc, ufsspec_write },             /* write */
+       { &vop_ioctl_desc, spec_ioctl },                /* ioctl */
+       { &vop_select_desc, spec_select },              /* select */
+       { &vop_mmap_desc, spec_mmap },                  /* mmap */
+       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
+       { &vop_seek_desc, spec_seek },                  /* seek */
+       { &vop_remove_desc, spec_remove },              /* remove */
+       { &vop_link_desc, spec_link },                  /* link */
+       { &vop_rename_desc, spec_rename },              /* rename */
+       { &vop_mkdir_desc, spec_mkdir },                /* mkdir */
+       { &vop_rmdir_desc, spec_rmdir },                /* rmdir */
+       { &vop_symlink_desc, spec_symlink },            /* symlink */
+       { &vop_readdir_desc, spec_readdir },            /* readdir */
+       { &vop_readlink_desc, spec_readlink },          /* readlink */
+       { &vop_abortop_desc, spec_abortop },            /* abortop */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
+       { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
+       { &vop_lock_desc, ufs_lock },                   /* lock */
+       { &vop_unlock_desc, ufs_unlock },               /* unlock */
+       { &vop_bmap_desc, spec_bmap },                  /* bmap */
+       { &vop_strategy_desc, spec_strategy },          /* strategy */
+       { &vop_print_desc, ufs_print },                 /* print */
+       { &vop_islocked_desc, ufs_islocked },           /* islocked */
+       { &vop_pathconf_desc, spec_pathconf },          /* pathconf */
+       { &vop_advlock_desc, spec_advlock },            /* advlock */
+       { &vop_blkatoff_desc, spec_blkatoff },          /* blkatoff */
+       { &vop_valloc_desc, spec_valloc },              /* valloc */
+       { &vop_reallocblks_desc, spec_reallocblks },    /* reallocblks */
+       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
+       { &vop_truncate_desc, spec_truncate },          /* truncate */
+       { &vop_update_desc, ffs_update },               /* update */
+       { &vop_bwrite_desc, vn_bwrite },
+       { (struct vnodeop_desc*)NULL, (int(*)())NULL }

 };
 };

+struct vnodeopv_desc ffs_specop_opv_desc =
+       { &ffs_specop_p, ffs_specop_entries };

 
 #ifdef FIFO
 
 #ifdef FIFO

-struct vnodeops ffs_fifoops = {
-       fifo_lookup,            /* lookup */
-       fifo_create,            /* create */
-       fifo_mknod,             /* mknod */
-       fifo_open,              /* open */
-       ufsfifo_close,          /* close */
-       ufs_access,             /* access */
-       ufs_getattr,            /* getattr */
-       ufs_setattr,            /* setattr */
-       ufsfifo_read,           /* read */
-       ufsfifo_write,          /* write */
-       fifo_ioctl,             /* ioctl */
-       fifo_select,            /* select */
-       fifo_mmap,              /* mmap */
-       fifo_fsync,             /* fsync */
-       fifo_seek,              /* seek */
-       fifo_remove,            /* remove */
-       fifo_link,              /* link */
-       fifo_rename,            /* rename */
-       fifo_mkdir,             /* mkdir */
-       fifo_rmdir,             /* rmdir */
-       fifo_symlink,           /* symlink */
-       fifo_readdir,           /* readdir */
-       fifo_readlink,          /* readlink */
-       fifo_abortop,           /* abortop */
-       ffs_inactive,           /* inactive */
-       ufs_reclaim,            /* reclaim */
-       ufs_lock,               /* lock */
-       ufs_unlock,             /* unlock */
-       fifo_bmap,              /* bmap */
-       fifo_strategy,          /* strategy */
-       ufs_print,              /* print */
-       ufs_islocked,           /* islocked */
-       fifo_advlock,           /* advlock */
-       fifo_blkatoff,          /* blkatoff */
-       fifo_vget,              /* vget */
-       fifo_valloc,            /* valloc */
-       fifo_vfree,             /* vfree */
-       fifo_truncate,          /* truncate */
-       ffs_update,             /* update */
-       bwrite,                 /* bwrite */
+int (**ffs_fifoop_p)();
+struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
+       { &vop_default_desc, vn_default_error },
+       { &vop_lookup_desc, fifo_lookup },              /* lookup */
+       { &vop_create_desc, fifo_create },              /* create */
+       { &vop_mknod_desc, fifo_mknod },                /* mknod */
+       { &vop_open_desc, fifo_open },                  /* open */
+       { &vop_close_desc, ufsfifo_close },             /* close */
+       { &vop_access_desc, ufs_access },               /* access */
+       { &vop_getattr_desc, ufs_getattr },             /* getattr */
+       { &vop_setattr_desc, ufs_setattr },             /* setattr */
+       { &vop_read_desc, ufsfifo_read },               /* read */
+       { &vop_write_desc, ufsfifo_write },             /* write */
+       { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
+       { &vop_select_desc, fifo_select },              /* select */
+       { &vop_mmap_desc, fifo_mmap },                  /* mmap */
+       { &vop_fsync_desc, ffs_fsync },                 /* fsync */
+       { &vop_seek_desc, fifo_seek },                  /* seek */
+       { &vop_remove_desc, fifo_remove },              /* remove */
+       { &vop_link_desc, fifo_link },                  /* link */
+       { &vop_rename_desc, fifo_rename },              /* rename */
+       { &vop_mkdir_desc, fifo_mkdir },                /* mkdir */
+       { &vop_rmdir_desc, fifo_rmdir },                /* rmdir */
+       { &vop_symlink_desc, fifo_symlink },            /* symlink */
+       { &vop_readdir_desc, fifo_readdir },            /* readdir */
+       { &vop_readlink_desc, fifo_readlink },          /* readlink */
+       { &vop_abortop_desc, fifo_abortop },            /* abortop */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
+       { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
+       { &vop_lock_desc, ufs_lock },                   /* lock */
+       { &vop_unlock_desc, ufs_unlock },               /* unlock */
+       { &vop_bmap_desc, fifo_bmap },                  /* bmap */
+       { &vop_strategy_desc, fifo_strategy },          /* strategy */
+       { &vop_print_desc, ufs_print },                 /* print */
+       { &vop_islocked_desc, ufs_islocked },           /* islocked */
+       { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
+       { &vop_advlock_desc, fifo_advlock },            /* advlock */
+       { &vop_blkatoff_desc, fifo_blkatoff },          /* blkatoff */
+       { &vop_valloc_desc, fifo_valloc },              /* valloc */
+       { &vop_reallocblks_desc, fifo_reallocblks },    /* reallocblks */
+       { &vop_vfree_desc, ffs_vfree },                 /* vfree */
+       { &vop_truncate_desc, fifo_truncate },          /* truncate */
+       { &vop_update_desc, ffs_update },               /* update */
+       { &vop_bwrite_desc, vn_bwrite },
+       { (struct vnodeop_desc*)NULL, (int(*)())NULL }

 };
 };

+struct vnodeopv_desc ffs_fifoop_opv_desc =
+       { &ffs_fifoop_p, ffs_fifoop_entries };

 #endif /* FIFO */
 
 #endif /* FIFO */
 

-
+#ifdef DEBUG

 /*
 /*

- * Vnode op for reading.
+ * Enabling cluster read/write operations.

  */
  */

-/* ARGSUSED */
-ffs_read(vp, uio, ioflag, cred)
-       struct vnode *vp;
-       register struct uio *uio;
-       int ioflag;
-       struct ucred *cred;
-{
-       register struct inode *ip = VTOI(vp);
-       register struct fs *fs;
-       struct buf *bp;
-       daddr_t lbn, bn, rablock;
-       int size, rasize, diff, error = 0;
-       long n, on, type;
-
-#ifdef DIAGNOSTIC
-       if (uio->uio_rw != UIO_READ)
-               panic("ffs_read mode");
-       type = ip->i_mode & IFMT;
-       if (type != IFDIR && type != IFREG && type != IFLNK)
-               panic("ffs_read type");
+#include <sys/sysctl.h>
+int doclusterread = 1;
+struct ctldebug debug11 = { "doclusterread", &doclusterread };
+int doclusterwrite = 1;
+struct ctldebug debug12 = { "doclusterwrite", &doclusterwrite };
+#else
+/* XXX for ufs_readwrite */
+#define doclusterread 1
+#define doclusterwrite 1

 #endif
 #endif

-       if (uio->uio_resid == 0)
-               return (0);
-       if (uio->uio_offset < 0)
-               return (EINVAL);
-       ip->i_flag |= IACC;
-       fs = ip->i_fs;
-       do {
-               lbn = lblkno(fs, uio->uio_offset);
-               on = blkoff(fs, uio->uio_offset);
-               n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
-               diff = ip->i_size - uio->uio_offset;
-               if (diff <= 0)
-                       return (0);
-               if (diff < n)
-                       n = diff;
-               size = blksize(fs, ip, lbn);
-               rablock = lbn + 1;
-               if (vp->v_lastr + 1 == lbn &&
-                   lblktosize(fs, rablock) < ip->i_size) {
-                       rasize = blksize(fs, ip, rablock);
-                       error = breadn(ITOV(ip), lbn, size, &rablock,
-                               &rasize, 1, NOCRED, &bp);
-               } else
-                       error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
-               vp->v_lastr = lbn;
-               n = MIN(n, size - bp->b_resid);
-               if (error) {
-                       brelse(bp);
-                       return (error);
-               }
-               error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
-               if (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size)
-                       bp->b_flags |= B_AGE;
-               brelse(bp);
-       } while (error == 0 && uio->uio_resid > 0 && n != 0);
-       return (error);
-}
+
+#include <ufs/ufs/ufs_readwrite.c>

 
 /*
 
 /*

- * Vnode op for writing.
+ * Synch an open file.

  */
  */

-ffs_write(vp, uio, ioflag, cred)
-       register struct vnode *vp;
-       struct uio *uio;
-       int ioflag;
-       struct ucred *cred;
+/* ARGSUSED */
+int
+ffs_fsync(ap)
+       struct vop_fsync_args /* {
+               struct vnode *a_vp;
+               struct ucred *a_cred;
+               int a_waitfor;
+               struct proc *a_p;
+       } */ *ap;

 {
 {

-       struct proc *p = uio->uio_procp;
-       register struct inode *ip = VTOI(vp);
-       register struct fs *fs;
-       struct buf *bp;
-       daddr_t lbn, bn;
-       u_long osize;
-       int n, on, flags;
-       int size, resid, error = 0;
-
-#ifdef DIAGNOSTIC
-       if (uio->uio_rw != UIO_WRITE)
-               panic("ffs_write mode");
-#endif
-       switch (vp->v_type) {
-       case VREG:
-               if (ioflag & IO_APPEND)
-                       uio->uio_offset = ip->i_size;
-               /* fall through */
-       case VLNK:
-               break;
+       register struct vnode *vp = ap->a_vp;
+       register struct buf *bp;
+       struct timeval tv;
+       struct buf *nbp;
+       int s;

 
 

-       case VDIR:
-               if ((ioflag & IO_SYNC) == 0)
-                       panic("ffs_write nonsync dir write");
-               break;
-
-       default:
-               panic("ffs_write type");
-       }
-       if (uio->uio_offset < 0)
-               return (EINVAL);
-       if (uio->uio_resid == 0)
-               return (0);

        /*
        /*

-        * Maybe this should be above the vnode op call, but so long as
-        * file servers have no limits, i don't think it matters
+        * Flush all dirty buffers associated with a vnode.

         */
         */

-       if (vp->v_type == VREG && p &&
-           uio->uio_offset + uio->uio_resid >
-             p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
-               psignal(p, SIGXFSZ);
-               return (EFBIG);
-       }
-       resid = uio->uio_resid;
-       osize = ip->i_size;
-       fs = ip->i_fs;
-       flags = 0;
-       if (ioflag & IO_SYNC)
-               flags = B_SYNC;
-       do {
-               lbn = lblkno(fs, uio->uio_offset);
-               on = blkoff(fs, uio->uio_offset);
-               n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
-               if (n < fs->fs_bsize)
-                       flags |= B_CLRBUF;
+loop:
+       s = splbio();
+       for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
+               nbp = bp->b_vnbufs.le_next;
+               if ((bp->b_flags & B_BUSY))
+                       continue;
+               if ((bp->b_flags & B_DELWRI) == 0)
+                       panic("ffs_fsync: not dirty");
+               bremfree(bp);
+               bp->b_flags |= B_BUSY;
+               splx(s);
+               /*
+                * Wait for I/O associated with indirect blocks to complete,
+                * since there is no way to quickly wait for them below.
+                */
+               if (bp->b_vp == vp || ap->a_waitfor == MNT_NOWAIT)
+                       (void) bawrite(bp);

                else
                else

-                       flags &= ~B_CLRBUF;
-               if (error = ffs_balloc(ip, lbn, (int)(on + n), &bp, flags))
-                       break;
-               bn = bp->b_blkno;
-               if (uio->uio_offset + n > ip->i_size) {
-                       ip->i_size = uio->uio_offset + n;
-                       vnode_pager_setsize(vp, (u_long)ip->i_size);
-               }
-               size = blksize(fs, ip, lbn);
-               (void) vnode_pager_uncache(vp);
-               n = MIN(n, size - bp->b_resid);
-               error = uiomove(bp->b_un.b_addr + on, n, uio);
-               if (ioflag & IO_SYNC)

                        (void) bwrite(bp);
                        (void) bwrite(bp);

-               else if (n + on == fs->fs_bsize) {
-                       bp->b_flags |= B_AGE;
-                       bawrite(bp);
-               } else
-                       bdwrite(bp);
-               ip->i_flag |= IUPD|ICHG;
-               if (cred->cr_uid != 0)
-                       ip->i_mode &= ~(ISUID|ISGID);
-       } while (error == 0 && uio->uio_resid > 0 && n != 0);
-       if (error && (ioflag & IO_UNIT)) {
-               (void)ffs_truncate(vp, osize, ioflag & IO_SYNC);
-               uio->uio_offset -= resid - uio->uio_resid;
-               uio->uio_resid = resid;
+               goto loop;

        }
        }

-       if (!error && (ioflag & IO_SYNC))
-               error = ffs_update(vp, &time, &time, 1);
-       return (error);
-}
-
-/*
- * Synch an open file.
- */
-/* ARGSUSED */
-int
-ffs_fsync(vp, fflags, cred, waitfor, p)
-       struct vnode *vp;
-       int fflags;
-       struct ucred *cred;
-       int waitfor;
-       struct proc *p;
-{
-       struct inode *ip = VTOI(vp);
-
-       if (fflags & FWRITE)
-               ip->i_flag |= ICHG;
-       vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0);
-       return (ffs_update(vp, &time, &time, waitfor == MNT_WAIT));
+       if (ap->a_waitfor == MNT_WAIT) {
+               while (vp->v_numoutput) {
+                       vp->v_flag |= VBWAIT;
+                       sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1);
+               }
+#ifdef DIAGNOSTIC
+               if (vp->v_dirtyblkhd.lh_first) {
+                       vprint("ffs_fsync: dirty", vp);
+                       goto loop;
+               }
+#endif
+       }
+       splx(s);
+       tv = time;
+       return (VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT));

 }
 
 /*
 }
 
 /*

- * Last reference to an inode, write the inode out and if necessary,
- * truncate and deallocate the file.
+ * Reclaim an inode so that it can be used for other purposes.

  */
 int
  */
 int

-ffs_inactive(vp, p)
-       struct vnode *vp;
-       struct proc *p;
+ffs_reclaim(ap)
+       struct vop_reclaim_args /* {
+               struct vnode *a_vp;
+       } */ *ap;

 {
 {

-       register struct inode *ip;
-       int mode, error;
-       extern int prtactive;
-
-       if (prtactive && vp->v_usecount != 0)
-               vprint("ffs_inactive: pushing active", vp);
-
-       /* Get rid of inodes related to stale file handles. */
-       ip = VTOI(vp);
-       if (ip->i_mode == 0) {
-               if ((vp->v_flag & VXLOCK) == 0)
-                       vgone(vp);
-               return (0);
-       }
+       register struct vnode *vp = ap->a_vp;
+       int error;

 
 

-       error = 0;
-       ILOCK(ip);
-       if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-#ifdef QUOTA
-               if (!getinoquota(ip))
-                       (void)chkiq(ip, -1, NOCRED, 0);
-#endif
-               error = ffs_truncate(vp, (u_long)0, 0);
-               mode = ip->i_mode;
-               ip->i_mode = 0;
-               ip->i_rdev = 0;
-               ip->i_flag |= IUPD|ICHG;
-               ffs_vfree(vp, ip->i_number, mode);
-       }
-       if (ip->i_flag&(IUPD|IACC|ICHG|IMOD))
-               ffs_update(vp, &time, &time, 0);
-       IUNLOCK(ip);
-       ip->i_flag = 0;
-       /*
-        * If we are done with the inode, reclaim it
-        * so that it can be reused immediately.
-        */
-       if (vp->v_usecount == 0 && ip->i_mode == 0)
-               vgone(vp);
-       return (error);
+       if (error = ufs_reclaim(vp))
+               return (error);
+       FREE(vp->v_data, M_FFSNODE);
+       vp->v_data = NULL;
+       return (0);

 }
 }