root/ufs/ext2fs/ext2fs_vnops.c

DEFINITIONS

1. ext2fs_create
2. ext2fs_mknod
3. ext2fs_open
4. ext2fs_access
5. ext2fs_getattr
6. ext2fs_setattr
7. ext2fs_chmod
8. ext2fs_chown
9. ext2fs_remove
10. ext2fs_link
11. ext2fs_rename
12. ext2fs_mkdir
13. ext2fs_rmdir
14. ext2fs_symlink
15. ext2fs_readlink
16. ext2fs_advlock
17. ext2fs_makeinode
18. ext2fs_fsync
19. ext2fs_reclaim
20. ext2fsfifo_reclaim

    1 /*      $OpenBSD: ext2fs_vnops.c,v 1.48 2007/06/17 20:15:25 jasper Exp $        */
    2 /*      $NetBSD: ext2fs_vnops.c,v 1.1 1997/06/11 09:34:09 bouyer Exp $  */
    4 /*
    5  * Copyright (c) 1997 Manuel Bouyer.
    6  * Copyright (c) 1982, 1986, 1989, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  * (c) UNIX System Laboratories, Inc.
    9  * All or some portions of this file are derived from material licensed
   10  * to the University of California by American Telephone and Telegraph
   11  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   12  * the permission of UNIX System Laboratories, Inc.
   13  *
   14  * Redistribution and use in source and binary forms, with or without
   15  * modification, are permitted provided that the following conditions
   16  * are met:
   17  * 1. Redistributions of source code must retain the above copyright
   18  *    notice, this list of conditions and the following disclaimer.
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  * 3. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)ufs_vnops.c 8.14 (Berkeley) 10/26/94
   39  * Modified for ext2fs by Manuel Bouyer.
   40  */
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/resourcevar.h>
   45 #include <sys/kernel.h>
   46 #include <sys/file.h>
   47 #include <sys/stat.h>
   48 #include <sys/buf.h>
   49 #include <sys/proc.h>
   50 #include <sys/conf.h>
   51 #include <sys/mount.h>
   52 #include <sys/namei.h>
   53 #include <sys/vnode.h>
   54 #include <sys/lockf.h>
   55 #include <sys/malloc.h>
   56 #include <sys/pool.h>
   57 #include <sys/signalvar.h>
   59 #include <uvm/uvm_extern.h>
   61 #include <miscfs/fifofs/fifo.h>
   62 #include <miscfs/specfs/specdev.h>
   64 #include <ufs/ufs/quota.h>
   65 #include <ufs/ufs/inode.h>
   66 #include <ufs/ufs/ufs_extern.h>
   67 #include <ufs/ufs/ufsmount.h>
   69 #include <ufs/ext2fs/ext2fs.h>
   70 #include <ufs/ext2fs/ext2fs_extern.h>
   71 #include <ufs/ext2fs/ext2fs_dir.h>
   73 static int ext2fs_chmod(struct vnode *, mode_t, struct ucred *, struct proc *);
   74 static int ext2fs_chown(struct vnode *, uid_t, gid_t, struct ucred *, struct proc *);
   76 /*
   77  * Create a regular file
   78  */
   79 int
ext2fs_create(void *v)
   81 {
   82         struct vop_create_args *ap = v;
   83         return ext2fs_makeinode(MAKEIMODE(ap->a_vap->va_type, 
ap->a_vap->va_mode),
ap->a_dvp, ap->a_vpp, ap->a_cnp);
   86 }
   88 /*
   89  * Mknod vnode call
   90  */
   91 /* ARGSUSED */
   92 int
ext2fs_mknod(void *v)
   94 {
   95         struct vop_mknod_args *ap = v;
   96         struct vattr *vap = ap->a_vap;
   97         struct vnode **vpp = ap->a_vpp;
   98         struct inode *ip;
   99         int error;
  101         if ((error =
ext2fs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
ap->a_dvp, vpp, ap->a_cnp)) != 0)
  104                 return (error);
ip = VTOI(*vpp);
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
  107         if (vap->va_rdev != VNOVAL) {
  108                 /*
  109                  * Want to be able to use this to make badblock
  110                  * inodes, so don't truncate the dev number.
  111                  */
ip->i_e2din->e2di_rdev = h2fs32(vap->va_rdev);
  113         }
  114         /*
  115          * Remove inode so that it will be reloaded by VFS_VGET and
  116          * checked to see if it is an alias of an existing entry in
  117          * the inode cache.
  118          */
vput(*vpp);
  120         (*vpp)->v_type = VNON;
vgone(*vpp);
  122         *vpp = 0;
  123         return (0);
  124 }
  126 /*
  127  * Open called.
  128  *
  129  * Just check the APPEND flag.
  130  */
  131 /* ARGSUSED */
  132 int
