merge {lfs,ffs}_{read,write}; Cleanups for 4.4BSD-Lite
[unix-history] / usr / src / sys / ufs / lfs / lfs_vnops.c
index 6627431..97f51d1 100644 (file)
@@ -1,10 +1,10 @@
 /*
 /*
- * Copyright (c) 1986, 1989, 1991 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *
- *     @(#)lfs_vnops.c 7.87 (Berkeley) %G%
+ *     @(#)lfs_vnops.c 8.2 (Berkeley) %G%
  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>
 #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 <vm/vm.h>
 
 #include <sys/malloc.h>
 
 #include <vm/vm.h>
 
+#include <miscfs/specfs/specdev.h>
+#include <miscfs/fifofs/fifo.h>
+
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 #include <ufs/ufs/dir.h>
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 #include <ufs/ufs/dir.h>
+#include <ufs/ufs/ufsmount.h>
 #include <ufs/ufs/ufs_extern.h>
 
 #include <ufs/lfs/lfs.h>
 #include <ufs/ufs/ufs_extern.h>
 
 #include <ufs/lfs/lfs.h>
@@ -38,12 +40,12 @@ int (**lfs_vnodeop_p)();
 struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
        { &vop_default_desc, vn_default_error },
        { &vop_lookup_desc, ufs_lookup },               /* lookup */
 struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
        { &vop_default_desc, vn_default_error },
        { &vop_lookup_desc, ufs_lookup },               /* lookup */
-       { &vop_create_desc, lfs_create },               /* create */
-       { &vop_mknod_desc, lfs_mknod },                 /* mknod */
+       { &vop_create_desc, ufs_create },               /* create */
+       { &vop_mknod_desc, ufs_mknod },                 /* mknod */
        { &vop_open_desc, ufs_open },                   /* open */
        { &vop_open_desc, ufs_open },                   /* open */
-       { &vop_close_desc, ufs_close },                 /* close */
+       { &vop_close_desc, lfs_close },                 /* close */
        { &vop_access_desc, ufs_access },               /* access */
        { &vop_access_desc, ufs_access },               /* access */
-       { &vop_getattr_desc, ufs_getattr },             /* getattr */
+       { &vop_getattr_desc, lfs_getattr },             /* getattr */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, lfs_read },                   /* read */
        { &vop_write_desc, lfs_write },                 /* write */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, lfs_read },                   /* read */
        { &vop_write_desc, lfs_write },                 /* write */
@@ -52,23 +54,24 @@ struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
        { &vop_mmap_desc, ufs_mmap },                   /* mmap */
        { &vop_fsync_desc, lfs_fsync },                 /* fsync */
        { &vop_seek_desc, ufs_seek },                   /* seek */
        { &vop_mmap_desc, ufs_mmap },                   /* mmap */
        { &vop_fsync_desc, lfs_fsync },                 /* fsync */
        { &vop_seek_desc, ufs_seek },                   /* seek */
-       { &vop_remove_desc, lfs_remove },               /* remove */
-       { &vop_link_desc, lfs_link },                   /* link */
-       { &vop_rename_desc, lfs_rename },               /* rename */
-       { &vop_mkdir_desc, lfs_mkdir },                 /* mkdir */
-       { &vop_rmdir_desc, lfs_rmdir },                 /* rmdir */
-       { &vop_symlink_desc, lfs_symlink },             /* symlink */
+       { &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_readdir_desc, ufs_readdir },             /* readdir */
        { &vop_readlink_desc, ufs_readlink },           /* readlink */
        { &vop_abortop_desc, ufs_abortop },             /* abortop */
-       { &vop_inactive_desc, lfs_inactive },           /* inactive */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
-       { &vop_bmap_desc, lfs_bmap },                   /* bmap */
+       { &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_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, lfs_blkatoff },           /* blkatoff */
        { &vop_valloc_desc, lfs_valloc },               /* valloc */
        { &vop_advlock_desc, ufs_advlock },             /* advlock */
        { &vop_blkatoff_desc, lfs_blkatoff },           /* blkatoff */
        { &vop_valloc_desc, lfs_valloc },               /* valloc */
@@ -90,7 +93,7 @@ struct vnodeopv_entry_desc lfs_specop_entries[] = {
        { &vop_open_desc, spec_open },                  /* open */
        { &vop_close_desc, ufsspec_close },             /* close */
        { &vop_access_desc, ufs_access },               /* access */
        { &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_getattr_desc, lfs_getattr },             /* getattr */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, ufsspec_read },               /* read */
        { &vop_write_desc, ufsspec_write },             /* write */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, ufsspec_read },               /* read */
        { &vop_write_desc, ufsspec_write },             /* write */
