[BACK]Return to ffs_vnops.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / ufs / ffs

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/ufs/ffs/ffs_vnops.c between version 1.86.4.9 and 1.109

version 1.86.4.9, 2007/08/20 21:28:25 version 1.109, 2009/02/01 17:36:43
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
   /*-
    * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
    * All rights reserved.
    *
    * This code is derived from software contributed to The NetBSD Foundation
    * by Wasabi Systems, Inc, and by Andrew Doran.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
    *
    * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
    * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
    * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    * POSSIBILITY OF SUCH DAMAGE.
    */
   
 /*  /*
  * Copyright (c) 1982, 1986, 1989, 1993   * Copyright (c) 1982, 1986, 1989, 1993
  *      The Regents of the University of California.  All rights reserved.   *      The Regents of the University of California.  All rights reserved.
Line 34 
Line 63 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
   #if defined(_KERNEL_OPT)
   #include "opt_ffs.h"
   #include "opt_wapbl.h"
   #endif
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/resourcevar.h>  #include <sys/resourcevar.h>
Line 48  __KERNEL_RCSID(0, "$NetBSD$");
Line 82  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/pool.h>  #include <sys/pool.h>
 #include <sys/signalvar.h>  #include <sys/signalvar.h>
 #include <sys/kauth.h>  #include <sys/kauth.h>
   #include <sys/wapbl.h>
 #include <sys/fstrans.h>  #include <sys/fstrans.h>
   
 #include <miscfs/fifofs/fifo.h>  #include <miscfs/fifofs/fifo.h>
Line 58  __KERNEL_RCSID(0, "$NetBSD$");
Line 93  __KERNEL_RCSID(0, "$NetBSD$");
 #include <ufs/ufs/dir.h>  #include <ufs/ufs/dir.h>
 #include <ufs/ufs/ufs_extern.h>  #include <ufs/ufs/ufs_extern.h>
 #include <ufs/ufs/ufsmount.h>  #include <ufs/ufs/ufsmount.h>
   #include <ufs/ufs/ufs_wapbl.h>
   
 #include <ufs/ffs/fs.h>  #include <ufs/ffs/fs.h>
 #include <ufs/ffs/ffs_extern.h>  #include <ufs/ffs/ffs_extern.h>
   
 #include <uvm/uvm.h>  #include <uvm/uvm.h>
   
 static int ffs_full_fsync(void *);  
   
 /* Global vfs data structures for ufs. */  /* Global vfs data structures for ufs. */
 int (**ffs_vnodeop_p)(void *);  int (**ffs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {  const struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
Line 81  const struct vnodeopv_entry_desc ffs_vno
Line 115  const struct vnodeopv_entry_desc ffs_vno
         { &vop_setattr_desc, ufs_setattr },             /* setattr */          { &vop_setattr_desc, ufs_setattr },             /* setattr */
         { &vop_read_desc, ffs_read },                   /* read */          { &vop_read_desc, ffs_read },                   /* read */
         { &vop_write_desc, ffs_write },                 /* write */          { &vop_write_desc, ffs_write },                 /* write */
         { &vop_lease_desc, ufs_lease_check },           /* lease */  
         { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */          { &vop_ioctl_desc, ufs_ioctl },                 /* ioctl */
         { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */          { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */
         { &vop_poll_desc, ufs_poll },                   /* poll */          { &vop_poll_desc, ufs_poll },                   /* poll */
Line 136  const struct vnodeopv_entry_desc ffs_spe
Line 169  const struct vnodeopv_entry_desc ffs_spe
         { &vop_setattr_desc, ufs_setattr },             /* setattr */          { &vop_setattr_desc, ufs_setattr },             /* setattr */
         { &vop_read_desc, ufsspec_read },               /* read */          { &vop_read_desc, ufsspec_read },               /* read */
         { &vop_write_desc, ufsspec_write },             /* write */          { &vop_write_desc, ufsspec_write },             /* write */
         { &vop_lease_desc, spec_lease_check },          /* lease */  
         { &vop_ioctl_desc, spec_ioctl },                /* ioctl */          { &vop_ioctl_desc, spec_ioctl },                /* ioctl */
         { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */          { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */
         { &vop_poll_desc, spec_poll },                  /* poll */          { &vop_poll_desc, spec_poll },                  /* poll */
Line 191  const struct vnodeopv_entry_desc ffs_fif
Line 223  const struct vnodeopv_entry_desc ffs_fif
         { &vop_setattr_desc, ufs_setattr },             /* setattr */          { &vop_setattr_desc, ufs_setattr },             /* setattr */
         { &vop_read_desc, ufsfifo_read },               /* read */          { &vop_read_desc, ufsfifo_read },               /* read */
         { &vop_write_desc, ufsfifo_write },             /* write */          { &vop_write_desc, ufsfifo_write },             /* write */
         { &vop_lease_desc, fifo_lease_check },          /* lease */  
         { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */          { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
         { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */          { &vop_fcntl_desc, ufs_fcntl },                 /* fcntl */
         { &vop_poll_desc, fifo_poll },                  /* poll */          { &vop_poll_desc, fifo_poll },                  /* poll */
Line 251  ffs_fsync(void *v)
Line 282  ffs_fsync(void *v)
         int bsize;          int bsize;
         daddr_t blk_high;          daddr_t blk_high;
         struct vnode *vp;          struct vnode *vp;
   #ifdef WAPBL
           struct mount *mp;
   #endif
   
         vp = ap->a_vp;          vp = ap->a_vp;
   
Line 260  ffs_fsync(void *v)
Line 294  ffs_fsync(void *v)
          */           */
         if ((ap->a_offlo == 0 && ap->a_offhi == 0) || DOINGSOFTDEP(vp) ||          if ((ap->a_offlo == 0 && ap->a_offhi == 0) || DOINGSOFTDEP(vp) ||
             (vp->v_type != VREG)) {              (vp->v_type != VREG)) {
                 error = ffs_full_fsync(v);                  int flags = ap->a_flags;
                   error = ffs_full_fsync(vp, flags);
                 goto out;                  goto out;
         }          }
   
Line 281  ffs_fsync(void *v)
Line 316  ffs_fsync(void *v)
                 goto out;                  goto out;
         }          }
   
   #ifdef WAPBL
           mp = wapbl_vptomp(vp);
           if (mp->mnt_wapbl) {
                   if (ap->a_flags & FSYNC_DATAONLY) {
                           fstrans_done(vp->v_mount);
                           return 0;
                   }
                   error = 0;
                   if (vp->v_tag == VT_UFS && VTOI(vp)->i_flag &
                       (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY |
                                    IN_MODIFIED | IN_ACCESSED)) {
                           error = UFS_WAPBL_BEGIN(mp);
                           if (error) {
                                   fstrans_done(vp->v_mount);
                                   return error;
                           }
                           error = ffs_update(vp, NULL, NULL,
                                   (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0);
                           UFS_WAPBL_END(mp);
                   }
                   if (error || (ap->a_flags & FSYNC_NOLOG)) {
                           fstrans_done(vp->v_mount);
                           return error;
                   }
                   error = wapbl_flush(mp->mnt_wapbl, 0);
                   fstrans_done(vp->v_mount);
                   return error;
           }
   #endif /* WAPBL */
   
         /*          /*
          * Then, flush indirect blocks.           * Then, flush indirect blocks.
          */           */
Line 290  ffs_fsync(void *v)
Line 355  ffs_fsync(void *v)
                 if (error)                  if (error)
                         goto out;                          goto out;
   
                 mutex_enter(&bqueue_lock);                  mutex_enter(&bufcache_lock);
                 for (i = 0; i < num; i++) {                  for (i = 0; i < num; i++) {
                         if ((bp = incore(vp, ia[i].in_lbn)) == NULL)                          if ((bp = incore(vp, ia[i].in_lbn)) == NULL)
                                 continue;                                  continue;
                         mutex_enter(&bp->b_interlock);                          if ((bp->b_cflags & BC_BUSY) != 0 ||
                         if ((bp->b_flags & (B_BUSY | B_DELWRI)) != B_DELWRI) {                              (bp->b_oflags & BO_DELWRI) == 0)
                                 mutex_exit(&bp->b_interlock);  
                                 continue;                                  continue;
                         }                          bp->b_cflags |= BC_BUSY | BC_VFLUSH;
                         bp->b_flags |= B_BUSY | B_VFLUSH;                          mutex_exit(&bufcache_lock);
                         mutex_exit(&bp->b_interlock);  
                         mutex_exit(&bqueue_lock);  
                         bawrite(bp);                          bawrite(bp);
                         mutex_enter(&bqueue_lock);                          mutex_enter(&bufcache_lock);
                 }                  }
                 mutex_exit(&bqueue_lock);                  mutex_exit(&bufcache_lock);
         }          }
   
         if (ap->a_flags & FSYNC_WAIT) {          if (ap->a_flags & FSYNC_WAIT) {
Line 322  ffs_fsync(void *v)
Line 384  ffs_fsync(void *v)
         if (error == 0 && ap->a_flags & FSYNC_CACHE) {          if (error == 0 && ap->a_flags & FSYNC_CACHE) {
                 int l = 0;                  int l = 0;
                 VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &l, FWRITE,                  VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &l, FWRITE,
                         ap->a_l->l_cred, ap->a_l);                          curlwp->l_cred);
         }          }
   
 out:  out:
Line 331  out:
Line 393  out:
 }  }
   
 /*  /*
  * Synch an open file.   * Synch an open file.  Called for VOP_FSYNC() and VFS_FSYNC().
    *
    * BEWARE: THIS ROUTINE ACCEPTS BOTH FFS AND NON-FFS VNODES.
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 static int  int
 ffs_full_fsync(void *v)  ffs_full_fsync(struct vnode *vp, int flags)
 {  {
         struct vop_fsync_args /* {  
                 struct vnode *a_vp;  
                 kauth_cred_t a_cred;  
                 int a_flags;  
                 off_t a_offlo;  
                 off_t a_offhi;  
                 struct lwp *a_l;  
         } */ *ap = v;  
         struct vnode *vp = ap->a_vp;  
         struct buf *bp, *nbp;          struct buf *bp, *nbp;
         int error, passes, skipmeta, inodedeps_only, waitfor;          int error, passes, skipmeta, inodedeps_only, waitfor;
           struct mount *mp;
   
           error = 0;
   
           if ((flags & FSYNC_VFS) != 0) {
                   KASSERT(vp->v_specmountpoint != NULL);
                   mp = vp->v_specmountpoint;
                   KASSERT(vp->v_type == VBLK);
           } else {
                   mp = vp->v_mount;
                   KASSERT(vp->v_tag == VT_UFS);
           }
   
         if (vp->v_type == VBLK &&          if (vp->v_type == VBLK &&
             vp->v_specmountpoint != NULL &&              vp->v_specmountpoint != NULL &&
Line 356  ffs_full_fsync(void *v)
Line 423  ffs_full_fsync(void *v)
   
         mutex_enter(&vp->v_interlock);          mutex_enter(&vp->v_interlock);
   
         inodedeps_only = DOINGSOFTDEP(vp) && (ap->a_flags & FSYNC_RECLAIM)          inodedeps_only = DOINGSOFTDEP(vp) && (flags & FSYNC_RECLAIM)
             && UVM_OBJ_IS_CLEAN(&vp->v_uobj) && LIST_EMPTY(&vp->v_dirtyblkhd);              && UVM_OBJ_IS_CLEAN(&vp->v_uobj) && LIST_EMPTY(&vp->v_dirtyblkhd);
   
         /*          /*
Line 364  ffs_full_fsync(void *v)
Line 431  ffs_full_fsync(void *v)
          */           */
   
         if (vp->v_type == VREG || vp->v_type == VBLK) {          if (vp->v_type == VREG || vp->v_type == VBLK) {
                 error = VOP_PUTPAGES(vp, 0, 0, PGO_ALLPAGES | PGO_CLEANIT |                  int pflags = PGO_ALLPAGES | PGO_CLEANIT;
                     ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0) |  
                     (fstrans_getstate(vp->v_mount) == FSTRANS_SUSPENDING ?                  if ((flags & FSYNC_WAIT))
                         PGO_FREE : 0));                          pflags |= PGO_SYNCIO;
                 if (error) {                  if (vp->v_type == VREG &&
                       fstrans_getstate(mp) == FSTRANS_SUSPENDING)
                           pflags |= PGO_FREE;
                   error = VOP_PUTPAGES(vp, 0, 0, pflags);
                   if (error)
                           return error;
           } else {
                   mutex_exit(&vp->v_interlock);
           }
   
   #ifdef WAPBL
           if (mp && mp->mnt_wapbl) {
                   error = 0;
                   if (flags & FSYNC_DATAONLY)
                         return error;                          return error;
   
                   if ((flags & FSYNC_VFS) == 0 && VTOI(vp) != NULL &&
                       (VTOI(vp)->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE
                       | IN_MODIFY | IN_MODIFIED | IN_ACCESSED)) != 0) {
                           error = UFS_WAPBL_BEGIN(mp);
                           if (error)
                                   return error;
                           error = ffs_update(vp, NULL, NULL,
                                   (flags & FSYNC_WAIT) ? UPDATE_WAIT : 0);
                           UFS_WAPBL_END(mp);
                 }                  }
                 mutex_enter(&vp->v_interlock);                  if (error || (flags & FSYNC_NOLOG))
                           return error;
   
                   /*
                    * Don't flush the log if the vnode being flushed
                    * contains no dirty buffers that could be in the log.
                    */
                   if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
                           error = wapbl_flush(mp->mnt_wapbl, 0);
                           if (error)
                                   return error;
                   }
   
                   if ((flags & FSYNC_WAIT) != 0) {
                           mutex_enter(&vp->v_interlock);
                           while (vp->v_numoutput)
                                   cv_wait(&vp->v_cv, &vp->v_interlock);
                           mutex_exit(&vp->v_interlock);
                   }
   
                   return error;
         }          }
   #endif /* WAPBL */
   
         passes = NIADDR + 1;          passes = NIADDR + 1;
         skipmeta = 0;          skipmeta = 0;
         if (ap->a_flags & FSYNC_WAIT)          if (flags & FSYNC_WAIT)
                 skipmeta = 1;                  skipmeta = 1;
   
 loop:  loop:
           mutex_enter(&bufcache_lock);
         LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {          LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
                 mutex_enter(&bp->b_interlock);                  bp->b_cflags &= ~BC_SCANNED;
                 bp->b_flags &= ~B_SCANNED;  
                 mutex_exit(&bp->b_interlock);  
         }          }
         for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {          for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
                 nbp = LIST_NEXT(bp, b_vnbufs);                  nbp = LIST_NEXT(bp, b_vnbufs);
                 mutex_enter(&bp->b_interlock);                  if (bp->b_cflags & (BC_BUSY | BC_SCANNED))
                 if (bp->b_flags & (B_BUSY | B_SCANNED)) {  
                         mutex_exit(&bp->b_interlock);  
                         continue;                          continue;
                 }                  if ((bp->b_oflags & BO_DELWRI) == 0)
                 if ((bp->b_flags & B_DELWRI) == 0)  
                         panic("ffs_fsync: not dirty");                          panic("ffs_fsync: not dirty");
                 if (skipmeta && bp->b_lblkno < 0) {                  if (skipmeta && bp->b_lblkno < 0)
                         mutex_exit(&bp->b_interlock);  
                         continue;                          continue;
                 }                  bp->b_cflags |= BC_BUSY | BC_VFLUSH | BC_SCANNED;
                 bp->b_flags |= B_BUSY | B_VFLUSH | B_SCANNED;                  mutex_exit(&bufcache_lock);
                 mutex_exit(&bp->b_interlock);  
                 /*                  /*
                  * On our final pass through, do all I/O synchronously                   * On our final pass through, do all I/O synchronously
                  * so that we can find out if our flush is failing                   * so that we can find out if our flush is failing
                  * because of write errors.                   * because of write errors.
                  */                   */
                 mutex_exit(&vp->v_interlock);                  if (passes > 0 || !(flags & FSYNC_WAIT))
                 if (passes > 0 || !(ap->a_flags & FSYNC_WAIT))  
                         (void) bawrite(bp);                          (void) bawrite(bp);
                 else if ((error = bwrite(bp)) != 0)                  else if ((error = bwrite(bp)) != 0)
                         return (error);                          return (error);
                 mutex_enter(&vp->v_interlock);  
                 /*                  /*
                  * Since we may have slept during the I/O, we need                   * Since we unlocked during the I/O, we need
                  * to start from a known point.                   * to start from a known point.
                  */                   */
                   mutex_enter(&bufcache_lock);
                 nbp = LIST_FIRST(&vp->v_dirtyblkhd);                  nbp = LIST_FIRST(&vp->v_dirtyblkhd);
         }          }
           mutex_exit(&bufcache_lock);
         if (skipmeta) {          if (skipmeta) {
                 skipmeta = 0;                  skipmeta = 0;
                 goto loop;                  goto loop;
         }          }
         if (ap->a_flags & FSYNC_WAIT) {  
           if ((flags & FSYNC_WAIT) != 0) {
                   mutex_enter(&vp->v_interlock);
                 while (vp->v_numoutput) {                  while (vp->v_numoutput) {
                         cv_wait(&vp->v_cv, &vp->v_interlock);                          cv_wait(&vp->v_cv, &vp->v_interlock);
                 }                  }
Line 431  loop:
Line 538  loop:
                  * Ensure that any filesystem metadata associated                   * Ensure that any filesystem metadata associated
                  * with the vnode has been written.                   * with the vnode has been written.
                  */                   */
                 if ((error = softdep_sync_metadata(ap)) != 0)                  if ((error = softdep_sync_metadata(vp)) != 0)
                         return (error);                          return (error);
   
                 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {                  if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
Line 452  loop:
Line 559  loop:
                                 vprint("ffs_fsync: dirty", vp);                                  vprint("ffs_fsync: dirty", vp);
 #endif  #endif
                 }                  }
         } else          }
                 mutex_exit(&vp->v_interlock);  
   
         if (inodedeps_only)          if (inodedeps_only)
                 waitfor = 0;                  waitfor = 0;
         else          else
                 waitfor = (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0;                  waitfor = (flags & FSYNC_WAIT) != 0 ? UPDATE_WAIT : 0;
         error = ffs_update(vp, NULL, NULL, waitfor);  
   
         if (error == 0 && ap->a_flags & FSYNC_CACHE) {          if ((flags & FSYNC_VFS) == 0)
                   error = ffs_update(vp, NULL, NULL, waitfor);
   
           if (error == 0 && (flags & FSYNC_CACHE) != 0) {
                 int i = 0;                  int i = 0;
                 VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &i, FWRITE,                  if ((flags & FSYNC_VFS) == 0) {
                         ap->a_l->l_cred, ap->a_l);                          KASSERT(VTOI(vp) != NULL);
                           vp = VTOI(vp)->i_devvp;
                   }
                   VOP_IOCTL(vp, DIOCCACHESYNC, &i, FWRITE, curlwp->l_cred);
         }          }
   
         return error;          return error;
Line 488  ffs_reclaim(void *v)
Line 599  ffs_reclaim(void *v)
         int error;          int error;
   
         fstrans_start(mp, FSTRANS_LAZY);          fstrans_start(mp, FSTRANS_LAZY);
         if ((error = ufs_reclaim(vp, ap->a_l)) != 0) {          if ((error = ufs_reclaim(vp)) != 0) {
                 fstrans_done(mp);                  fstrans_done(mp);
                 return (error);                  return (error);
         }          }
         if (ip->i_din.ffs1_din != NULL) {          if (ip->i_din.ffs1_din != NULL) {
                 if (ump->um_fstype == UFS1)                  if (ump->um_fstype == UFS1)
                         pool_put(&ffs_dinode1_pool, ip->i_din.ffs1_din);                          pool_cache_put(ffs_dinode1_cache, ip->i_din.ffs1_din);
                 else                  else
                         pool_put(&ffs_dinode2_pool, ip->i_din.ffs2_din);                          pool_cache_put(ffs_dinode2_cache, ip->i_din.ffs2_din);
         }          }
         /*          /*
          * To interlock with ffs_sync().           * To interlock with ffs_sync().
Line 511  ffs_reclaim(void *v)
Line 622  ffs_reclaim(void *v)
          * XXX MFS ends up here, too, to free an inode.  Should we create           * XXX MFS ends up here, too, to free an inode.  Should we create
          * XXX a separate pool for MFS inodes?           * XXX a separate pool for MFS inodes?
          */           */
         pool_put(&ffs_inode_pool, data);          pool_cache_put(ffs_inode_cache, data);
         fstrans_done(mp);          fstrans_done(mp);
         return (0);          return (0);
 }  }