ext2fs_open(void *v)
  134 {
  135         struct vop_open_args *ap = v;
  137         /*
  138          * Files marked append-only must be opened for appending.
  139          */
  140         if ((VTOI(ap->a_vp)->i_e2fs_flags & EXT2_APPEND) &&
  141                 (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
  142                 return (EPERM);
  143         return (0);
  144 }
  146 int
ext2fs_access(void *v)
  148 {
  149         struct vop_access_args *ap = v;
  150         struct vnode *vp = ap->a_vp;
  151         struct inode *ip = VTOI(vp);
mode_t mode = ap->a_mode;
  154         /* If immutable bit set, nobody gets to write it. */
  155         if ((mode & VWRITE) && (ip->i_e2fs_flags & EXT2_IMMUTABLE))
  156                 return (EPERM);
  158         return (vaccess(ip->i_e2fs_mode, ip->i_e2fs_uid, ip->i_e2fs_gid, mode,
ap->a_cred));
  160 }
  162 /* ARGSUSED */
  163 int
ext2fs_getattr(void *v)
  165 {
  166         struct vop_getattr_args *ap = v;
  167         struct vnode *vp = ap->a_vp;
  168         struct inode *ip = VTOI(vp);
  169         struct vattr *vap = ap->a_vap;
  170         struct timeval tv;
getmicrotime(&tv);
EXT2FS_ITIMES(ip, &tv, &tv);
  174         /*
  175          * Copy from inode table
  176          */
vap->va_fsid = ip->i_dev;
vap->va_fileid = ip->i_number;
vap->va_mode = ip->i_e2fs_mode & ALLPERMS;
vap->va_nlink = ip->i_e2fs_nlink;
vap->va_uid = ip->i_e2fs_uid;
vap->va_gid = ip->i_e2fs_gid;
vap->va_rdev = (dev_t)fs2h32(ip->i_e2din->e2di_rdev);
vap->va_size = ext2fs_size(ip);
vap->va_atime.tv_sec = ip->i_e2fs_atime;
vap->va_atime.tv_nsec = 0;
vap->va_mtime.tv_sec = ip->i_e2fs_mtime;
vap->va_mtime.tv_nsec = 0;
vap->va_ctime.tv_sec = ip->i_e2fs_ctime;
vap->va_ctime.tv_nsec = 0;
  191 #ifdef EXT2FS_SYSTEM_FLAGS
vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? SF_APPEND : 0;
vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? SF_IMMUTABLE : 0;
  194 #else
vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? UF_APPEND : 0;
vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? UF_IMMUTABLE : 0;
  197 #endif
vap->va_gen = ip->i_e2fs_gen;
  199         /* this doesn't belong here */
  200         if (vp->v_type == VBLK)
vap->va_blocksize = BLKDEV_IOSIZE;
  202         else if (vp->v_type == VCHR)
vap->va_blocksize = MAXBSIZE;
  204         else
vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
vap->va_bytes = dbtob((u_quad_t)ip->i_e2fs_nblock);
vap->va_type = vp->v_type;
vap->va_filerev = ip->i_modrev;
  209         return (0);
  210 }
  212 /*
  213  * Set attribute vnode op. called from several syscalls
  214  */
  215 int
ext2fs_setattr(void *v)
  217 {
  218         struct vop_setattr_args *ap = v;
  219         struct vattr *vap = ap->a_vap;
  220         struct vnode *vp = ap->a_vp;
  221         struct inode *ip = VTOI(vp);
  222         struct ucred *cred = ap->a_cred;
  223         struct proc *p = ap->a_p;
  224         int error;
  226         /*
  227          * Check for unsettable attributes.
  228          */
  229         if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
  230                 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
  231                 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
  232                 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
  233                 return (EINVAL);
  234         }
  235         if (vap->va_flags != VNOVAL) {
  236                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
  237                         return (EROFS);
  238                 if (cred->cr_uid != ip->i_e2fs_uid &&
  239                         (error = suser_ucred(cred)))
  240                         return (error);
  241 #ifdef EXT2FS_SYSTEM_FLAGS
  242                 if (cred->cr_uid == 0) {
  243                         if ((ip->i_e2fs_flags & 
  244                             (EXT2_APPEND | EXT2_IMMUTABLE)) && securelevel > 0)
  245                                 return (EPERM);
ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
ip->i_e2fs_flags |= 
  248                             (vap->va_flags & SF_APPEND) ? EXT2_APPEND : 0 |
  249                             (vap->va_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE: 0;
  250                 } else {
  251                         return (EPERM);
  252                 }
  253 #else
ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
ip->i_e2fs_flags |= 
  256                     (vap->va_flags & UF_APPEND) ? EXT2_APPEND : 0 |
  257                     (vap->va_flags & UF_IMMUTABLE) ? EXT2_IMMUTABLE: 0;
  258 #endif
ip->i_flag |= IN_CHANGE;
  260                 if (vap->va_flags & (IMMUTABLE | APPEND))
  261                         return (0);
  262         }
  263         if (ip->i_e2fs_flags & (EXT2_APPEND | EXT2_IMMUTABLE))
  264                 return (EPERM);
  265         /*
  266          * Go through the fields and update iff not VNOVAL.
  267          */
  268         if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
  269                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
  270                         return (EROFS);
error = ext2fs_chown(vp, vap->va_uid, vap->va_gid, cred, p);
  272                 if (error)
  273                         return (error);
  274         }
  275         if (vap->va_size != VNOVAL) {
  276                 /*
  277                  * Disallow write attempts on read-only file systems;
  278                  * unless the file is a socket, fifo, or a block or
  279                  * character device resident on the file system.
  280                  */
  281                 switch (vp->v_type) {
  282                 case VDIR:
  283                         return (EISDIR);
  284                 case VLNK:
  285                 case VREG:
  286                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
  287                                 return (EROFS);
  288                 default:
  289                         break;
  290                 }
error = ext2fs_truncate(ip, vap->va_size, 0, cred);
  292                 if (error)
  293                         return (error);
  294         }
  295         if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
  296                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
  297                         return (EROFS);
  298                 if (cred->cr_uid != ip->i_e2fs_uid &&
  299                         (error = suser_ucred(cred)) &&
  300                         ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || 
  301                         (error = VOP_ACCESS(vp, VWRITE, cred, p))))
  302                         return (error);
  303                 if (vap->va_atime.tv_sec != VNOVAL)
  304                         if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
ip->i_flag |= IN_ACCESS;
  306                 if (vap->va_mtime.tv_sec != VNOVAL)
ip->i_flag |= IN_CHANGE | IN_UPDATE;
error = ext2fs_update(ip, &vap->va_atime, &vap->va_mtime, 1);
  309                 if (error)
  310                         return (error);
  311         }
error = 0;
  313         if (vap->va_mode != (mode_t)VNOVAL) {
  314                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
  315                         return (EROFS);
error = ext2fs_chmod(vp, (int)vap->va_mode, cred, p);
  317         }
  318         return (error);
  319 }
  321 /*
  322  * Change the mode on a file.
  323  * Inode must be locked before calling.
  324  */
  325 static int
ext2fs_chmod(struct vnode *vp, mode_t mode, struct ucred *cred, struct proc *p)
  327 {
  328         struct inode *ip = VTOI(vp);
  329         int error;
  331         if (cred->cr_uid != ip->i_e2fs_uid && (error = suser_ucred(cred)))
  332                 return (error);
  333         if (cred->cr_uid) {
  334                 if (vp->v_type != VDIR && (mode & S_ISTXT))
  335                         return (EFTYPE);
  336                 if (!groupmember(ip->i_e2fs_gid, cred) && (mode & ISGID))
  337                         return (EPERM);
  338         }
ip->i_e2fs_mode &= ~ALLPERMS;
ip->i_e2fs_mode |= (mode & ALLPERMS);
ip->i_flag |= IN_CHANGE;
  342         if ((vp->v_flag & VTEXT) && (ip->i_e2fs_mode & S_ISTXT) == 0)
  343                 (void) uvm_vnp_uncache(vp);
  344         return (0);
  345 }
  347 /*
  348  * Perform chown operation on inode ip;
  349  * inode must be locked prior to call.
  350  */
  351 static int
