[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.59.2.1 and 1.86.4.9

version 1.59.2.1, 2003/07/02 15:27:22 version 1.86.4.9, 2007/08/20 21:28:25
Line 12 
Line 12 
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. Neither the name of the University nor the names of its contributors
  *    must display the following acknowledgement:  
  *      This product includes software developed by the University of  
  *      California, Berkeley and its contributors.  
  * 4. Neither the name of the University nor the names of its contributors  
  *    may be used to endorse or promote products derived from this software   *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.   *    without specific prior written permission.
  *   *
Line 51  __KERNEL_RCSID(0, "$NetBSD$");
Line 47  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/vnode.h>  #include <sys/vnode.h>
 #include <sys/pool.h>  #include <sys/pool.h>
 #include <sys/signalvar.h>  #include <sys/signalvar.h>
   #include <sys/kauth.h>
   #include <sys/fstrans.h>
   
 #include <miscfs/fifofs/fifo.h>  #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>  #include <miscfs/genfs/genfs.h>
Line 66  __KERNEL_RCSID(0, "$NetBSD$");
Line 64  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include <uvm/uvm.h>  #include <uvm/uvm.h>
   
 static int ffs_full_fsync __P((void *));  static int ffs_full_fsync(void *);
   
 /* Global vfs data structures for ufs. */  /* Global vfs data structures for ufs. */
 int (**ffs_vnodeop_p) __P((void *));  int (**ffs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {  const struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
         { &vop_default_desc, vn_default_error },          { &vop_default_desc, vn_default_error },
         { &vop_lookup_desc, ufs_lookup },               /* lookup */          { &vop_lookup_desc, ufs_lookup },               /* lookup */
Line 103  const struct vnodeopv_entry_desc ffs_vno
Line 101  const struct vnodeopv_entry_desc ffs_vno
         { &vop_abortop_desc, ufs_abortop },             /* abortop */          { &vop_abortop_desc, ufs_abortop },             /* abortop */
         { &vop_inactive_desc, ufs_inactive },           /* inactive */          { &vop_inactive_desc, ufs_inactive },           /* inactive */
         { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */          { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
         { &vop_lock_desc, ufs_lock },                   /* lock */          { &vop_lock_desc, ffs_lock },                   /* lock */
         { &vop_unlock_desc, ufs_unlock },               /* unlock */          { &vop_unlock_desc, ffs_unlock },               /* unlock */
         { &vop_bmap_desc, ufs_bmap },                   /* bmap */          { &vop_bmap_desc, ufs_bmap },                   /* bmap */
         { &vop_strategy_desc, ufs_strategy },           /* strategy */          { &vop_strategy_desc, ufs_strategy },           /* strategy */
         { &vop_print_desc, ufs_print },                 /* print */          { &vop_print_desc, ufs_print },                 /* print */
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ffs_islocked },           /* islocked */
         { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */          { &vop_pathconf_desc, ufs_pathconf },           /* pathconf */
         { &vop_advlock_desc, ufs_advlock },             /* advlock */          { &vop_advlock_desc, ufs_advlock },             /* advlock */
         { &vop_blkatoff_desc, ffs_blkatoff },           /* blkatoff */  
         { &vop_valloc_desc, ffs_valloc },               /* valloc */  
         { &vop_balloc_desc, ffs_balloc },               /* balloc */  
         { &vop_reallocblks_desc, ffs_reallocblks },     /* reallocblks */  
         { &vop_vfree_desc, ffs_vfree },                 /* vfree */  
         { &vop_truncate_desc, ffs_truncate },           /* truncate */  
         { &vop_update_desc, ffs_update },               /* update */  
         { &vop_bwrite_desc, vn_bwrite },                /* bwrite */          { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
         { &vop_getpages_desc, ffs_getpages },           /* getpages */          { &vop_getpages_desc, genfs_getpages },         /* getpages */
         { &vop_putpages_desc, ffs_putpages },           /* putpages */          { &vop_putpages_desc, genfs_putpages },         /* putpages */
           { &vop_openextattr_desc, ffs_openextattr },     /* openextattr */
           { &vop_closeextattr_desc, ffs_closeextattr },   /* closeextattr */
           { &vop_getextattr_desc, ffs_getextattr },       /* getextattr */
           { &vop_setextattr_desc, ffs_setextattr },       /* setextattr */
           { &vop_listextattr_desc, ffs_listextattr },     /* listextattr */
           { &vop_deleteextattr_desc, ffs_deleteextattr }, /* deleteextattr */
         { NULL, NULL }          { NULL, NULL }
 };  };
 const struct vnodeopv_desc ffs_vnodeop_opv_desc =  const struct vnodeopv_desc ffs_vnodeop_opv_desc =
         { &ffs_vnodeop_p, ffs_vnodeop_entries };          { &ffs_vnodeop_p, ffs_vnodeop_entries };
   
 int (**ffs_specop_p) __P((void *));  int (**ffs_specop_p)(void *);
 const struct vnodeopv_entry_desc ffs_specop_entries[] = {  const struct vnodeopv_entry_desc ffs_specop_entries[] = {
         { &vop_default_desc, vn_default_error },          { &vop_default_desc, vn_default_error },
         { &vop_lookup_desc, spec_lookup },              /* lookup */          { &vop_lookup_desc, spec_lookup },              /* lookup */
Line 159  const struct vnodeopv_entry_desc ffs_spe
Line 156  const struct vnodeopv_entry_desc ffs_spe
         { &vop_abortop_desc, spec_abortop },            /* abortop */          { &vop_abortop_desc, spec_abortop },            /* abortop */
         { &vop_inactive_desc, ufs_inactive },           /* inactive */          { &vop_inactive_desc, ufs_inactive },           /* inactive */
         { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */          { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
         { &vop_lock_desc, ufs_lock },                   /* lock */          { &vop_lock_desc, ffs_lock },                   /* lock */
         { &vop_unlock_desc, ufs_unlock },               /* unlock */          { &vop_unlock_desc, ffs_unlock },               /* unlock */
         { &vop_bmap_desc, spec_bmap },                  /* bmap */          { &vop_bmap_desc, spec_bmap },                  /* bmap */
         { &vop_strategy_desc, spec_strategy },          /* strategy */          { &vop_strategy_desc, spec_strategy },          /* strategy */
         { &vop_print_desc, ufs_print },                 /* print */          { &vop_print_desc, ufs_print },                 /* print */
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ffs_islocked },           /* islocked */
         { &vop_pathconf_desc, spec_pathconf },          /* pathconf */          { &vop_pathconf_desc, spec_pathconf },          /* pathconf */
         { &vop_advlock_desc, spec_advlock },            /* advlock */          { &vop_advlock_desc, spec_advlock },            /* advlock */
         { &vop_blkatoff_desc, spec_blkatoff },          /* blkatoff */  
         { &vop_valloc_desc, spec_valloc },              /* valloc */  
         { &vop_reallocblks_desc, spec_reallocblks },    /* reallocblks */  
         { &vop_vfree_desc, ffs_vfree },                 /* vfree */  
         { &vop_truncate_desc, spec_truncate },          /* truncate */  
         { &vop_update_desc, ffs_update },               /* update */  
         { &vop_bwrite_desc, vn_bwrite },                /* bwrite */          { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
         { &vop_getpages_desc, spec_getpages },          /* getpages */          { &vop_getpages_desc, spec_getpages },          /* getpages */
         { &vop_putpages_desc, spec_putpages },          /* putpages */          { &vop_putpages_desc, spec_putpages },          /* putpages */
           { &vop_openextattr_desc, ffs_openextattr },     /* openextattr */
           { &vop_closeextattr_desc, ffs_closeextattr },   /* closeextattr */
           { &vop_getextattr_desc, ffs_getextattr },       /* getextattr */
           { &vop_setextattr_desc, ffs_setextattr },       /* setextattr */
           { &vop_listextattr_desc, ffs_listextattr },     /* listextattr */
           { &vop_deleteextattr_desc, ffs_deleteextattr }, /* deleteextattr */
         { NULL, NULL }          { NULL, NULL }
 };  };
 const struct vnodeopv_desc ffs_specop_opv_desc =  const struct vnodeopv_desc ffs_specop_opv_desc =
         { &ffs_specop_p, ffs_specop_entries };          { &ffs_specop_p, ffs_specop_entries };
   
 int (**ffs_fifoop_p) __P((void *));  int (**ffs_fifoop_p)(void *);
 const struct vnodeopv_entry_desc ffs_fifoop_entries[] = {  const struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
         { &vop_default_desc, vn_default_error },          { &vop_default_desc, vn_default_error },
         { &vop_lookup_desc, fifo_lookup },              /* lookup */          { &vop_lookup_desc, fifo_lookup },              /* lookup */
Line 214  const struct vnodeopv_entry_desc ffs_fif
Line 211  const struct vnodeopv_entry_desc ffs_fif
         { &vop_abortop_desc, fifo_abortop },            /* abortop */          { &vop_abortop_desc, fifo_abortop },            /* abortop */
         { &vop_inactive_desc, ufs_inactive },           /* inactive */          { &vop_inactive_desc, ufs_inactive },           /* inactive */
         { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */          { &vop_reclaim_desc, ffs_reclaim },             /* reclaim */
         { &vop_lock_desc, ufs_lock },                   /* lock */          { &vop_lock_desc, ffs_lock },                   /* lock */
         { &vop_unlock_desc, ufs_unlock },               /* unlock */          { &vop_unlock_desc, ffs_unlock },               /* unlock */
         { &vop_bmap_desc, fifo_bmap },                  /* bmap */          { &vop_bmap_desc, fifo_bmap },                  /* bmap */
         { &vop_strategy_desc, fifo_strategy },          /* strategy */          { &vop_strategy_desc, fifo_strategy },          /* strategy */
         { &vop_print_desc, ufs_print },                 /* print */          { &vop_print_desc, ufs_print },                 /* print */
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ffs_islocked },           /* islocked */
         { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */          { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
         { &vop_advlock_desc, fifo_advlock },            /* advlock */          { &vop_advlock_desc, fifo_advlock },            /* advlock */
         { &vop_blkatoff_desc, fifo_blkatoff },          /* blkatoff */  
         { &vop_valloc_desc, fifo_valloc },              /* valloc */  
         { &vop_reallocblks_desc, fifo_reallocblks },    /* reallocblks */  
         { &vop_vfree_desc, ffs_vfree },                 /* vfree */  
         { &vop_truncate_desc, fifo_truncate },          /* truncate */  
         { &vop_update_desc, ffs_update },               /* update */  
         { &vop_bwrite_desc, vn_bwrite },                /* bwrite */          { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
         { &vop_putpages_desc, fifo_putpages },          /* putpages */          { &vop_putpages_desc, fifo_putpages },          /* putpages */
           { &vop_openextattr_desc, ffs_openextattr },     /* openextattr */
           { &vop_closeextattr_desc, ffs_closeextattr },   /* closeextattr */
           { &vop_getextattr_desc, ffs_getextattr },       /* getextattr */
           { &vop_setextattr_desc, ffs_setextattr },       /* setextattr */
           { &vop_listextattr_desc, ffs_listextattr },     /* listextattr */
           { &vop_deleteextattr_desc, ffs_deleteextattr }, /* deleteextattr */
         { NULL, NULL }          { NULL, NULL }
 };  };
 const struct vnodeopv_desc ffs_fifoop_opv_desc =  const struct vnodeopv_desc ffs_fifoop_opv_desc =
Line 238  const struct vnodeopv_desc ffs_fifoop_op
Line 235  const struct vnodeopv_desc ffs_fifoop_op
 #include <ufs/ufs/ufs_readwrite.c>  #include <ufs/ufs/ufs_readwrite.c>
   
 int  int
 ffs_fsync(v)  ffs_fsync(void *v)
         void *v;  
 {  {
         struct vop_fsync_args /* {          struct vop_fsync_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 int a_flags;                  int a_flags;
                 off_t a_offlo;                  off_t a_offlo;
                 off_t a_offhi;                  off_t a_offhi;
                 struct lwp *a_l;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct buf *bp;          struct buf *bp;
         int s, num, error, i;          int num, error, i;
         struct indir ia[NIADDR + 1];          struct indir ia[NIADDR + 1];
         int bsize;          int bsize;
         daddr_t blk_high;          daddr_t blk_high;
         struct vnode *vp;          struct vnode *vp;
   
           vp = ap->a_vp;
   
           fstrans_start(vp->v_mount, FSTRANS_LAZY);
         /*          /*
          * XXX no easy way to sync a range in a file with softdep.           * XXX no easy way to sync a range in a file with softdep.
          */           */
         if ((ap->a_offlo == 0 && ap->a_offhi == 0) || DOINGSOFTDEP(ap->a_vp))          if ((ap->a_offlo == 0 && ap->a_offhi == 0) || DOINGSOFTDEP(vp) ||
                 return ffs_full_fsync(v);              (vp->v_type != VREG)) {
                   error = ffs_full_fsync(v);
         vp = ap->a_vp;                  goto out;
           }
   
         bsize = ap->a_vp->v_mount->mnt_stat.f_iosize;          bsize = vp->v_mount->mnt_stat.f_iosize;
         blk_high = ap->a_offhi / bsize;          blk_high = ap->a_offhi / bsize;
         if (ap->a_offhi % bsize != 0)          if (ap->a_offhi % bsize != 0)
                 blk_high++;                  blk_high++;
Line 273  ffs_fsync(v)
Line 273  ffs_fsync(v)
          * First, flush all pages in range.           * First, flush all pages in range.
          */           */
   
         if (vp->v_type == VREG) {          mutex_enter(&vp->v_interlock);
                 simple_lock(&vp->v_interlock);          error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),
                 error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),              round_page(ap->a_offhi), PGO_CLEANIT |
                     round_page(ap->a_offhi), PGO_CLEANIT|PGO_SYNCIO);              ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0));
                 if (error) {          if (error) {
                         return error;                  goto out;
                 }  
         }          }
   
         /*          /*
          * Then, flush indirect blocks.           * Then, flush indirect blocks.
          */           */
   
         s = splbio();          if (blk_high >= NDADDR) {
         if (!(ap->a_flags & FSYNC_DATAONLY) && blk_high >= NDADDR) {  
                 error = ufs_getlbns(vp, blk_high, ia, &num);                  error = ufs_getlbns(vp, blk_high, ia, &num);
                 if (error) {                  if (error)
                         splx(s);                          goto out;
                         return error;  
                 }                  mutex_enter(&bqueue_lock);
                 for (i = 0; i < num; i++) {                  for (i = 0; i < num; i++) {
                         bp = incore(vp, ia[i].in_lbn);                          if ((bp = incore(vp, ia[i].in_lbn)) == NULL)
                         if (bp != NULL && !(bp->b_flags & B_BUSY) &&                                  continue;
                             (bp->b_flags & B_DELWRI)) {                          mutex_enter(&bp->b_interlock);
                                 bp->b_flags |= B_BUSY | B_VFLUSH;                          if ((bp->b_flags & (B_BUSY | B_DELWRI)) != B_DELWRI) {
                                 splx(s);                                  mutex_exit(&bp->b_interlock);
                                 bawrite(bp);                                  continue;
                                 s = splbio();  
                         }                          }
                           bp->b_flags |= B_BUSY | B_VFLUSH;
                           mutex_exit(&bp->b_interlock);
                           mutex_exit(&bqueue_lock);
                           bawrite(bp);
                           mutex_enter(&bqueue_lock);
                 }                  }
                   mutex_exit(&bqueue_lock);
         }          }
   
         if (ap->a_flags & FSYNC_WAIT) {          if (ap->a_flags & FSYNC_WAIT) {
                 simple_lock(&global_v_numoutput_slock);                  mutex_enter(&vp->v_interlock);
                 while (vp->v_numoutput > 0) {                  while (vp->v_numoutput > 0)
                         vp->v_flag |= VBWAIT;                          cv_wait(&vp->v_cv, &vp->v_interlock);
                         ltsleep(&vp->v_numoutput, PRIBIO + 1, "fsync_range", 0,                  mutex_exit(&vp->v_interlock);
                                 &global_v_numoutput_slock);  
                 }  
                 simple_unlock(&global_v_numoutput_slock);  
         }          }
         splx(s);  
   
         return (VOP_UPDATE(vp, NULL, NULL,          error = ffs_update(vp, NULL, NULL,
             (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0));              ((ap->a_flags & (FSYNC_WAIT | FSYNC_DATAONLY)) == FSYNC_WAIT)
               ? UPDATE_WAIT : 0);
   
           if (error == 0 && ap->a_flags & FSYNC_CACHE) {
                   int l = 0;
                   VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &l, FWRITE,
                           ap->a_l->l_cred, ap->a_l);
           }
   
   out:
           fstrans_done(vp->v_mount);
           return error;
 }  }
   
 /*  /*
Line 325  ffs_fsync(v)
Line 335  ffs_fsync(v)
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
 ffs_full_fsync(v)  ffs_full_fsync(void *v)
         void *v;  
 {  {
         struct vop_fsync_args /* {          struct vop_fsync_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 int a_flags;                  int a_flags;
                 off_t a_offlo;                  off_t a_offlo;
                 off_t a_offhi;                  off_t a_offhi;
Line 338  ffs_full_fsync(v)
Line 347  ffs_full_fsync(v)
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         struct buf *bp, *nbp;          struct buf *bp, *nbp;
         int s, error, passes, skipmeta, inodedeps_only, waitfor;          int error, passes, skipmeta, inodedeps_only, waitfor;
   
         if (vp->v_type == VBLK &&          if (vp->v_type == VBLK &&
             vp->v_specmountpoint != NULL &&              vp->v_specmountpoint != NULL &&
             (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))              (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
                 softdep_fsync_mountdev(vp);                  softdep_fsync_mountdev(vp);
   
           mutex_enter(&vp->v_interlock);
   
         inodedeps_only = DOINGSOFTDEP(vp) && (ap->a_flags & FSYNC_RECLAIM)          inodedeps_only = DOINGSOFTDEP(vp) && (ap->a_flags & FSYNC_RECLAIM)
             && vp->v_uobj.uo_npages == 0 && LIST_EMPTY(&vp->v_dirtyblkhd);              && UVM_OBJ_IS_CLEAN(&vp->v_uobj) && LIST_EMPTY(&vp->v_dirtyblkhd);
   
         /*          /*
          * Flush all dirty data associated with a vnode.           * Flush all dirty data associated with a vnode.
          */           */
   
         if (vp->v_type == VREG) {          if (vp->v_type == VREG || vp->v_type == VBLK) {
                 simple_lock(&vp->v_interlock);  
                 error = VOP_PUTPAGES(vp, 0, 0, PGO_ALLPAGES | PGO_CLEANIT |                  error = VOP_PUTPAGES(vp, 0, 0, PGO_ALLPAGES | PGO_CLEANIT |
                     ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0));                      ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0) |
                       (fstrans_getstate(vp->v_mount) == FSTRANS_SUSPENDING ?
                           PGO_FREE : 0));
                 if (error) {                  if (error) {
                         return error;                          return error;
                 }                  }
                   mutex_enter(&vp->v_interlock);
         }          }
   
         passes = NIADDR + 1;          passes = NIADDR + 1;
         skipmeta = 0;          skipmeta = 0;
         if (ap->a_flags & (FSYNC_DATAONLY|FSYNC_WAIT))          if (ap->a_flags & FSYNC_WAIT)
                 skipmeta = 1;                  skipmeta = 1;
         s = splbio();  
   
 loop:  loop:
         LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs)          LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
                   mutex_enter(&bp->b_interlock);
                 bp->b_flags &= ~B_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);
                 if (bp->b_flags & (B_BUSY | B_SCANNED))                  mutex_enter(&bp->b_interlock);
                   if (bp->b_flags & (B_BUSY | B_SCANNED)) {
                           mutex_exit(&bp->b_interlock);
                         continue;                          continue;
                   }
                 if ((bp->b_flags & B_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_flags |= B_BUSY | B_VFLUSH | B_SCANNED;                  bp->b_flags |= B_BUSY | B_VFLUSH | B_SCANNED;
                 splx(s);                  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 || !(ap->a_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);
                 s = splbio();                  mutex_enter(&vp->v_interlock);
                 /*                  /*
                  * Since we may have slept during the I/O, we need                   * Since we may have slept during the I/O, we need
                  * to start from a known point.                   * to start from a known point.
                  */                   */
                 nbp = LIST_FIRST(&vp->v_dirtyblkhd);                  nbp = LIST_FIRST(&vp->v_dirtyblkhd);
         }          }
         if (skipmeta && !(ap->a_flags & FSYNC_DATAONLY)) {          if (skipmeta) {
                 skipmeta = 0;                  skipmeta = 0;
                 goto loop;                  goto loop;
         }          }
         if (ap->a_flags & FSYNC_WAIT) {          if (ap->a_flags & FSYNC_WAIT) {
                 simple_lock(&global_v_numoutput_slock);  
                 while (vp->v_numoutput) {                  while (vp->v_numoutput) {
                         vp->v_flag |= VBWAIT;                          cv_wait(&vp->v_cv, &vp->v_interlock);
                         (void) ltsleep(&vp->v_numoutput, PRIBIO + 1,  
                             "ffsfsync", 0, &global_v_numoutput_slock);  
                 }                  }
                 simple_unlock(&global_v_numoutput_slock);                  mutex_exit(&vp->v_interlock);
                 splx(s);  
   
                 if (ap->a_flags & FSYNC_DATAONLY)  
                         return (0);  
   
                 /*                  /*
                  * 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(ap)) != 0)
                         return (error);                          return (error);
   
                 s = splbio();  
                 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {                  if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
                         /*                          /*
                         * Block devices associated with filesystems may                          * Block devices associated with filesystems may
Line 439  loop:
Line 452  loop:
                                 vprint("ffs_fsync: dirty", vp);                                  vprint("ffs_fsync: dirty", vp);
 #endif  #endif
                 }                  }
         }          } else
         splx(s);                  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 = (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0;
         return (VOP_UPDATE(vp, NULL, NULL, waitfor));          error = ffs_update(vp, NULL, NULL, waitfor);
   
           if (error == 0 && ap->a_flags & FSYNC_CACHE) {
                   int i = 0;
                   VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &i, FWRITE,
                           ap->a_l->l_cred, ap->a_l);
           }
   
           return error;
 }  }
   
 /*  /*
  * Reclaim an inode so that it can be used for other purposes.   * Reclaim an inode so that it can be used for other purposes.
  */   */
 int  int
 ffs_reclaim(v)  ffs_reclaim(void *v)
         void *v;  
 {  {
         struct vop_reclaim_args /* {          struct vop_reclaim_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 462  ffs_reclaim(v)
Line 482  ffs_reclaim(v)
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         struct inode *ip = VTOI(vp);          struct inode *ip = VTOI(vp);
           struct mount *mp = vp->v_mount;
         struct ufsmount *ump = ip->i_ump;          struct ufsmount *ump = ip->i_ump;
           void *data;
         int error;          int error;
   
         if ((error = ufs_reclaim(vp, ap->a_l)) != 0)          fstrans_start(mp, FSTRANS_LAZY);
           if ((error = ufs_reclaim(vp, ap->a_l)) != 0) {
                   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_put(&ffs_dinode1_pool, ip->i_din.ffs1_din);
Line 474  ffs_reclaim(v)
Line 499  ffs_reclaim(v)
                         pool_put(&ffs_dinode2_pool, ip->i_din.ffs2_din);                          pool_put(&ffs_dinode2_pool, ip->i_din.ffs2_din);
         }          }
         /*          /*
            * To interlock with ffs_sync().
            */
           genfs_node_destroy(vp);
           mutex_enter(&vp->v_interlock);
           data = vp->v_data;
           vp->v_data = NULL;
           mutex_exit(&vp->v_interlock);
   
           /*
          * 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, vp->v_data);          pool_put(&ffs_inode_pool, data);
         vp->v_data = NULL;          fstrans_done(mp);
         return (0);          return (0);
 }  }
   
   #if 0
 int  int
 ffs_getpages(void *v)  ffs_getpages(void *v)
 {  {
Line 510  ffs_getpages(void *v)
Line 545  ffs_getpages(void *v)
              blkoff(fs, *ap->a_count << PAGE_SHIFT) != 0) &&               blkoff(fs, *ap->a_count << PAGE_SHIFT) != 0) &&
             DOINGSOFTDEP(ap->a_vp)) {              DOINGSOFTDEP(ap->a_vp)) {
                 if ((ap->a_flags & PGO_LOCKED) == 0) {                  if ((ap->a_flags & PGO_LOCKED) == 0) {
                         simple_unlock(&vp->v_interlock);                          mutex_exit(&vp->v_interlock);
                 }                  }
                 return EINVAL;                  return EINVAL;
         }          }
         return genfs_getpages(v);          return genfs_getpages(v);
 }  }
   #endif
   
   /*
    * Return the last logical file offset that should be written for this file
    * if we're doing a write that ends at "size".
    */
   
   void
   ffs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)
   {
           struct inode *ip = VTOI(vp);
           struct fs *fs = ip->i_fs;
           daddr_t olbn, nlbn;
   
           olbn = lblkno(fs, ip->i_size);
           nlbn = lblkno(fs, size);
           if (nlbn < NDADDR && olbn <= nlbn) {
                   *eobp = fragroundup(fs, size);
           } else {
                   *eobp = blkroundup(fs, size);
           }
   }
   
 int  int
 ffs_putpages(void *v)  ffs_openextattr(void *v)
 {  {
         struct vop_putpages_args /* {          struct vop_openextattr_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 voff_t a_offlo;                  kauth_cred_t a_cred;
                 voff_t a_offhi;                  struct proc *a_p;
                 int a_flags;          } */ *ap = v;
           struct inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
           /* Not supported for UFS1 file systems. */
           if (fs->fs_magic == FS_UFS1_MAGIC)
                   return (EOPNOTSUPP);
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }
   
   int
   ffs_closeextattr(void *v)
   {
           struct vop_closeextattr_args /* {
                   struct vnode *a_vp;
                   int a_commit;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
           } */ *ap = v;
           struct inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
           /* Not supported for UFS1 file systems. */
           if (fs->fs_magic == FS_UFS1_MAGIC)
                   return (EOPNOTSUPP);
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }
   
   int
   ffs_getextattr(void *v)
   {
           struct vop_getextattr_args /* {
                   struct vnode *a_vp;
                   int a_attrnamespace;
                   const char *a_name;
                   struct uio *a_uio;
                   size_t *a_size;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         struct uvm_object *uobj = &vp->v_uobj;  
         struct inode *ip = VTOI(vp);          struct inode *ip = VTOI(vp);
         struct fs *fs = ip->i_fs;          struct fs *fs = ip->i_fs;
         struct vm_page *pg;  
         off_t off;  
   
         if (!DOINGSOFTDEP(vp) || (ap->a_flags & PGO_CLEANIT) == 0) {          if (fs->fs_magic == FS_UFS1_MAGIC) {
                 return genfs_putpages(v);  #ifdef UFS_EXTATTR
                   int error;
   
                   fstrans_start(vp->v_mount, FSTRANS_SHARED);
                   error = ufs_getextattr(ap);
                   fstrans_done(vp->v_mount);
                   return error;
   #else
                   return (EOPNOTSUPP);
   #endif
         }          }
   
         /*          /* XXX Not implemented for UFS2 file systems. */
          * for softdep files, force the pages in a block to be written together.          return (EOPNOTSUPP);
          * if we're the pagedaemon and we would have to wait for other pages,  }
          * just fail the request.  the pagedaemon will pick a different page.  
          */  
   
         ap->a_offlo &= ~fs->fs_qbmask;  
         ap->a_offhi = blkroundup(fs, ap->a_offhi);  
         if (curproc == uvm.pagedaemon_proc) {  
                 for (off = ap->a_offlo; off < ap->a_offhi; off += PAGE_SIZE) {  
                         pg = uvm_pagelookup(uobj, off);  
   
                         /*  int
                          * we only have missing pages here because the  ffs_setextattr(void *v)
                          * calculation of offhi above doesn't account for  {
                          * fragments.  so once we see one missing page,          struct vop_setextattr_args /* {
                          * the rest should be missing as well, but we'll                  struct vnode *a_vp;
                          * check for the rest just to be paranoid.                  int a_attrnamespace;
                          */                  const char *a_name;
                   struct uio *a_uio;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
           struct inode *ip = VTOI(vp);
           struct fs *fs = ip->i_fs;
   
                         if (pg == NULL) {          if (fs->fs_magic == FS_UFS1_MAGIC) {
                                 continue;  #ifdef UFS_EXTATTR
                         }                  int error;
                         if (pg->flags & PG_BUSY) {  
                                 simple_unlock(&uobj->vmobjlock);                  fstrans_start(vp->v_mount, FSTRANS_SHARED);
                                 return EBUSY;                  error = ufs_setextattr(ap);
                         }                  fstrans_done(vp->v_mount);
                 }                  return error;
   #else
                   return (EOPNOTSUPP);
   #endif
         }          }
         return genfs_putpages(v);  
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
 }  }
   
 /*  int
  * Return the last logical file offset that should be written for this file  ffs_listextattr(void *v)
  * if we're doing a write that ends at "size".  {
  */          struct vop_listextattr_args /* {
                   struct vnode *a_vp;
                   int a_attrnamespace;
                   struct uio *a_uio;
                   size_t *a_size;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
           } */ *ap = v;
           struct inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
 void          /* Not supported for UFS1 file systems. */
 ffs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)          if (fs->fs_magic == FS_UFS1_MAGIC)
                   return (EOPNOTSUPP);
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }
   
   int
   ffs_deleteextattr(void *v)
 {  {
           struct vop_deleteextattr_args /* {
                   struct vnode *a_vp;
                   int a_attrnamespace;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
         struct inode *ip = VTOI(vp);          struct inode *ip = VTOI(vp);
         struct fs *fs = ip->i_fs;          struct fs *fs = ip->i_fs;
         daddr_t olbn, nlbn;  
   
         KASSERT(flags & (GOP_SIZE_READ | GOP_SIZE_WRITE));          if (fs->fs_magic == FS_UFS1_MAGIC) {
         KASSERT((flags & (GOP_SIZE_READ | GOP_SIZE_WRITE))  #ifdef UFS_EXTATTR
                 != (GOP_SIZE_READ | GOP_SIZE_WRITE));                  int error;
   
                   fstrans_start(vp->v_mount, FSTRANS_SHARED);
                   error = ufs_deleteextattr(ap);
                   fstrans_done(vp->v_mount);
                   return error;
   #else
                   return (EOPNOTSUPP);
   #endif
           }
   
         olbn = lblkno(fs, ip->i_size);          /* XXX Not implemented for UFS2 file systems. */
         nlbn = lblkno(fs, size);          return (EOPNOTSUPP);
         if (nlbn < NDADDR && olbn <= nlbn) {  }
                 *eobp = fragroundup(fs, size);  
         } else {  /*
                 *eobp = blkroundup(fs, size);   * Lock the node.
    */
   int
   ffs_lock(void *v)
   {
           struct vop_lock_args /* {
                   struct vnode *a_vp;
                   int a_flags;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
           struct mount *mp = vp->v_mount;
   
           /*
            * Fake lock during file system suspension.
            */
           if ((vp->v_type == VREG || vp->v_type == VDIR) &&
               fstrans_is_owner(mp) &&
               fstrans_getstate(mp) == FSTRANS_SUSPENDING) {
                   if ((ap->a_flags & LK_INTERLOCK) != 0)
                           mutex_exit(&vp->v_interlock);
                   return 0;
         }          }
           return (lockmgr(vp->v_vnlock, ap->a_flags, &vp->v_interlock));
   }
   
   /*
    * Unlock the node.
    */
   int
   ffs_unlock(void *v)
   {
           struct vop_unlock_args /* {
                   struct vnode *a_vp;
                   int a_flags;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
           struct mount *mp = vp->v_mount;
   
           /*
            * Fake unlock during file system suspension.
            */
           if ((vp->v_type == VREG || vp->v_type == VDIR) &&
               fstrans_is_owner(mp) &&
               fstrans_getstate(mp) == FSTRANS_SUSPENDING) {
                   if ((ap->a_flags & LK_INTERLOCK) != 0)
                           mutex_exit(&vp->v_interlock);
                   return 0;
           }
           return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE,
               &vp->v_interlock));
   }
   
   /*
    * Return whether or not the node is locked.
    */
   int
   ffs_islocked(void *v)
   {
           struct vop_islocked_args /* {
                   struct vnode *a_vp;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
   
           return (lockstatus(vp->v_vnlock));
 }  }
Legend:
Removed from v.1.59.2.1  
changed lines
  Added in v.1.86.4.9
CVSweb <webmaster@jp.NetBSD.org>