Line 742  ffs_lock(void *v)
Line 853  ffs_lock(void *v)
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         struct mount *mp = vp->v_mount;          struct mount *mp = vp->v_mount;
           int flags = ap->a_flags;
   
           if ((flags & LK_INTERLOCK) != 0) {
                   mutex_exit(&vp->v_interlock);
                   flags &= ~LK_INTERLOCK;
           }
   
         /*          /*
          * Fake lock during file system suspension.           * Fake lock during file system suspension.
Line 749  ffs_lock(void *v)
Line 866  ffs_lock(void *v)
         if ((vp->v_type == VREG || vp->v_type == VDIR) &&          if ((vp->v_type == VREG || vp->v_type == VDIR) &&
             fstrans_is_owner(mp) &&              fstrans_is_owner(mp) &&
             fstrans_getstate(mp) == FSTRANS_SUSPENDING) {              fstrans_getstate(mp) == FSTRANS_SUSPENDING) {
                 if ((ap->a_flags & LK_INTERLOCK) != 0)  
                         mutex_exit(&vp->v_interlock);  
                 return 0;                  return 0;
         }          }
         return (lockmgr(vp->v_vnlock, ap->a_flags, &vp->v_interlock));  
           return (vlockmgr(vp->v_vnlock, flags));
 }  }
   
 /*  /*
Line 769  ffs_unlock(void *v)
Line 885  ffs_unlock(void *v)
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         struct mount *mp = vp->v_mount;          struct mount *mp = vp->v_mount;
   
           KASSERT(ap->a_flags == 0);
   
         /*          /*
          * Fake unlock during file system suspension.           * Fake unlock during file system suspension.
          */           */
         if ((vp->v_type == VREG || vp->v_type == VDIR) &&          if ((vp->v_type == VREG || vp->v_type == VDIR) &&
             fstrans_is_owner(mp) &&              fstrans_is_owner(mp) &&
             fstrans_getstate(mp) == FSTRANS_SUSPENDING) {              fstrans_getstate(mp) == FSTRANS_SUSPENDING) {
                 if ((ap->a_flags & LK_INTERLOCK) != 0)  
                         mutex_exit(&vp->v_interlock);  
                 return 0;                  return 0;
         }          }
         return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE,          return (vlockmgr(vp->v_vnlock, LK_RELEASE));
             &vp->v_interlock));  
 }  }
   
 /*  /*
Line 794  ffs_islocked(void *v)
Line 909  ffs_islocked(void *v)
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
   
         return (lockstatus(vp->v_vnlock));          return (vlockstatus(vp->v_vnlock));
 }  }
Legend:
Removed from v.1.86.4.9  
changed lines
  Added in v.1.109
CVSweb <webmaster@jp.NetBSD.org>