ext2fs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, struct proc *p)
  353 {
  354         struct inode *ip = VTOI(vp);
uid_t ouid;
gid_t ogid;
  357         int error = 0;
  359         if (uid == (uid_t)VNOVAL)
uid = ip->i_e2fs_uid;
  361         if (gid == (gid_t)VNOVAL)
gid = ip->i_e2fs_gid;
  363         /*
  364          * If we don't own the file, are trying to change the owner
  365          * of the file, or are not a member of the target group,
  366          * the caller must be superuser or the call fails.
  367          */
  368         if ((cred->cr_uid != ip->i_e2fs_uid || uid != ip->i_e2fs_uid ||
  369                 (gid != ip->i_e2fs_gid && !groupmember((gid_t)gid, cred))) &&
  370                 (error = suser_ucred(cred)))
  371                 return (error);
ogid = ip->i_e2fs_gid;
ouid = ip->i_e2fs_uid;
ip->i_e2fs_gid = gid;
ip->i_e2fs_uid = uid;
  377         if (ouid != uid || ogid != gid)
ip->i_flag |= IN_CHANGE;
  379         if (ouid != uid && cred->cr_uid != 0)
ip->i_e2fs_mode &= ~ISUID;
  381         if (ogid != gid && cred->cr_uid != 0)
ip->i_e2fs_mode &= ~ISGID;
  383         return (0);
  384 }
  386 int
