only delete space used by inode, on inode deletion; required
[unix-history] / usr / src / sys / ufs / lfs / lfs_vnops.c
index 51f84ed..8397c8d 100644 (file)
-/*     lfs_vnops.c     6.12    84/07/20        */
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/kernel.h"
-#include "../h/file.h"
-#include "../h/stat.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/buf.h"
-#include "../h/proc.h"
-#include "../h/quota.h"
-#include "../h/uio.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/mount.h"
-
-extern struct fileops inodeops;
-struct file *getinode();
-
-/*
- * Change current working directory (``.'').
- */
-chdir()
-{
-
-       chdirec(&u.u_cdir);
-}
-
-/*
- * Change notion of root (``/'') directory.
- */
-chroot()
-{
-
-       if (suser())
-               chdirec(&u.u_rdir);
-}
-
 /*
 /*
- * Common routine for chroot and chdir.
- */
-chdirec(ipp)
-       register struct inode **ipp;
-{
-       register struct inode *ip;
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) != IFDIR) {
-               u.u_error = ENOTDIR;
-               goto bad;
-       }
-       if (access(ip, IEXEC))
-               goto bad;
-       IUNLOCK(ip);
-       if (*ipp)
-               irele(*ipp);
-       *ipp = ip;
-       return;
-
-bad:
-       iput(ip);
-}
-
-/*
- * Open system call.
+ * Copyright (c) 1986, 1989, 1991 Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)lfs_vnops.c 7.77 (Berkeley) %G%
  */
  */
-open()
-{
-       struct a {
-               char    *fname;
-               int     mode;
-               int     crtmode;
-       } *uap = (struct a *) u.u_ap;
 
 
-       copen(uap->mode-FOPEN, uap->crtmode, uap->fname);
-}
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/resourcevar.h>
+#include <sys/kernel.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/buf.h>
+#include <sys/proc.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 <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <ufs/ufs/dir.h>
+#include <ufs/ufs/ufs_extern.h>
+
+#include <ufs/lfs/lfs.h>
+#include <ufs/lfs/lfs_extern.h>
+
+/* Global vfs data structures for lfs. */
+struct vnodeops lfs_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 */
+       lfs_read,               /* read */
+       lfs_write,              /* write */
+       ufs_ioctl,              /* ioctl */
+       ufs_select,             /* select */
+       ufs_mmap,               /* mmap */
+       lfs_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 */
+       lfs_inactive,           /* inactive */
+       ufs_reclaim,            /* reclaim */
+       ufs_lock,               /* lock */
+       ufs_unlock,             /* unlock */
+       lfs_bmap,               /* bmap */
+       ufs_strategy,           /* strategy */
+       ufs_print,              /* print */
+       ufs_islocked,           /* islocked */
+       ufs_advlock,            /* advlock */
+       lfs_blkatoff,           /* blkatoff */
+       lfs_vget,               /* vget */
+       lfs_valloc,             /* valloc */
+       lfs_vfree,              /* vfree */
+       lfs_truncate,           /* truncate */
+       lfs_update,             /* update */
+       lfs_bwrite,             /* bwrite */
+};
 
 
-/*
- * Creat system call.
- */
-creat()
-{
-       struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
+struct vnodeops lfs_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 */
+       lfs_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 */
+       lfs_update,             /* update */
+       lfs_bwrite,             /* bwrite */
+};
 
 
-       copen(FWRITE|FCREAT|FTRUNC, uap->fmode, uap->fname);
-}
+#ifdef FIFO
+struct vnodeops lfs_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 */
+       lfs_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 */
+       lfs_update,             /* update */
+       lfs_bwrite,             /* bwrite */
+};
+#endif /* FIFO */
 
 /*
 
 /*
- * Common code for open and creat.
- * Check permissions, allocate an open file structure,
- * and call the device open routine if any.
+ * Vnode op for reading.
  */
  */