@@ -108,7 +111,7 @@ struct vnodeopv_entry_desc lfs_specop_entries[] = {
        { &vop_readdir_desc, spec_readdir },            /* readdir */
        { &vop_readlink_desc, spec_readlink },          /* readlink */
        { &vop_abortop_desc, spec_abortop },            /* abortop */
        { &vop_readdir_desc, spec_readdir },            /* readdir */
        { &vop_readlink_desc, spec_readlink },          /* readlink */
        { &vop_abortop_desc, spec_abortop },            /* abortop */
-       { &vop_inactive_desc, lfs_inactive },           /* inactive */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
@@ -116,6 +119,7 @@ struct vnodeopv_entry_desc lfs_specop_entries[] = {
        { &vop_strategy_desc, spec_strategy },          /* strategy */
        { &vop_print_desc, ufs_print },                 /* print */
        { &vop_islocked_desc, ufs_islocked },           /* islocked */
        { &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_advlock_desc, spec_advlock },            /* advlock */
        { &vop_blkatoff_desc, spec_blkatoff },          /* blkatoff */
        { &vop_valloc_desc, spec_valloc },              /* valloc */
@@ -138,7 +142,7 @@ struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
        { &vop_open_desc, fifo_open },                  /* open */
        { &vop_close_desc, ufsfifo_close },             /* close */
        { &vop_access_desc, ufs_access },               /* access */
        { &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_getattr_desc, lfs_getattr },             /* getattr */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, ufsfifo_read },               /* read */
        { &vop_write_desc, ufsfifo_write },             /* write */
        { &vop_setattr_desc, ufs_setattr },             /* setattr */
        { &vop_read_desc, ufsfifo_read },               /* read */
        { &vop_write_desc, ufsfifo_write },             /* write */
@@ -156,7 +160,7 @@ struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
        { &vop_readdir_desc, fifo_readdir },            /* readdir */
        { &vop_readlink_desc, fifo_readlink },          /* readlink */
        { &vop_abortop_desc, fifo_abortop },            /* abortop */
        { &vop_readdir_desc, fifo_readdir },            /* readdir */
        { &vop_readlink_desc, fifo_readlink },          /* readlink */
        { &vop_abortop_desc, fifo_abortop },            /* abortop */
-       { &vop_inactive_desc, lfs_inactive },           /* inactive */
+       { &vop_inactive_desc, ufs_inactive },           /* inactive */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
        { &vop_reclaim_desc, ufs_reclaim },             /* reclaim */
        { &vop_lock_desc, ufs_lock },                   /* lock */
        { &vop_unlock_desc, ufs_unlock },               /* unlock */
@@ -164,6 +168,7 @@ struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
        { &vop_strategy_desc, fifo_strategy },          /* strategy */
        { &vop_print_desc, ufs_print },                 /* print */
        { &vop_islocked_desc, ufs_islocked },           /* islocked */
        { &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_advlock_desc, fifo_advlock },            /* advlock */
        { &vop_blkatoff_desc, fifo_blkatoff },          /* blkatoff */
        { &vop_valloc_desc, fifo_valloc },              /* valloc */
@@ -177,187 +182,9 @@ struct vnodeopv_desc lfs_fifoop_opv_desc =
        { &lfs_fifoop_p, lfs_fifoop_entries };
 #endif /* FIFO */
 
        { &lfs_fifoop_p, lfs_fifoop_entries };
 #endif /* FIFO */
 
-/*
- * Vnode op for reading.
- */
-/* ARGSUSED */
-lfs_read(ap)
-       struct vop_read_args /* {
-               struct vnode *a_vp;
-               struct uio *a_uio;
-               int a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
-{
-       register struct uio *uio = ap->a_uio;
-       register struct inode *ip = VTOI(ap->a_vp);
-       register struct lfs *fs;                                /* LFS */
-       struct buf *bp;
-       daddr_t lbn, bn, rablock;
-       int size, error = 0;
-       long n, on, type;
-       off_t diff;
-
-#ifdef VERBOSE
-       printf("lfs_read: ino %d\n", ip->i_number);
-#endif
-#ifdef DIAGNOSTIC
-       if (uio->uio_rw != UIO_READ)
-               panic("ufs_read mode");
-       type = ip->i_mode & IFMT;
-       if (type != IFDIR && type != IFREG && type != IFLNK)
-               panic("ufs_read type");
-#endif
-       if (uio->uio_resid == 0)
-               return (0);
-       if (uio->uio_offset < 0)
-               return (EINVAL);
-       ip->i_flag |= IACC;
-
-       fs = ip->i_lfs;                                         /* LFS */
-       do {
-               lbn = lblkno(fs, uio->uio_offset);
-               on = blkoff(fs, uio->uio_offset);
-               n = MIN((unsigned)(fs->lfs_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);                             /* LFS */
-               rablock = lbn + 1;
-               if (ap->a_vp->v_lastr + 1 == lbn &&
-                   lblktosize(fs, rablock) < ip->i_size)
-                       error = breadn(ITOV(ip), lbn, size, &rablock,
-                               &size, 1, NOCRED, &bp);
-               else
-                       error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
-               ap->a_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->lfs_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);
-}
-
-/*
- * Vnode op for writing.
- */
-lfs_write(ap)
-       struct vop_write_args /* {
-               struct vnode *a_vp;
-               struct uio *a_uio;
-               int a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
-{
-       register struct vnode *vp = ap->a_vp;
-       register struct uio *uio = ap->a_uio;
-       struct proc *p = uio->uio_procp;
-       register struct inode *ip = VTOI(vp);
-       register struct lfs *fs;
-       register ioflag = ap->a_ioflag;
-       struct timeval tv;
-       struct buf *bp;
-       daddr_t lbn;
-       off_t osize;
-       int n, on, flags, newblock;
-       int size, resid, error = 0;
-
-#ifdef VERBOSE
-       printf("lfs_write ino %d\n", ip->i_number);
-#endif
-#ifdef DIAGNOSTIC
-       if (uio->uio_rw != UIO_WRITE)
-               panic("lfs_write mode");
-#endif
-       switch (vp->v_type) {
-       case VREG:
-               if (ioflag & IO_APPEND)
-                       uio->uio_offset = ip->i_size;
-               /* fall through */
-       case VLNK:
-               break;
-
-       case VDIR:
-               /* XXX This may not be correct for LFS. */
-               if ((ioflag & IO_SYNC) == 0)
-                       panic("lfs_write nonsync dir write");
-               break;
-
-       default:
-               panic("lfs_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
-        */
-       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_lfs;                                         /* LFS */
-       flags = 0;
-#ifdef NOTLFS
-       if (ioflag & IO_SYNC)
-               flags = B_SYNC;
-#endif
-       do {
-               lbn = lblkno(fs, uio->uio_offset);
-               on = blkoff(fs, uio->uio_offset);
-               n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
-               if (error = lfs_balloc(vp, n, lbn, &bp))
-                       break;
-               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);
-               (void) vnode_pager_uncache(vp);
-               n = MIN(n, size - bp->b_resid);
-               error = uiomove(bp->b_un.b_addr + on, n, uio);
-#ifdef NOTLFS                                                  /* LFS */
-               if (ioflag & IO_SYNC)
-                       (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;
-#else
-               /* XXX This doesn't handle IO_SYNC. */
-               LFS_UBWRITE(bp);
-#endif
-               if (ap->a_cred->cr_uid != 0)
-                       ip->i_mode &= ~(ISUID|ISGID);
-       } while (error == 0 && uio->uio_resid > 0 && n != 0);
-       if (error && (ioflag & IO_UNIT)) {
-               (void)VOP_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred,
-                   uio->uio_procp);
-               uio->uio_offset -= resid - uio->uio_resid;
-               uio->uio_resid = resid;
-       }
-       if (!error && (ioflag & IO_SYNC)) {
-               tv = time;
-               error = VOP_UPDATE(vp, &tv, &tv, 1);
-       }
-       return (error);
-}
+#define        LFS_READWRITE
+#include <ufs/ufs/ufs_readwrite.c>
+#undef LFS_READWRITE
 
 /*
  * Synch an open file.
 
 /*
  * Synch an open file.
@@ -373,70 +200,9 @@ lfs_fsync(ap)
 {
        struct timeval tv;
 
 {
        struct timeval tv;
 
-#ifdef VERBOSE
-       printf("lfs_fsync\n");
-#endif
        tv = time;
        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.
- */
-int
-lfs_inactive(ap)
-       struct vop_inactive_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
-{
-       extern int prtactive;
-       register struct vnode *vp = ap->a_vp;
-       register struct inode *ip;
-       struct timeval tv;
-       int mode, error;
-
-#ifdef VERBOSE
-       printf("lfs_inactive\n");
-#endif
-       if (prtactive && vp->v_usecount != 0)
-               vprint("lfs_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);
-       }
-
-       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 = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
-               mode = ip->i_mode;
-               ip->i_mode = 0;
-               ip->i_rdev = 0;
-               ip->i_flag |= IUPD|ICHG;
-               VOP_VFREE(vp, ip->i_number, mode);
-       }
-       if (ip->i_flag&(IUPD|IACC|ICHG|IMOD)) {
-               tv = time;
-               VOP_UPDATE(vp, &tv, &tv, 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);
+       return (VOP_UPDATE(ap->a_vp, &tv, &tv,
+           ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0));
 }
 
 /*
 }
 
 /*
@@ -445,22 +211,16 @@ lfs_inactive(ap)
  * be ordered and flushed atomically, so that they may be recovered.
  */
 #define        SET_DIROP(fs) {                                                 \
  * be ordered and flushed atomically, so that they may be recovered.
  */
 #define        SET_DIROP(fs) {                                                 \