ext2fs_remove(void *v)
  388 {
  389         struct vop_remove_args *ap = v;
  390         struct inode *ip;
  391         struct vnode *vp = ap->a_vp;
  392         struct vnode *dvp = ap->a_dvp;
  393         int error;
ip = VTOI(vp);
  396         if (vp->v_type == VDIR ||
  397                 (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
  398                 (VTOI(dvp)->i_e2fs_flags & EXT2_APPEND)) {
error = EPERM;
  400                 goto out;
  401         }
error = ext2fs_dirremove(dvp, ap->a_cnp);
  403         if (error == 0) {
ip->i_e2fs_nlink--;
ip->i_flag |= IN_CHANGE;
  406         }
out:
  408         if (dvp == vp)
vrele(vp);
  410         else
vput(vp);
vput(dvp);
  413         return (error);
  414 }
  416 /*
  417  * link vnode call
  418  */
  419 int
ext2fs_link(void *v)
  421 {
  422         struct vop_link_args *ap = v;
  423         struct vnode *dvp = ap->a_dvp;
  424         struct vnode *vp = ap->a_vp;
  425         struct componentname *cnp = ap->a_cnp;
  426         struct proc *p = cnp->cn_proc;
  427         struct inode *ip;
  428         int error;
  430 #ifdef DIAGNOSTIC
  431         if ((cnp->cn_flags & HASBUF) == 0)
panic("ext2fs_link: no name");
  433 #endif
  434         if (vp->v_type == VDIR) {
VOP_ABORTOP(dvp, cnp);
error = EISDIR;
  437                 goto out2;
  438         }
  439         if (dvp->v_mount != vp->v_mount) {
VOP_ABORTOP(dvp, cnp);
error = EXDEV;
  442                 goto out2;
  443         }
  444         if (dvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) {
VOP_ABORTOP(dvp, cnp);
  446                 goto out2;
  447         }
ip = VTOI(vp);
  449         if ((nlink_t)ip->i_e2fs_nlink >= LINK_MAX) {
VOP_ABORTOP(dvp, cnp);
error = EMLINK;
  452                 goto out1;
  453         }
  454         if (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) {
VOP_ABORTOP(dvp, cnp);
error = EPERM;
  457                 goto out1;
  458         }
ip->i_e2fs_nlink++;
ip->i_flag |= IN_CHANGE;
error = ext2fs_update(ip, NULL, NULL, 1);
  462         if (!error)
error = ext2fs_direnter(ip, dvp, cnp);
  464         if (error) {
ip->i_e2fs_nlink--;
ip->i_flag |= IN_CHANGE;
  467         }
pool_put(&namei_pool, cnp->cn_pnbuf);
out1:
  470         if (dvp != vp)
VOP_UNLOCK(vp, 0, p);
out2:
vput(dvp);
  474         return (error);
  475 }
  477 /*
  478  * Rename system call.
  479  *      rename("foo", "bar");
  480  * is essentially
  481  *      unlink("bar");
  482  *      link("foo", "bar");
  483  *      unlink("foo");
  484  * but ``atomically''.  Can't do full commit without saving state in the
  485  * inode on disk which isn't feasible at this time.  Best we can do is
  486  * always guarantee the target exists.
  487  *
  488  * Basic algorithm is:
  489  *
  490  * 1) Bump link count on source while we're linking it to the
  491  *    target.  This also ensure the inode won't be deleted out
  492  *    from underneath us while we work (it may be truncated by
  493  *    a concurrent `trunc' or `open' for creation).
  494  * 2) Link source to destination.  If destination already exists,
  495  *    delete it first.
  496  * 3) Unlink source reference to inode if still around. If a
  497  *    directory was moved and the parent of the destination
  498  *    is different from the source, patch the ".." entry in the
  499  *    directory.
  500  */
  501 int
ext2fs_rename(void *v)
  503 {
  504         struct vop_rename_args  *ap = v;
  505         struct vnode *tvp = ap->a_tvp;
  506         struct vnode *tdvp = ap->a_tdvp;
  507         struct vnode *fvp = ap->a_fvp;
  508         struct vnode *fdvp = ap->a_fdvp;
  509         struct componentname *tcnp = ap->a_tcnp;
  510         struct componentname *fcnp = ap->a_fcnp;
  511         struct inode *ip, *xp, *dp;
  512         struct proc *p = fcnp->cn_proc;
  513         struct ext2fs_dirtemplate dirbuf;
  514         /* struct timespec ts; */
  515         int doingdirectory = 0, oldparent = 0, newparent = 0;
  516         int error = 0;
u_char namlen;
  519 #ifdef DIAGNOSTIC
  520         if ((tcnp->cn_flags & HASBUF) == 0 ||
  521             (fcnp->cn_flags & HASBUF) == 0)
panic("ext2fs_rename: no name");
  523 #endif
  524         /*
  525          * Check for cross-device rename.
  526          */
  527         if ((fvp->v_mount != tdvp->v_mount) ||
  528             (tvp && (fvp->v_mount != tvp->v_mount))) {
error = EXDEV;
abortit:
VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */
  532                 if (tdvp == tvp)
vrele(tdvp);
  534                 else
vput(tdvp);
  536                 if (tvp)
vput(tvp);
VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
vrele(fdvp);
vrele(fvp);
  541                 return (error);
  542         }
  544         /*
  545          * Check if just deleting a link name.
  546          */
  547         if (tvp && ((VTOI(tvp)->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
  548             (VTOI(tdvp)->i_e2fs_flags & EXT2_APPEND))) {
error = EPERM;
  550                 goto abortit;
  551         }
  552         if (fvp == tvp) {
  553                 if (fvp->v_type == VDIR) {
error = EINVAL;
  555                         goto abortit;
  556                 }
  558                 /* Release destination completely. */
VOP_ABORTOP(tdvp, tcnp);
vput(tdvp);
vput(tvp);
  563                 /* Delete source. */
vrele(fdvp);
vrele(fvp);
fcnp->cn_flags &= ~MODMASK;
fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
  568                 if ((fcnp->cn_flags & SAVESTART) == 0)
panic("ext2fs_rename: lost from startdir");
fcnp->cn_nameiop = DELETE;
  571                 (void) relookup(fdvp, &fvp, fcnp);
  572                 return (VOP_REMOVE(fdvp, fvp, fcnp));
  573         }
  574         if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0)
  575                 goto abortit;
dp = VTOI(fdvp);
ip = VTOI(fvp);
  578         if ((nlink_t)ip->i_e2fs_nlink >= LINK_MAX) {
VOP_UNLOCK(fvp, 0, p);
error = EMLINK;
  581                 goto abortit;
  582         }
  583         if ((ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
  584                 (dp->i_e2fs_flags & EXT2_APPEND)) {
VOP_UNLOCK(fvp, 0, p);
error = EPERM;
  587                 goto abortit;
  588         }
  589         if ((ip->i_e2fs_mode & IFMT) == IFDIR) {
error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
  591                 if (!error && tvp)
error = VOP_ACCESS(tvp, VWRITE, tcnp->cn_cred, 
tcnp->cn_proc);
  594                 if (error) {
VOP_UNLOCK(fvp, 0, p);
error = EACCES;
  597                         goto abortit;
  598                 }
  599                 /*
  600                  * Avoid ".", "..", and aliases of "." for obvious reasons.
  601                  */
  602                 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
dp == ip ||
  604                         (fcnp->cn_flags&ISDOTDOT) ||
  605                         (tcnp->cn_flags & ISDOTDOT) ||
  606                     (ip->i_flag & IN_RENAME)) {
VOP_UNLOCK(fvp, 0, p);
error = EINVAL;
  609                         goto abortit;
  610                 }
ip->i_flag |= IN_RENAME;
oldparent = dp->i_number;
doingdirectory++;
  614         }
vrele(fdvp);
  617         /*
  618          * When the target exists, both the directory
  619          * and target vnodes are returned locked.
  620          */
dp = VTOI(tdvp);
xp = NULL;
  623         if (tvp)
xp = VTOI(tvp);
  626         /*
  627          * 1) Bump link count while we're moving stuff
  628          *    around.  If we crash somewhere before
  629          *    completing our work, the link count
  630          *    may be wrong, but correctable.
  631          */
ip->i_e2fs_nlink++;
ip->i_flag |= IN_CHANGE;
  634         if ((error = ext2fs_update(ip, NULL, NULL, 1)) != 0) {
VOP_UNLOCK(fvp, 0, p);
  636                 goto bad;
  637         }
  639         /*
  640          * If ".." must be changed (ie the directory gets a new
  641          * parent) then the source directory must not be in the
  642          * directory hierarchy above the target, as this would
  643          * orphan everything below the source directory. Also
  644          * the user must have write permission in the source so
  645          * as to be able to change "..". We must repeat the call 
  646          * to namei, as the parent directory is unlocked by the
  647          * call to checkpath().
  648          */
error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
VOP_UNLOCK(fvp, 0, p);
  651         if (oldparent != dp->i_number)
newparent = dp->i_number;
  653         if (doingdirectory && newparent) {
  654                 if (error)      /* write access check above */
  655                         goto bad;
  656                 if (xp != NULL)
vput(tvp);
error = ext2fs_checkpath(ip, dp, tcnp->cn_cred);
  659                 if (error != 0)
  660                         goto out;
  661                 if ((tcnp->cn_flags & SAVESTART) == 0)
panic("ext2fs_rename: lost to startdir");
  663                 if ((error = relookup(tdvp, &tvp, tcnp)) != 0)
  664                         goto out;
dp = VTOI(tdvp);
xp = NULL;
  667                 if (tvp)
xp = VTOI(tvp);
  669         }
  670         /*
  671          * 2) If target doesn't exist, link the target
  672          *    to the source and unlink the source. 
  673          *    Otherwise, rewrite the target directory
  674          *    entry to reference the source inode and
  675          *    expunge the original entry's existence.
  676          */
  677         if (xp == NULL) {
  678                 if (dp->i_dev != ip->i_dev)
panic("rename: EXDEV");
  680                 /*
  681                  * Account for ".." in new directory.
  682                  * When source and destination have the same
  683                  * parent we don't fool with the link count.
  684                  */
  685                 if (doingdirectory && newparent) {
  686                         if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
error = EMLINK;
  688                                 goto bad;
  689                         }
dp->i_e2fs_nlink++;
dp->i_flag |= IN_CHANGE;
  692                         if ((error = ext2fs_update(dp, NULL, NULL, 1)) != 0)
  693                                 goto bad;
  694                 }
error = ext2fs_direnter(ip, tdvp, tcnp);
  696                 if (error != 0) {
  697                         if (doingdirectory && newparent) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
  700                                 (void)ext2fs_update(dp, NULL, NULL, 1);
  701                         }
  702                         goto bad;
  703                 }
vput(tdvp);
  705         } else {
  706                 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
panic("rename: EXDEV");
  708                 /*
  709                  * Short circuit rename(foo, foo).
  710                  */
  711                 if (xp->i_number == ip->i_number)
panic("rename: same file");
  713                 /*
  714                  * If the parent directory is "sticky", then the user must
  715                  * own the parent directory, or the destination of the rename,
  716                  * otherwise the destination may not be changed (except by
  717                  * root). This implements append-only directories.
  718                  */
  719                 if ((dp->i_e2fs_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 &&
tcnp->cn_cred->cr_uid != dp->i_e2fs_uid &&
xp->i_e2fs_uid != tcnp->cn_cred->cr_uid) {
error = EPERM;
  723                         goto bad;
  724                 }
  725                 /*
  726                  * Target must be empty if a directory and have no links
  727                  * to it. Also, ensure source and target are compatible
  728                  * (both directories, or both not directories).
  729                  */
  730                 if ((xp->i_e2fs_mode & IFMT) == IFDIR) {
  731                         if (!ext2fs_dirempty(xp, dp->i_number, tcnp->cn_cred) ||
xp->i_e2fs_nlink > 2) {
error = ENOTEMPTY;
  734                                 goto bad;
  735                         }
  736                         if (!doingdirectory) {
error = ENOTDIR;
  738                                 goto bad;
  739                         }
cache_purge(tdvp);
  741                 } else if (doingdirectory) {
error = EISDIR;
  743                         goto bad;
  744                 }
error = ext2fs_dirrewrite(dp, ip, tcnp);
  746                 if (error != 0)
  747                         goto bad;
  748                 /*
  749                  * If the target directory is in the same
  750                  * directory as the source directory,
  751                  * decrement the link count on the parent
  752                  * of the target directory.
  753                  */
  754                  if (doingdirectory && !newparent) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
  757                 }
vput(tdvp);
  759                 /*
  760                  * Adjust the link count of the target to
  761                  * reflect the dirrewrite above.  If this is
  762                  * a directory it is empty and there are
  763                  * no links to it, so we can squash the inode and
  764                  * any space associated with it.  We disallowed
  765                  * renaming over top of a directory with links to
  766                  * it above, as the remaining link would point to
  767                  * a directory without "." or ".." entries.
  768                  */
xp->i_e2fs_nlink--;
  770                 if (doingdirectory) {
  771                         if (--xp->i_e2fs_nlink != 0)
panic("rename: linked directory");
error = ext2fs_truncate(xp, (off_t)0, IO_SYNC,
tcnp->cn_cred);
  775                 }
xp->i_flag |= IN_CHANGE;
vput(tvp);
xp = NULL;
  779         }
  781         /*
  782          * 3) Unlink the source.
  783          */