-copen(mode, arg, fname)
-       register int mode;
-       int arg;
-       caddr_t fname;
-{
-       register struct inode *ip;
-       register struct file *fp;
-       register struct nameidata *ndp = &u.u_nd;
-       int i;
-
-#ifdef notdef
-       if ((mode&(FREAD|FWRITE)) == 0) {
-               u.u_error = EINVAL;
-               return;
-       }
+/* ARGSUSED */
+lfs_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 lfs *fs;                                /* LFS */
+       struct buf *bp;
+       daddr_t lbn, bn, rablock;
+       int size, diff, error = 0;
+       long n, on, type;
+
+#ifdef VERBOSE
+       printf("lfs_read: ino %d\n", ip->i_number);
 #endif
 #endif
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = fname;
-       if (mode&FCREAT) {
-               ndp->ni_nameiop = CREATE | FOLLOW;
-               ip = namei(ndp);
-               if (ip == NULL) {
-                       if (u.u_error)
-                               return;
-                       ip = maknode(arg&07777&(~ISVTX), ndp);
-                       if (ip == NULL)
-                               return;
-                       mode &= ~FTRUNC;
-               } else {
-                       if (mode&FEXCL) {
-                               u.u_error = EEXIST;
-                               iput(ip);
-                               return;
-                       }
-                       mode &= ~FCREAT;
-               }
-       } else {
-               ndp->ni_nameiop = LOOKUP | FOLLOW;
-               ip = namei(ndp);
-               if (ip == NULL)
-                       return;
-       }
-       if ((ip->i_mode & IFMT) == IFSOCK) {
-               u.u_error = EOPNOTSUPP;
-               goto bad;
-       }
-       if ((mode&FCREAT) == 0) {
-               if (mode&FREAD)
-                       if (access(ip, IREAD))
-                               goto bad;
-               if (mode&(FWRITE|FTRUNC)) {
-                       if (access(ip, IWRITE))
-                               goto bad;
-                       if ((ip->i_mode&IFMT) == IFDIR) {
-                               u.u_error = EISDIR;
-                               goto bad;
-                       }
-               }
-       }
-       fp = falloc();
-       if (fp == NULL)
-               goto bad;
-       if (mode&FTRUNC)
-               itrunc(ip, (u_long)0);
-       IUNLOCK(ip);
-       fp->f_flag = mode&FMASK;
-       fp->f_type = DTYPE_INODE;
-       fp->f_ops = &inodeops;
-       fp->f_data = (caddr_t)ip;
-       i = u.u_r.r_val1;
-       if (setjmp(&u.u_qsave)) {
-               if (u.u_error == 0)
-                       u.u_error = EINTR;
-               u.u_ofile[i] = NULL;
-               closef(fp);
-               return;
-       }
-       u.u_error = openi(ip, mode);
-       if (u.u_error == 0)
-               return;
-       u.u_ofile[i] = NULL;
-       fp->f_count--;
-       irele(ip);
-       return;
-bad:
-       iput(ip);
-}
-
-/*
- * Mknod system call
- */
-mknod()
-{
-       register struct inode *ip;
-       register struct a {
-               char    *fname;
-               int     fmode;
-               int     dev;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       if (!suser())
-               return;
-       ndp->ni_nameiop = CREATE;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip != NULL) {
-               u.u_error = EEXIST;
-               goto out;
-       }
-       if (u.u_error)
-               return;
-       ip = maknode(uap->fmode, ndp);
-       if (ip == NULL)
-               return;
-       switch (ip->i_mode & IFMT) {
-
-       case IFMT:      /* used by badsect to flag bad sectors */
-       case IFCHR:
-       case IFBLK:
-               if (uap->dev) {
-                       /*
-                        * Want to be able to use this to make badblock
-                        * inodes, so don't truncate the dev number.
-                        */
-                       ip->i_rdev = uap->dev;
-                       ip->i_flag |= IACC|IUPD|ICHG;
-               }
-       }
-
-out:
-       iput(ip);
-}
-
-/*
- * link system call
- */
-link()
-{
-       register struct inode *ip, *xp;
-       register struct a {
-               char    *target;
-               char    *linkname;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->target;
-       ip = namei(ndp);        /* well, this routine is doomed anyhow */
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) == IFDIR && !suser()) {
-               iput(ip);
-               return;
-       }
-       ip->i_nlink++;
-       ip->i_flag |= ICHG;
-       iupdat(ip, &time, &time, 1);
-       IUNLOCK(ip);
-       ndp->ni_nameiop = CREATE;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = (caddr_t)uap->linkname;
-       xp = namei(ndp);
-       if (xp != NULL) {
-               u.u_error = EEXIST;
-               iput(xp);
-               goto out;
-       }
-       if (u.u_error)
-               goto out;
-       if (ndp->ni_pdir->i_dev != ip->i_dev) {
-               iput(ndp->ni_pdir);
-               u.u_error = EXDEV;
-               goto out;
-       }
-       u.u_error = direnter(ip, ndp);
-out:
-       if (u.u_error) {
-               ip->i_nlink--;
-               ip->i_flag |= ICHG;
-       }
-       irele(ip);
-}
-
-/*
- * symlink -- make a symbolic link
- */
-symlink()
-{
-       register struct a {
-               char    *target;
-               char    *linkname;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       register char *tp;
-       register c, nc;
-       register struct nameidata *ndp = &u.u_nd;
-
-       tp = uap->target;
-       nc = 0;
-       while (c = fubyte(tp)) {
-               if (c < 0) {
-                       u.u_error = EFAULT;
-                       return;
+#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 (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);
+               vp->v_lastr = lbn;
+               n = MIN(n, size - bp->b_resid);
+               if (error) {
+                       brelse(bp);
+                       return (error);
                }
                }
-               tp++;
-               nc++;
-       }
-       ndp->ni_nameiop = CREATE;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->linkname;
-       ip = namei(ndp);
-       if (ip) {
-               iput(ip);
-               u.u_error = EEXIST;
-               return;
-       }
-       if (u.u_error)
-               return;
-       ip = maknode(IFLNK | 0777, ndp);
-       if (ip == NULL)
-               return;
-       u.u_error = rdwri(UIO_WRITE, ip, uap->target, nc, 0, 0, (int *)0);
-       /* handle u.u_error != 0 */
-       iput(ip);
+               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);
 }
 
 /*
 }
 
 /*
- * Unlink system call.
- * Hard to avoid races here, especially
- * in unlinking directories.
+ * Vnode op for writing.
  */
  */