-       int __s;                                                        \
-       __s = splbio();                                                 \
        if ((fs)->lfs_writer)                                           \
        if ((fs)->lfs_writer)                                           \
-               tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs dirop", 0);  \
+               tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);  \
        ++(fs)->lfs_dirops;                                             \
        (fs)->lfs_doifile = 1;                                          \
        ++(fs)->lfs_dirops;                                             \
        (fs)->lfs_doifile = 1;                                          \
-       splx(__s);                                                      \
 }
 
 #define        SET_ENDOP(fs) {                                                 \
 }
 
 #define        SET_ENDOP(fs) {                                                 \
-       int __s;                                                        \
-       __s = splbio();                                                 \
        --(fs)->lfs_dirops;                                             \
        if (!(fs)->lfs_dirops)                                          \
                wakeup(&(fs)->lfs_writer);                              \
        --(fs)->lfs_dirops;                                             \
        if (!(fs)->lfs_dirops)                                          \
                wakeup(&(fs)->lfs_writer);                              \
-       splx(__s);                                                      \
 }
 
 #define        MARK_VNODE(dvp) (dvp)->v_flag |= VDIROP
 }
 
 #define        MARK_VNODE(dvp) (dvp)->v_flag |= VDIROP
@@ -612,3 +372,74 @@ lfs_rename(ap)
        SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
        return (ret);
 }
        SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
        return (ret);
 }