fcnp->cn_flags &= ~MODMASK;
fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
  786         if ((fcnp->cn_flags & SAVESTART) == 0)
panic("ext2fs_rename: lost from startdir");
  788         (void) relookup(fdvp, &fvp, fcnp);
  789         if (fvp != NULL) {
xp = VTOI(fvp);
dp = VTOI(fdvp);
  792         } else {
  793                 /*
  794                  * From name has disappeared.
  795                  */
  796                 if (doingdirectory)
panic("ext2fs_rename: lost dir entry");
vrele(ap->a_fvp);
  799                 return (0);
  800         }
  801         /*
  802          * Ensure that the directory entry still exists and has not
  803          * changed while the new name has been entered. If the source is
  804          * a file then the entry may have been unlinked or renamed. In
  805          * either case there is no further work to be done. If the source
  806          * is a directory then it cannot have been rmdir'ed; its link
  807          * count of three would cause a rmdir to fail with ENOTEMPTY.
  808          * The IRENAME flag ensures that it cannot be moved by another
  809          * rename.
  810          */
  811         if (xp != ip) {
  812                 if (doingdirectory)
panic("ext2fs_rename: lost dir entry");
  814         } else {
  815                 /*
  816                  * If the source is a directory with a
  817                  * new parent, the link count of the old
  818                  * parent directory must be decremented
  819                  * and ".." set to point to the new parent.
  820                  */
  821                 if (doingdirectory && newparent) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf,
  825                                 sizeof (struct ext2fs_dirtemplate), (off_t)0,
UIO_SYSSPACE, IO_NODELOCKED, 
tcnp->cn_cred, (size_t *)0, (struct proc *)0);
  828                         if (error == 0) {
namlen = dirbuf.dotdot_namlen;
  830                                 if (namlen != 2 ||
dirbuf.dotdot_name[0] != '.' ||
dirbuf.dotdot_name[1] != '.') {
ufs_dirbad(xp, (doff_t)12,
  834                                             "ext2fs_rename: mangled dir");
  835                                 } else {
dirbuf.dotdot_ino = h2fs32(newparent);
  837                                         (void) vn_rdwr(UIO_WRITE, fvp,
  838                                             (caddr_t)&dirbuf,
  839                                             sizeof (struct dirtemplate),
  840                                             (off_t)0, UIO_SYSSPACE,
IO_NODELOCKED|IO_SYNC,
tcnp->cn_cred, (size_t *)0,
  843                                             (struct proc *)0);
cache_purge(fdvp);
  845                                 }
  846                         }
  847                 }
error = ext2fs_dirremove(fdvp, fcnp);
  849                 if (!error) {
xp->i_e2fs_nlink--;
xp->i_flag |= IN_CHANGE;
  852                 }
xp->i_flag &= ~IN_RENAME;
  854         }
  855         if (dp)
vput(fdvp);
  857         if (xp)
vput(fvp);
vrele(ap->a_fvp);
  860         return (error);
bad:
  863         if (xp)
vput(ITOV(xp));
vput(ITOV(dp));
out:
  867         if (doingdirectory)
ip->i_flag &= ~IN_RENAME;
  869         if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) {
ip->i_e2fs_nlink--;
ip->i_flag |= IN_CHANGE;
vput(fvp);
  873         } else
vrele(fvp);
  875         return (error);
  876 }
  878 /*
  879  * Mkdir system call
  880  */
  881 int