-unlink()
-{
-       struct a {
-               char    *fname;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       if ((ip->i_mode&IFMT) == IFDIR && !suser())
-               goto out;
-       /*
-        * Don't unlink a mounted file.
-        */
-       if (ip->i_dev != dp->i_dev) {
-               u.u_error = EBUSY;
-               goto out;
-       }
-       if (ip->i_flag&ITEXT)
-               xrele(ip);      /* try once to free text */
-       if (dirremove(ndp)) {
-               ip->i_nlink--;
-               ip->i_flag |= ICHG;
-       }
-out:
-       if (dp == ip)
-               irele(ip);
-       else
-               iput(ip);
-       iput(dp);
-}
-
-/*
- * Seek system call
- */
-lseek()
-{
-       register struct file *fp;
-       register struct a {
-               int     fd;
-               off_t   off;
-               int     sbase;
-       } *uap = (struct a *)u.u_ap;
-
-       GETF(fp, uap->fd);
-       if (fp->f_type != DTYPE_INODE) {
-               u.u_error = ESPIPE;
-               return;
-       }
-       switch (uap->sbase) {
-
-       case L_INCR:
-               fp->f_offset += uap->off;
-               break;
-
-       case L_XTND:
-               fp->f_offset = uap->off + ((struct inode *)fp->f_data)->i_size;
+lfs_write(vp, uio, ioflag, cred)
+       register struct vnode *vp;
+       struct uio *uio;
+       int ioflag;
+       struct ucred *cred;
+{
+       struct proc *p = uio->uio_procp;
+       register struct inode *ip = VTOI(vp);
+       register struct lfs *fs;
+       struct buf *bp;
+       daddr_t lbn;
+       u_long 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;
 
                break;
 
-       case L_SET:
-               fp->f_offset = uap->off;
+       case VDIR:
+               /* XXX This may not be correct for LFS. */
+               if ((ioflag & IO_SYNC) == 0)
+                       panic("lfs_write nonsync dir write");
                break;
 
        default:
                break;
 
        default:
-               u.u_error = EINVAL;
-               return;
-       }
-       u.u_r.r_off = fp->f_offset;
-}
-
-/*
- * Access system call
- */
-saccess()
-{
-       register svuid, svgid;
-       register struct inode *ip;
-       register struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-
-       svuid = u.u_uid;
-       svgid = u.u_gid;
-       u.u_uid = u.u_ruid;
-       u.u_gid = u.u_rgid;
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip != NULL) {
-               if ((uap->fmode&R_OK) && access(ip, IREAD))
-                       goto done;
-               if ((uap->fmode&W_OK) && access(ip, IWRITE))
-                       goto done;
-               if ((uap->fmode&X_OK) && access(ip, IEXEC))
-                       goto done;
-done:
-               iput(ip);
-       }
-       u.u_uid = svuid;
-       u.u_gid = svgid;
-}
-
-/*
- * Stat system call.  This version follows links.
- */
-stat()
-{
-
-       stat1(FOLLOW);
-}
-
-/*
- * Lstat system call.  This version does not follow links.
- */
-lstat()
-{
-
-       stat1(NOFOLLOW);
-}
-
-stat1(follow)
-       int follow;
-{
-       register struct inode *ip;
-       register struct a {
-               char    *fname;
-               struct stat *ub;
-       } *uap = (struct a *)u.u_ap;
-       struct stat sb;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = LOOKUP | follow;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       (void) ino_stat(ip, &sb);
-       iput(ip);
-       u.u_error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
-}
-
-/*
- * Return target name of a symbolic link
- */
-readlink()
-{
-       register struct inode *ip;
-       register struct a {
-               char    *name;
-               char    *buf;
-               int     count;
-       } *uap = (struct a *)u.u_ap;
-       register struct nameidata *ndp = &u.u_nd;
-       int resid;
-
-       ndp->ni_nameiop = LOOKUP;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if ((ip->i_mode&IFMT) != IFLNK) {
-               u.u_error = ENXIO;
-               goto out;
-       }
-       u.u_error = rdwri(UIO_READ, ip, uap->buf, uap->count, 0, 0, &resid);
-out:
-       iput(ip);
-       u.u_r.r_val1 = uap->count - resid;
-}
-
-/*
- * Change mode of a file given path name.
- */
-chmod()
-{
-       struct inode *ip;
-       struct a {
-               char    *fname;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
-
-       if ((ip = owner(uap->fname, FOLLOW)) == NULL)
-               return;
-       chmod1(ip, uap->fmode);
-       iput(ip);
-}
-
-/*
- * Change mode of a file given a file descriptor.
- */
-fchmod()
-{
-       struct a {
-               int     fd;
-               int     fmode;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       register struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       if (u.u_uid != ip->i_uid && !suser())
-               return;
-       ILOCK(ip);
-       chmod1(ip, uap->fmode);
-       IUNLOCK(ip);
-}
-
-/*
- * Change the mode on a file.
- * Inode must be locked before calling.
- */
-chmod1(ip, mode)
-       register struct inode *ip;
-       register int mode;
-{
-
-       ip->i_mode &= ~07777;
-       if (u.u_uid) {
-               mode &= ~ISVTX;
-               if (!groupmember(ip->i_gid))
-                       mode &= ~ISGID;
+               panic("lfs_write type");
        }
        }
-       ip->i_mode |= mode&07777;
-       ip->i_flag |= ICHG;
-       if (ip->i_flag&ITEXT && (ip->i_mode&ISVTX)==0)
-               xrele(ip);
-}
-
-/*
- * Set ownership given a path name.
- */
-chown()
-{
-       struct inode *ip;
-       struct a {
-               char    *fname;
-               int     uid;
-               int     gid;
-       } *uap = (struct a *)u.u_ap;
-
-       if (!suser() || (ip = owner(uap->fname, NOFOLLOW)) == NULL)
-               return;
-       u.u_error = chown1(ip, uap->uid, uap->gid);
-       iput(ip);
-}
-
-/*
- * Set ownership given a file descriptor.
- */
-fchown()
-{
-       struct a {
-               int     fd;
-               int     uid;
-               int     gid;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       register struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       if (!suser())
-               return;
-       ILOCK(ip);
-       u.u_error = chown1(ip, uap->uid, uap->gid);
-       IUNLOCK(ip);
-}
-
-/*
- * Perform chown operation on inode ip;
- * inode must be locked prior to call.
- */
-chown1(ip, uid, gid)
-       register struct inode *ip;
-       int uid, gid;
-{
-#ifdef QUOTA
-       register long change;
-#endif
-
-       if (uid == -1)
-               uid = ip->i_uid;
-       if (gid == -1)
-               gid = ip->i_gid;
-#ifdef QUOTA
-       if (ip->i_uid == uid)           /* this just speeds things a little */
-               change = 0;
-       else
-               change = ip->i_blocks;
-       (void) chkdq(ip, -change, 1);
-       (void) chkiq(ip->i_dev, ip, ip->i_uid, 1);
-       dqrele(ip->i_dquot);
+       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
 #endif
-       ip->i_uid = uid;
-       ip->i_gid = gid;
-       ip->i_flag |= ICHG;
-       if (u.u_ruid != 0)
-               ip->i_mode &= ~(ISUID|ISGID);
-#ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
-       (void) chkdq(ip, change, 1);
-       (void) chkiq(ip->i_dev, (struct inode *)NULL, uid, 1);
-       return (u.u_error);             /* should == 0 ALWAYS !! */
+       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
 #else
-       return (0);
+               /* XXX This doesn't handle IO_SYNC. */
+               LFS_UBWRITE(bp);
 #endif
 #endif
-}
-
-utimes()
-{
-       register struct a {
-               char    *fname;
-               struct  timeval *tptr;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip;
-       struct timeval tv[2];
-
-       if ((ip = owner(uap->fname, FOLLOW)) == NULL)
-               return;
-       u.u_error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
-       if (u.u_error == 0) {
-               ip->i_flag |= IACC|IUPD|ICHG;
-               iupdat(ip, &tv[0], &tv[1], 0);
+               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)lfs_truncate(vp, osize, ioflag & IO_SYNC);
+               uio->uio_offset -= resid - uio->uio_resid;
+               uio->uio_resid = resid;
        }
        }
-       iput(ip);
-}
-
-/*
- * Flush any pending I/O.
- */
-sync()
-{
-
-       update();
-}
-
-/*
- * Truncate a file given its path name.
- */
-truncate()
-{
-       struct a {
-               char    *fname;
-               u_long  length;
-       } *uap = (struct a *)u.u_ap;
-       struct inode *ip;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = LOOKUP | FOLLOW;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->fname;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       if (access(ip, IWRITE))
-               goto bad;
-       if ((ip->i_mode&IFMT) == IFDIR) {
-               u.u_error = EISDIR;
-               goto bad;
-       }
-       itrunc(ip, uap->length);
-bad:
-       iput(ip);
-}
-
-/*
- * Truncate a file given a file descriptor.
- */
-ftruncate()
-{
-       struct a {
-               int     fd;
-               u_long  length;
-       } *uap = (struct a *)u.u_ap;
-       struct inode *ip;
-       struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       if ((fp->f_flag&FWRITE) == 0) {
-               u.u_error = EINVAL;
-               return;
-       }
-       ip = (struct inode *)fp->f_data;
-       ILOCK(ip);
-       itrunc(ip, uap->length);
-       IUNLOCK(ip);
+       if (!error && (ioflag & IO_SYNC))
+               error = lfs_update(vp, &time, &time, 1);
+       return (error);
 }
 
 /*
  * Synch an open file.
  */
 }
 
 /*
  * Synch an open file.
  */
-fsync()
+/* ARGSUSED */
+lfs_fsync(vp, fflags, cred, waitfor, p)
+       struct vnode *vp;
+       int fflags;
+       struct ucred *cred;
+       int waitfor;
+       struct proc *p;
 {
 {
-       struct a {
-               int     fd;
-       } *uap = (struct a *)u.u_ap;
        struct inode *ip;
        struct inode *ip;
-       struct file *fp;
-
-       fp = getinode(uap->fd);
-       if (fp == NULL)
-               return;
-       ip = (struct inode *)fp->f_data;
-       ILOCK(ip);
-       syncip(ip);
-       IUNLOCK(ip);
-}
-
-/*
- * Rename system call.
- *     rename("foo", "bar");
- * is essentially
- *     unlink("bar");
- *     link("foo", "bar");
- *     unlink("foo");
- * but ``atomically''.  Can't do full commit without saving state in the
- * inode on disk which isn't feasible at this time.  Best we can do is
- * always guarantee the target exists.
- *
- * Basic algorithm is:
- *
- * 1) Bump link count on source while we're linking it to the
- *    target.  This also insure the inode won't be deleted out
- *    from underneath us while we work.
- * 2) Link source to destination.  If destination already exists,
- *    delete it first.
- * 3) Unlink source reference to inode if still around.
- * 4) If a directory was moved and the parent of the destination
- *    is different from the source, patch the ".." entry in the
- *    directory.
- *
- * Source and destination must either both be directories, or both
- * not be directories.  If target is a directory, it must be empty.
- */
-rename()
-{
-       struct a {
-               char    *from;
-               char    *to;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *xp, *dp;
-       struct inode *zp;
-       int oldparent, parentdifferent, doingdirectory;
-       register struct nameidata *ndp = &u.u_nd;
-       int error = 0;
-
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->from;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       oldparent = 0, doingdirectory = 0;
-       if ((ip->i_mode&IFMT) == IFDIR) {
-               register struct direct *d;
-
-               d = &ndp->ni_dent;
-               /*
-                * Avoid ".", "..", and aliases of "." for obvious reasons.
-                */
-               if ((d->d_namlen == 1 && d->d_name[0] == '.') ||
-                   (d->d_namlen == 2 && bcmp(d->d_name, "..", 2) == 0) ||
-                   (dp == ip)) {
-                       iput(dp);
-                       if (dp == ip)
-                               irele(ip);
-                       else
-                               iput(ip);
-                       u.u_error = EINVAL;
-                       return;
-               }
-               oldparent = dp->i_number;
-               doingdirectory++;
-       }
-       iput(dp);
-
-       /*
-        * 1) Bump link count while we're moving stuff
-        *    around.  If we crash somewhere before
-        *    completing our work, the link count
-        *    may be wrong, but correctable.
-        */
-       ip->i_nlink++;
-       ip->i_flag |= ICHG;
-       iupdat(ip, &time, &time, 1);
-       IUNLOCK(ip);
 
 
-       /*
-        * When the target exists, both the directory
-        * and target inodes are returned locked.
-        */
-       ndp->ni_nameiop = CREATE | LOCKPARENT | NOCACHE;
-       ndp->ni_dirp = (caddr_t)uap->to;
-       xp = namei(ndp);
-       if (u.u_error) {
-               error = u.u_error;
-               goto out;
-       }
-       dp = ndp->ni_pdir;
-       /*
-        * If ".." must be changed (ie the directory gets a new
-        * parent) then the source directory must not be in the
-        * directory heirarchy above the target, as this would
-        * orphan everything below the source directory. Also
-        * the user must have write permission in the source so
-        * as to be able to change "..". We must repeat the call 
-        * to namei, as the parent directory is unlocked by the
-        * call to checkpath().
-        */
-       parentdifferent = oldparent != dp->i_number;
-       if (doingdirectory && parentdifferent) {
-               if (access(ip, IWRITE))
-                       goto bad;
-               do {
-                       dp = ndp->ni_pdir;
-                       if (xp != NULL)
-                               iput(xp);
-                       u.u_error = checkpath(ip, dp);
-                       if (u.u_error)
-                               goto out;
-                       xp = namei(ndp);
-                       if (u.u_error) {
-                               error = u.u_error;
-                               goto out;
-                       }
-               } while (dp != ndp->ni_pdir);
-       }
-       /*
-        * 2) If target doesn't exist, link the target
-        *    to the source and unlink the source. 
-        *    Otherwise, rewrite the target directory
-        *    entry to reference the source inode and
-        *    expunge the original entry's existence.
-        */
-       if (xp == NULL) {
-               if (dp->i_dev != ip->i_dev) {
-                       error = EXDEV;
-                       goto bad;
-               }
-               /*
-                * Account for ".." in directory.
-                * When source and destination have the
-                * same parent we don't fool with the
-                * link count -- this isn't required
-                * because we do a similar check below.
-                */
-               if (doingdirectory && parentdifferent) {
-                       dp->i_nlink++;
-                       dp->i_flag |= ICHG;
-                       iupdat(dp, &time, &time, 1);
-               }
-               error = direnter(ip, ndp);
-               if (error)
-                       goto out;
-       } else {
-               if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) {
-                       error = EXDEV;
-                       goto bad;
-               }
-               /*
-                * Short circuit rename(foo, foo).
-                */
-               if (xp->i_number == ip->i_number)
-                       goto bad;
-               /*
-                * Target must be empty if a directory
-                * and have no links to it.
-                * Also, insure source and target are
-                * compatible (both directories, or both
-                * not directories).
-                */
-               if ((xp->i_mode&IFMT) == IFDIR) {
-                       if (!dirempty(xp) || xp->i_nlink > 2) {
-                               error = ENOTEMPTY;
-                               goto bad;
-                       }
-                       if (!doingdirectory) {
-                               error = ENOTDIR;
-                               goto bad;
-                       }
-               } else if (doingdirectory) {
-                       error = EISDIR;
-                       goto bad;
-               }
-               dirrewrite(dp, ip, ndp);
-               if (u.u_error) {
-                       error = u.u_error;
-                       goto bad1;
-               }
-               /*
-                * Adjust the link count of the target to
-                * reflect the dirrewrite above.  If this is
-                * a directory it is empty and there are
-                * no links to it, so we can squash the inode and
-                * any space associated with it.  We disallowed
-                * renaming over top of a directory with links to
-                * it above, as we've no way to determine if
-                * we've got a link or the directory itself, and
-                * if we get a link, then ".." will be screwed up.
-                */
-               xp->i_nlink--;
-               if (doingdirectory) {
-                       if (--xp->i_nlink != 0)
-                               panic("rename: linked directory");
-                       itrunc(xp, (u_long)0);
-               }
-               xp->i_flag |= ICHG;
-               iput(xp);
-               xp = NULL;
-       }
-
-       /*
-        * 3) Unlink the source.
-        */
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->from;
-       zp = namei(ndp);
-       dp = ndp->ni_pdir;
-       /*
-        * Insure directory entry still exists and
-        * has not changed since the start of all
-        * this.  If either has occured, forget about
-        * about deleting the original entry.
-        */
-       if (dp != NULL && zp == ip) {
-               /*
-                * If source is a directory, must adjust
-                * link count of parent directory also.
-                * If target didn't exist and source and
-                * target have the same parent, then we
-                * needn't touch the link count, it all
-                * balances out in the end.  Otherwise, we
-                * must do so to reflect deletion of ".."
-                * done above.
-                */
-               if (doingdirectory && (xp != NULL || parentdifferent)) {
-                       dp->i_nlink--;
-                       dp->i_flag |= ICHG;
-               }
-               if (dirremove(ndp)) {
-                       zp->i_nlink--;
-                       zp->i_flag |= ICHG;
-               }
-               if (error == 0)         /* conservative */
-                       error = u.u_error;
-       }
-       if (zp != NULL)
-               iput(zp);
-       irele(ip);
-       if (dp)
-               iput(dp);
-
-       /*
-        * 4) Renaming a directory with the parent
-        *    different requires ".." to be rewritten.
-        *    The window is still there for ".." to
-        *    be inconsistent, but this is unavoidable,
-        *    and a lot shorter than when it was done
-        *    in a user process.
-        */
-       if (doingdirectory && parentdifferent && error == 0) {
-               struct dirtemplate dirbuf;
-
-               ndp->ni_nameiop = LOOKUP | LOCKPARENT;
-               ndp->ni_segflg = UIO_USERSPACE;
-               ndp->ni_dirp = uap->to;
-               ip = namei(ndp);
-               if (ip == NULL) {
-                       printf("rename: .. went away\n");
-                       return;
-               }
-               dp = ndp->ni_pdir;
-               if ((ip->i_mode&IFMT) != IFDIR) {
-                       printf("rename: .. not a directory\n");
-                       goto stuck;
-               }
-               error = rdwri(UIO_READ, ip, (caddr_t)&dirbuf,
-                       sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
-               if (error == 0) {
-                       dirbuf.dotdot_ino = dp->i_number;
-                       cacheinval(dp);
-                       (void) rdwri(UIO_WRITE, ip, (caddr_t)&dirbuf,
-                         sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
-               }
-stuck:
-               irele(dp);
-               iput(ip);
-       }
-       goto done;
-
-bad:
-       iput(dp);
-bad1:
-       if (xp)
-               iput(xp);
-out:
-       ip->i_nlink--;
-       ip->i_flag |= ICHG;
-       irele(ip);
-done:
-       if (error)
-               u.u_error = error;
+#ifdef VERBOSE
+       printf("lfs_fsync\n");
+#endif
+       ip = VTOI(vp);
+       if (fflags & FWRITE)
+               ip->i_flag |= ICHG;
+       return (lfs_update(vp, &time, &time, waitfor == MNT_WAIT));
 }
 
 /*
 }
 
 /*
- * Make a new file.
+ * Last reference to an inode, write the inode out and if necessary,
+ * truncate and deallocate the file.
  */
  */
-struct inode *
-maknode(mode, ndp)
-       int mode;
-       register struct nameidata *ndp;
+int
+lfs_inactive(vp, p)
+       struct vnode *vp;
+       struct proc *p;
 {
 {
+       extern int prtactive;
        register struct inode *ip;
        register struct inode *ip;
-       register struct inode *pdir = ndp->ni_pdir;
-       ino_t ipref;
+       int mode, error;
 
 
-       if ((mode & IFMT) == IFDIR)
-               ipref = dirpref(pdir->i_fs);
-       else
-               ipref = pdir->i_number;
-       ip = ialloc(pdir, ipref, mode);
-       if (ip == NULL) {
-               iput(pdir);
-               return (NULL);
-       }
-#ifdef QUOTA
-       if (ip->i_dquot != NODQUOT)
-               panic("maknode: dquot");
-#endif
-       ip->i_flag |= IACC|IUPD|ICHG;
-       if ((mode & IFMT) == 0)
-               mode |= IFREG;
-       ip->i_mode = mode & ~u.u_cmask;
-       ip->i_nlink = 1;
-       ip->i_uid = u.u_uid;
-       ip->i_gid = pdir->i_gid;
-       if (ip->i_mode & ISGID && !groupmember(ip->i_gid))
-               ip->i_mode &= ~ISGID;
-#ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
+#ifdef VERBOSE
+       printf("lfs_inactive\n");
 #endif
 #endif
+       if (prtactive && vp->v_usecount != 0)
+               vprint("lfs_inactive: pushing active", vp);
 
 
-       /*
-        * Make sure inode goes to disk before directory entry.
-        */
-       iupdat(ip, &time, &time, 1);
-       u.u_error = direnter(ip, ndp);
-       if (u.u_error) {
-               /*
-                * Write error occurred trying to update directory
-                * so must deallocate the inode.
-                */
-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
-               iput(ip);
-               return (NULL);
+       /* 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);
        }
        }
-       return (ip);
-}
-
-/*
- * A virgin directory (no blushing please).
- */
-struct dirtemplate mastertemplate = {
-       0, 12, 1, ".",
-       0, DIRBLKSIZ - 12, 2, ".."
-};
 
 
-/*
- * Mkdir system call
- */
-mkdir()
-{
-       struct a {
-               char    *name;
-               int     dmode;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       struct dirtemplate dirtemplate;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = CREATE;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (u.u_error)
-               return;
-       if (ip != NULL) {
-               iput(ip);
-               u.u_error = EEXIST;
-               return;
-       }
-       dp = ndp->ni_pdir;
-       uap->dmode &= 0777;
-       uap->dmode |= IFDIR;
-       /*
-        * Must simulate part of maknode here
-        * in order to acquire the inode, but
-        * not have it entered in the parent
-        * directory.  The entry is made later
-        * after writing "." and ".." entries out.
-        */
-       ip = ialloc(dp, dirpref(dp->i_fs), uap->dmode);
-       if (ip == NULL) {
-               iput(dp);
-               return;
-       }
-#ifdef QUOTA
-       if (ip->i_dquot != NODQUOT)
-               panic("mkdir: dquot");
-#endif
-       ip->i_flag |= IACC|IUPD|ICHG;
-       ip->i_mode = uap->dmode & ~u.u_cmask;
-       ip->i_nlink = 2;
-       ip->i_uid = u.u_uid;
-       ip->i_gid = dp->i_gid;
+       error = 0;
+       ILOCK(ip);
+       if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
 #ifdef QUOTA
 #ifdef QUOTA
-       ip->i_dquot = inoquota(ip);
+               if (!getinoquota(ip))
+                       (void)chkiq(ip, -1, NOCRED, 0);
 #endif
 #endif
-       iupdat(ip, &time, &time, 1);
-
-       /*
-        * Bump link count in parent directory
-        * to reflect work done below.  Should
-        * be done before reference is created
-        * so reparation is possible if we crash.
-        */
-       dp->i_nlink++;
-       dp->i_flag |= ICHG;
-       iupdat(dp, &time, &time, 1);
-
-       /*
-        * Initialize directory with "."
-        * and ".." from static template.
-        */
-       dirtemplate = mastertemplate;
-       dirtemplate.dot_ino = ip->i_number;
-       dirtemplate.dotdot_ino = dp->i_number;
-       u.u_error = rdwri(UIO_WRITE, ip, (caddr_t)&dirtemplate,
-               sizeof (dirtemplate), (off_t)0, 1, (int *)0);
-       if (u.u_error) {
-               dp->i_nlink--;
-               dp->i_flag |= ICHG;
-               goto bad;
-       }
-       /*
-        * Directory all set up, now
-        * install the entry for it in
-        * the parent directory.
-        */
-       u.u_error = direnter(ip, ndp);
-       dp = NULL;
-       if (u.u_error) {
-               ndp->ni_nameiop = LOOKUP | NOCACHE;
-               ndp->ni_segflg = UIO_USERSPACE;
-               ndp->ni_dirp = uap->name;
-               dp = namei(ndp);
-               if (dp) {
-                       dp->i_nlink--;
-                       dp->i_flag |= ICHG;
-               }
-       }
-bad:
-       /*
-        * No need to do an explicit itrunc here,
-        * irele will do this for us because we set
-        * the link count to 0.
-        */
-       if (u.u_error) {
-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
-       }
-       if (dp)
-               iput(dp);
-       iput(ip);
-}
-
-/*
- * Rmdir system call.
- */
-rmdir()
-{
-       struct a {
-               char    *name;
-       } *uap = (struct a *)u.u_ap;
-       register struct inode *ip, *dp;
-       register struct nameidata *ndp = &u.u_nd;
-
-       ndp->ni_nameiop = DELETE | LOCKPARENT;
-       ndp->ni_segflg = UIO_USERSPACE;
-       ndp->ni_dirp = uap->name;
-       ip = namei(ndp);
-       if (ip == NULL)
-               return;
-       dp = ndp->ni_pdir;
-       /*
-        * No rmdir "." please.
-        */
-       if (dp == ip) {
-               irele(dp);
-               iput(ip);
-               u.u_error = EINVAL;
-               return;
-       }
-       if ((ip->i_mode&IFMT) != IFDIR) {
-               u.u_error = ENOTDIR;
-               goto out;
-       }
-       /*
-        * Don't remove a mounted on directory.
-        */
-       if (ip->i_dev != dp->i_dev) {
-               u.u_error = EBUSY;
-               goto out;
-       }
-       /*
-        * Verify the directory is empty (and valid).
-        * (Rmdir ".." won't be valid since
-        *  ".." will contain a reference to
-        *  the current directory and thus be
-        *  non-empty.)
-        */
-       if (ip->i_nlink != 2 || !dirempty(ip)) {
-               u.u_error = ENOTEMPTY;
-               goto out;
-       }
-       /*
-        * Delete reference to directory before purging
-        * inode.  If we crash in between, the directory
-        * will be reattached to lost+found,
-        */
-       if (dirremove(ndp) == 0)
-               goto out;
-       dp->i_nlink--;
-       dp->i_flag |= ICHG;
-       iput(dp);
-       dp = NULL;
+               error = lfs_truncate(vp, (u_long)0, 0);
+               mode = ip->i_mode;
+               ip->i_mode = 0;
+               ip->i_rdev = 0;
+               ip->i_flag |= IUPD|ICHG;
+               lfs_vfree(vp, ip->i_number, mode);
+       }
+       if (ip->i_flag&(IUPD|IACC|ICHG|IMOD))
+               lfs_update(vp, &time, &time, 0);
+       IUNLOCK(ip);
+       ip->i_flag = 0;
        /*
        /*
-        * Truncate inode.  The only stuff left
-        * in the directory is "." and "..".  The
-        * "." reference is inconsequential since
-        * we're quashing it.  The ".." reference
-        * has already been adjusted above.  We've
-        * removed the "." reference and the reference
-        * in the parent directory, but there may be
-        * other hard links so decrement by 2 and
-        * worry about them later.
+        * If we are done with the inode, reclaim it
+        * so that it can be reused immediately.
         */
         */
-       ip->i_nlink -= 2;
-       itrunc(ip, (u_long)0);
-       cacheinval(ip);
-out:
-       if (dp)
-               iput(dp);
-       iput(ip);
-}
-
-struct file *
-getinode(fdes)
-       int fdes;
-{
-       struct file *fp;
-
-       if ((unsigned)fdes >= NOFILE || (fp = u.u_ofile[fdes]) == NULL) {
-               u.u_error = EBADF;
-               return ((struct file *)0);
-       }
-       if (fp->f_type != DTYPE_INODE) {
-               u.u_error = EINVAL;
-               return ((struct file *)0);
-       }
-       return (fp);
-}
-
-/*
- * mode mask for creation of files
- */
-umask()
-{
-       register struct a {
-               int     mask;
-       } *uap = (struct a *)u.u_ap;
-
-       u.u_r.r_val1 = u.u_cmask;
-       u.u_cmask = uap->mask & 07777;
+       if (vp->v_usecount == 0 && ip->i_mode == 0)
+               vgone(vp);
+       return (error);
 }
 }