+/* XXX hack to avoid calling ITIMES in getattr */
+int
+lfs_getattr(ap)
+       struct vop_getattr_args /* {
+               struct vnode *a_vp;
+               struct vattr *a_vap;
+               struct ucred *a_cred;
+               struct proc *a_p;
+       } */ *ap;
+{
+       register struct vnode *vp = ap->a_vp;
+       register struct inode *ip = VTOI(vp);
+       register struct vattr *vap = ap->a_vap;
+       /*
+        * Copy from inode table
+        */
+       vap->va_fsid = ip->i_dev;
+       vap->va_fileid = ip->i_number;
+       vap->va_mode = ip->i_mode & ~IFMT;
+       vap->va_nlink = ip->i_nlink;
+       vap->va_uid = ip->i_uid;
+       vap->va_gid = ip->i_gid;
+       vap->va_rdev = (dev_t)ip->i_rdev;
+       vap->va_size = ip->i_din.di_size;
+       vap->va_atime = ip->i_atime;
+       vap->va_mtime = ip->i_mtime;
+       vap->va_ctime = ip->i_ctime;
+       vap->va_flags = ip->i_flags;
+       vap->va_gen = ip->i_gen;
+       /* this doesn't belong here */
+       if (vp->v_type == VBLK)
+               vap->va_blocksize = BLKDEV_IOSIZE;
+       else if (vp->v_type == VCHR)
+               vap->va_blocksize = MAXBSIZE;
+       else
+               vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
+       vap->va_bytes = dbtob(ip->i_blocks);
+       vap->va_type = vp->v_type;
+       vap->va_filerev = ip->i_modrev;
+       return (0);
+}
+/*
+ * Close called
+ *
+ * XXX -- we were using ufs_close, but since it updates the
+ * times on the inode, we might need to bump the uinodes
+ * count.
+ */
+/* ARGSUSED */
+int
+lfs_close(ap)
+       struct vop_close_args /* {
+               struct vnode *a_vp;
+               int  a_fflag;
+               struct ucred *a_cred;
+               struct proc *a_p;
+       } */ *ap;
+{
+       register struct vnode *vp = ap->a_vp;
+       register struct inode *ip = VTOI(vp);
+       int mod;
+
+       if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) {
+               mod = ip->i_flag & IMOD;
+               ITIMES(ip, &time, &time);
+               if (!mod && ip->i_flag & IMOD)
+                       ip->i_lfs->lfs_uinodes++;
+       }
+       return (0);
+}
+