ext2fs_mkdir(void *v)
  883 {
  884         struct vop_mkdir_args *ap = v;
  885         struct vnode *dvp = ap->a_dvp;
  886         struct vattr *vap = ap->a_vap;
  887         struct componentname *cnp = ap->a_cnp;
  888         struct inode *ip, *dp;
  889         struct vnode *tvp;
  890         struct ext2fs_dirtemplate dirtemplate;
mode_t dmode;
  892         int error;
  894 #ifdef DIAGNOSTIC
  895         if ((cnp->cn_flags & HASBUF) == 0)
panic("ext2fs_mkdir: no name");
  897 #endif
dp = VTOI(dvp);
  899         if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
error = EMLINK;
  901                 goto out;
  902         }
dmode = vap->va_mode & ACCESSPERMS;
dmode |= IFDIR;
  905         /*
  906          * Must simulate part of ext2fs_makeinode here to acquire the inode,
  907          * but not have it entered in the parent directory. The entry is
  908          * made later after writing "." and ".." entries.
  909          */
  910         if ((error = ext2fs_inode_alloc(dp, dmode, cnp->cn_cred, &tvp)) != 0)
  911                 goto out;
ip = VTOI(tvp);
ip->i_e2fs_uid = cnp->cn_cred->cr_uid;
ip->i_e2fs_gid = dp->i_e2fs_gid;
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
ip->i_e2fs_mode = dmode;
tvp->v_type = VDIR;     /* Rest init'd in getnewvnode(). */
ip->i_e2fs_nlink = 2;
error = ext2fs_update(ip, NULL, NULL, 1);
  921         /*
  922          * Bump link count in parent directory
  923          * to reflect work done below.  Should
  924          * be done before reference is created
  925          * so reparation is possible if we crash.
  926          */
dp->i_e2fs_nlink++;
dp->i_flag |= IN_CHANGE;
  929         if ((error = ext2fs_update(dp, NULL, NULL, 1)) != 0)
  930                 goto bad;
  932         /* Initialize directory with "." and ".." from static template. */
bzero(&dirtemplate, sizeof(dirtemplate));
dirtemplate.dot_ino = h2fs32(ip->i_number);
dirtemplate.dot_reclen = h2fs16(12);
dirtemplate.dot_namlen = 1;
  937         if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
  938             (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
dirtemplate.dot_type = EXT2_FT_DIR;
  940         }
dirtemplate.dot_name[0] = '.';
dirtemplate.dotdot_ino = h2fs32(dp->i_number);
dirtemplate.dotdot_reclen = h2fs16(VTOI(dvp)->i_e2fs->e2fs_bsize - 12);
dirtemplate.dotdot_namlen = 2;
  945         if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
  946             (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
dirtemplate.dotdot_type = EXT2_FT_DIR;
  948         }
dirtemplate.dotdot_name[0] = dirtemplate.dotdot_name[1] = '.';
error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate,
  951             sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE,
IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (size_t *)0, (struct proc *)0);
  953         if (error) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
  956                 goto bad;
  957         }
  958         if (VTOI(dvp)->i_e2fs->e2fs_bsize >
VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
panic("ext2fs_mkdir: blksize"); /* XXX should grow with balloc() */
  961         else {
error = ext2fs_setsize(ip, VTOI(dvp)->i_e2fs->e2fs_bsize);
  963                 if (error) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
  966                         goto bad;
  967                 }
ip->i_flag |= IN_CHANGE;
  969         }
  971         /* Directory set up, now install its entry in the parent directory. */
error = ext2fs_direnter(ip, dvp, cnp);
  973         if (error != 0) {
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
  976         }
bad:
  978         /*
  979          * No need to do an explicit VOP_TRUNCATE here, vrele will do this
  980          * for us because we set the link count to 0.
  981          */
  982         if (error) {
ip->i_e2fs_nlink = 0;
ip->i_flag |= IN_CHANGE;
vput(tvp);
  986         } else
  987                 *ap->a_vpp = tvp;
out:
pool_put(&namei_pool, cnp->cn_pnbuf);
vput(dvp);
  991         return (error);
  992 }
  994 /*
  995  * Rmdir system call.
  996  */
  997 int
ext2fs_rmdir(void *v)
  999 {
 1000         struct vop_rmdir_args *ap = v;
 1001         struct vnode *vp = ap->a_vp;
 1002         struct vnode *dvp = ap->a_dvp;
 1003         struct componentname *cnp = ap->a_cnp;
 1004         struct inode *ip, *dp;
 1005         int error;
ip = VTOI(vp);
dp = VTOI(dvp);
 1009         /*
 1010          * No rmdir "." please.
 1011          */
 1012         if (dp == ip) {
vrele(dvp);
vput(vp);
 1015                 return (EINVAL);
 1016         }
 1017         /*
 1018          * Verify the directory is empty (and valid).
 1019          * (Rmdir ".." won't be valid since
 1020          *  ".." will contain a reference to
 1021          *  the current directory and thus be
 1022          *  non-empty.)
 1023          */
error = 0;
 1025         if (ip->i_e2fs_nlink != 2 ||
 1026             !ext2fs_dirempty(ip, dp->i_number, cnp->cn_cred)) {
error = ENOTEMPTY;
 1028                 goto out;
 1029         }
 1030         if ((dp->i_e2fs_flags & EXT2_APPEND) ||
 1031                                  (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND))) {
error = EPERM;
 1033                 goto out;
 1034         }
 1035         /*
 1036          * Delete reference to directory before purging
 1037          * inode.  If we crash in between, the directory
 1038          * will be reattached to lost+found,
 1039          */
error = ext2fs_dirremove(dvp, cnp);
 1041         if (error != 0)
 1042                 goto out;
dp->i_e2fs_nlink--;
dp->i_flag |= IN_CHANGE;
cache_purge(dvp);
vput(dvp);
dvp = NULL;
 1048         /*
 1049          * Truncate inode.  The only stuff left
 1050          * in the directory is "." and "..".  The
 1051          * "." reference is inconsequential since
 1052          * we're quashing it.  The ".." reference
 1053          * has already been adjusted above.  We've
 1054          * removed the "." reference and the reference
 1055          * in the parent directory, but there may be
 1056          * other hard links so decrement by 2 and
 1057          * worry about them later.
 1058          */
ip->i_e2fs_nlink -= 2;
error = ext2fs_truncate(ip, (off_t)0, IO_SYNC, cnp->cn_cred);
cache_purge(ITOV(ip));
out:
 1063         if (dvp)
vput(dvp);
vput(vp);
 1066         return (error);
 1067 }
 1069 /*
 1070  * symlink -- make a symbolic link
 1071  */
 1072 int
ext2fs_symlink(void *v)
 1074 {
 1075         struct vop_symlink_args *ap = v;
 1076         struct vnode *vp, **vpp = ap->a_vpp;
 1077         struct inode *ip;
 1078         int len, error;
error = ext2fs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
vpp, ap->a_cnp);
 1082         if (error)
 1083                 return (error);
vp = *vpp;
len = strlen(ap->a_target);
 1086         if (len < vp->v_mount->mnt_maxsymlinklen) {
ip = VTOI(vp);
bcopy(ap->a_target, (char *)ip->i_e2din->e2di_shortlink, len);
error = ext2fs_setsize(ip, len);
 1090                 if (error)
 1091                         goto bad;
ip->i_flag |= IN_CHANGE | IN_UPDATE;
 1093         } else
error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, NULL,
 1096                     (struct proc *)0);
bad:    
vput(vp);
 1099         return (error);
 1100 }
 1102 /*
 1103  * Return target name of a symbolic link
 1104  */
 1105 int
ext2fs_readlink(void *v)
 1107 {
 1108         struct vop_readlink_args *ap = v;
 1109         struct vnode *vp = ap->a_vp;
 1110         struct inode *ip = VTOI(vp);
 1111         int isize;
isize = ext2fs_size(ip);
 1114         if (isize < vp->v_mount->mnt_maxsymlinklen ||
 1115             (vp->v_mount->mnt_maxsymlinklen == 0 && ip->i_e2fs_nblock == 0)) {
uiomove((char *)ip->i_e2din->e2di_shortlink, isize, ap->a_uio);
 1117                 return (0);
 1118         }
 1119         return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
 1120 }
 1122 /*
 1123  * Advisory record locking support
 1124  */
 1125 int
ext2fs_advlock(void *v)
 1127 {
 1128         struct vop_advlock_args *ap = v;
 1129         struct inode *ip = VTOI(ap->a_vp);
 1131         return (lf_advlock(&ip->i_lockf, ext2fs_size(ip), ap->a_id, ap->a_op,
ap->a_fl, ap->a_flags));
 1133 }
 1135 /*
 1136  * Allocate a new inode.
 1137  */
 1138 int
ext2fs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
 1140     struct componentname *cnp)
 1141 {
 1142         struct inode *ip, *pdir;
 1143         struct vnode *tvp;
 1144         int error;
pdir = VTOI(dvp);
 1147 #ifdef DIAGNOSTIC
 1148         if ((cnp->cn_flags & HASBUF) == 0)
panic("ext2fs_makeinode: no name");
 1150 #endif
 1151         *vpp = NULL;
 1152         if ((mode & IFMT) == 0)
mode |= IFREG;
 1155         if ((error = ext2fs_inode_alloc(pdir, mode, cnp->cn_cred, &tvp)) 
 1156             != 0) {
pool_put(&namei_pool, cnp->cn_pnbuf);
vput(dvp);
 1159                 return (error);
 1160         }
ip = VTOI(tvp);
ip->i_e2fs_gid = pdir->i_e2fs_gid;
ip->i_e2fs_uid = cnp->cn_cred->cr_uid;
ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
ip->i_e2fs_mode = mode;
tvp->v_type = IFTOVT(mode);     /* Rest init'd in getnewvnode(). */
ip->i_e2fs_nlink = 1;
 1168         if ((ip->i_e2fs_mode & ISGID) &&
 1169                 !groupmember(ip->i_e2fs_gid, cnp->cn_cred) &&
suser_ucred(cnp->cn_cred))
ip->i_e2fs_mode &= ~ISGID;
 1173         /*
 1174          * Make sure inode goes to disk before directory entry.
 1175          */
 1176         if ((error = ext2fs_update(ip, NULL, NULL, 1)) != 0)
 1177                 goto bad;
error = ext2fs_direnter(ip, dvp, cnp);
 1179         if (error != 0)
 1180                 goto bad;
 1181         if ((cnp->cn_flags & SAVESTART) == 0)
pool_put(&namei_pool, cnp->cn_pnbuf);
vput(dvp);
 1184         *vpp = tvp;
 1185         return (0);
bad:
 1188         /*
 1189          * Write error occurred trying to update the inode
 1190          * or the directory so must deallocate the inode.
 1191          */
pool_put(&namei_pool, cnp->cn_pnbuf);
vput(dvp);
ip->i_e2fs_nlink = 0;
ip->i_flag |= IN_CHANGE;
tvp->v_type = VNON;
vput(tvp);
 1198         return (error);
 1199 }
 1201 /*
 1202  * Synch an open file.
 1203  */
 1204 /* ARGSUSED */
 1205 int
ext2fs_fsync(void *v)
 1207 {
 1208         struct vop_fsync_args *ap = v;
 1209         struct vnode *vp = ap->a_vp;
vflushbuf(vp, ap->a_waitfor == MNT_WAIT);
 1212         return (ext2fs_update(VTOI(ap->a_vp), NULL, NULL, 
ap->a_waitfor == MNT_WAIT));
 1214 }
 1216 /*
 1217  * Reclaim an inode so that it can be used for other purposes.
 1218  */
 1219 int
ext2fs_reclaim(void *v)
 1221 {
 1222         struct vop_reclaim_args *ap = v;
 1223         struct vnode *vp = ap->a_vp;
 1224         struct inode *ip;
 1225 #ifdef DIAGNOSTIC
 1226         extern int prtactive;
 1228         if (prtactive && vp->v_usecount != 0) 
vprint("ext2fs_reclaim: pushing active", vp);
 1230 #endif
 1232         /*
 1233          * Remove the inode from its hash chain.
 1234          */
ip = VTOI(vp);
ufs_ihashrem(ip);
 1238         /*
 1239          * Purge old data structures associated with the inode.
 1240          */
cache_purge(vp);
 1242         if (ip->i_devvp)
vrele(ip->i_devvp);
 1245         if (ip->i_e2din != NULL)
pool_put(&ext2fs_dinode_pool, ip->i_e2din);
pool_put(&ext2fs_inode_pool, ip);
vp->v_data = NULL;
 1252         return (0);
 1253 }
 1255 /* Global vfs data structures for ext2fs. */
 1256 int (**ext2fs_vnodeop_p)(void *);
 1257 struct vnodeopv_entry_desc ext2fs_vnodeop_entries[] = {
 1258         { &vop_default_desc, vn_default_error },
 1259         { &vop_lookup_desc, ext2fs_lookup },    /* lookup */
 1260         { &vop_create_desc, ext2fs_create },    /* create */
 1261         { &vop_mknod_desc, ext2fs_mknod },              /* mknod */
 1262         { &vop_open_desc, ext2fs_open },                /* open */
 1263         { &vop_close_desc, ufs_close },                 /* close */
 1264         { &vop_access_desc, ext2fs_access },    /* access */
 1265         { &vop_getattr_desc, ext2fs_getattr },  /* getattr */
 1266         { &vop_setattr_desc, ext2fs_setattr },  /* setattr */
 1267         { &vop_read_desc, ext2fs_read },                /* read */
 1268         { &vop_write_desc, ext2fs_write },              /* write */
 1269         { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
 1270         { &vop_poll_desc, ufs_poll },           /* poll */
 1271         { &vop_kqfilter_desc, vop_generic_kqfilter },   /* kqfilter */
 1272         { &vop_fsync_desc, ext2fs_fsync },              /* fsync */
 1273         { &vop_remove_desc, ext2fs_remove },    /* remove */
 1274         { &vop_link_desc, ext2fs_link },                /* link */
 1275         { &vop_rename_desc, ext2fs_rename },    /* rename */
 1276         { &vop_mkdir_desc, ext2fs_mkdir },              /* mkdir */
 1277         { &vop_rmdir_desc, ext2fs_rmdir },              /* rmdir */
 1278         { &vop_symlink_desc, ext2fs_symlink },  /* symlink */
 1279         { &vop_readdir_desc, ext2fs_readdir },  /* readdir */
 1280         { &vop_readlink_desc, ext2fs_readlink },/* readlink */
 1281         { &vop_abortop_desc, vop_generic_abortop },             /* abortop */
 1282         { &vop_inactive_desc, ext2fs_inactive },/* inactive */
 1283         { &vop_reclaim_desc, ext2fs_reclaim },  /* reclaim */
 1284         { &vop_lock_desc, ufs_lock },                   /* lock */
 1285         { &vop_unlock_desc, ufs_unlock },               /* unlock */
 1286         { &vop_bmap_desc, ext2fs_bmap },                /* bmap */
 1287         { &vop_strategy_desc, ufs_strategy },   /* strategy */
 1288         { &vop_print_desc, ufs_print },                 /* print */
 1289         { &vop_islocked_desc, ufs_islocked },   /* islocked */
 1290         { &vop_pathconf_desc, ufs_pathconf },   /* pathconf */
 1291         { &vop_advlock_desc, ext2fs_advlock },  /* advlock */
 1292         { &vop_bwrite_desc, vop_generic_bwrite },               /* bwrite */
 1293         { NULL, NULL }
 1294 };
 1295 struct vnodeopv_desc ext2fs_vnodeop_opv_desc =
 1296         { &ext2fs_vnodeop_p, ext2fs_vnodeop_entries };
 1298 int (**ext2fs_specop_p)(void *);
 1299 struct vnodeopv_entry_desc ext2fs_specop_entries[] = {
 1300         { &vop_default_desc, spec_vnoperate },
 1301         { &vop_close_desc, ufsspec_close },             /* close */
 1302         { &vop_access_desc, ext2fs_access },    /* access */
 1303         { &vop_getattr_desc, ext2fs_getattr },  /* getattr */
 1304         { &vop_setattr_desc, ext2fs_setattr },  /* setattr */
 1305         { &vop_read_desc, ufsspec_read },               /* read */
 1306         { &vop_write_desc, ufsspec_write },             /* write */
 1307         { &vop_fsync_desc, ext2fs_fsync },              /* fsync */
 1308         { &vop_inactive_desc, ext2fs_inactive },/* inactive */
 1309         { &vop_reclaim_desc, ext2fs_reclaim },  /* reclaim */
 1310         { &vop_lock_desc, ufs_lock },                   /* lock */
 1311         { &vop_unlock_desc, ufs_unlock },               /* unlock */
 1312         { &vop_print_desc, ufs_print },                 /* print */
 1313         { &vop_islocked_desc, ufs_islocked },   /* islocked */
 1314         { NULL, NULL }
 1315 };
 1316 struct vnodeopv_desc ext2fs_specop_opv_desc =
 1317         { &ext2fs_specop_p, ext2fs_specop_entries };
 1319 #ifdef FIFO
 1320 int (**ext2fs_fifoop_p)(void *);
 1321 struct vnodeopv_entry_desc ext2fs_fifoop_entries[] = {
 1322         { &vop_default_desc, fifo_vnoperate },
 1323         { &vop_close_desc, ufsfifo_close },             /* close */
 1324         { &vop_access_desc, ext2fs_access },    /* access */
 1325         { &vop_getattr_desc, ext2fs_getattr },  /* getattr */
 1326         { &vop_setattr_desc, ext2fs_setattr },  /* setattr */
 1327         { &vop_read_desc, ufsfifo_read },               /* read */
 1328         { &vop_write_desc, ufsfifo_write },             /* write */
 1329         { &vop_fsync_desc, ext2fs_fsync },              /* fsync */
 1330         { &vop_inactive_desc, ext2fs_inactive },/* inactive */
 1331         { &vop_reclaim_desc, ext2fsfifo_reclaim },      /* reclaim */
 1332         { &vop_lock_desc, ufs_lock },                   /* lock */
 1333         { &vop_unlock_desc, ufs_unlock },               /* unlock */
 1334         { &vop_print_desc, ufs_print },                 /* print */
 1335         { &vop_islocked_desc, ufs_islocked },   /* islocked */
 1336         { &vop_bwrite_desc, vop_generic_bwrite },               /* bwrite */
 1337         { NULL, NULL }
 1338 };
 1339 struct vnodeopv_desc ext2fs_fifoop_opv_desc =
 1340         { &ext2fs_fifoop_p, ext2fs_fifoop_entries };
 1342 int
ext2fsfifo_reclaim(void *v)
 1344 {
fifo_reclaim(v);
 1346         return (ext2fs_reclaim(v));
 1347 }
 1348 #endif /* FIFO */