[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.15 and 1.77.8.3

version 1.15, 1998/06/24 20:58:48 version 1.77.8.3, 2006/05/24 10:59: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 35 
Line 31 
  *      @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95   *      @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95
  */   */
   
 #if defined(_KERNEL) && !defined(_LKM)  #include <sys/cdefs.h>
 #include "opt_uvm.h"  __KERNEL_RCSID(0, "$NetBSD$");
 #endif  
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
Line 46 
Line 41 
 #include <sys/file.h>  #include <sys/file.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <sys/buf.h>  #include <sys/buf.h>
   #include <sys/event.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/conf.h>  
 #include <sys/mount.h>  #include <sys/mount.h>
 #include <sys/vnode.h>  #include <sys/vnode.h>
 #include <sys/malloc.h>  #include <sys/pool.h>
 #include <sys/signalvar.h>  #include <sys/signalvar.h>
   #include <sys/kauth.h>
 #include <vm/vm.h>  
   
 #if defined(UVM)  
 #include <uvm/uvm_extern.h>  
 #endif  
   
 #include <miscfs/fifofs/fifo.h>  #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>  #include <miscfs/genfs/genfs.h>
 #include <miscfs/specfs/specdev.h>  #include <miscfs/specfs/specdev.h>
   
 #include <ufs/ufs/quota.h>  
 #include <ufs/ufs/inode.h>  #include <ufs/ufs/inode.h>
 #include <ufs/ufs/dir.h>  #include <ufs/ufs/dir.h>
 #include <ufs/ufs/ufs_extern.h>  #include <ufs/ufs/ufs_extern.h>
Line 72 
Line 61 
 #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>
   
   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 *);
 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 */
         { &vop_create_desc, ufs_create },               /* create */          { &vop_create_desc, ufs_create },               /* create */
Line 89  struct vnodeopv_entry_desc ffs_vnodeop_e
Line 82  struct vnodeopv_entry_desc ffs_vnodeop_e
         { &vop_write_desc, ffs_write },                 /* write */          { &vop_write_desc, ffs_write },                 /* write */
         { &vop_lease_desc, ufs_lease_check },           /* lease */          { &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_poll_desc, ufs_poll },                   /* poll */          { &vop_poll_desc, ufs_poll },                   /* poll */
           { &vop_kqfilter_desc, genfs_kqfilter },         /* kqfilter */
         { &vop_revoke_desc, ufs_revoke },               /* revoke */          { &vop_revoke_desc, ufs_revoke },               /* revoke */
         { &vop_mmap_desc, ufs_mmap },                   /* mmap */          { &vop_mmap_desc, ufs_mmap },                   /* mmap */
         { &vop_fsync_desc, ffs_fsync },                 /* fsync */          { &vop_fsync_desc, ffs_fsync },                 /* fsync */
Line 113  struct vnodeopv_entry_desc ffs_vnodeop_e
Line 108  struct vnodeopv_entry_desc ffs_vnodeop_e
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ufs_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_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 */
         { (struct vnodeop_desc*)NULL, (int(*) __P((void*)))NULL }          { &vop_getpages_desc, ffs_getpages },           /* getpages */
           { &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 }
 };  };
 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 *);
 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 */
         { &vop_create_desc, spec_create },              /* create */          { &vop_create_desc, spec_create },              /* create */
Line 140  struct vnodeopv_entry_desc ffs_specop_en
Line 137  struct vnodeopv_entry_desc ffs_specop_en
         { &vop_write_desc, ufsspec_write },             /* write */          { &vop_write_desc, ufsspec_write },             /* write */
         { &vop_lease_desc, spec_lease_check },          /* lease */          { &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_poll_desc, spec_poll },                  /* poll */          { &vop_poll_desc, spec_poll },                  /* poll */
           { &vop_kqfilter_desc, spec_kqfilter },          /* kqfilter */
         { &vop_revoke_desc, spec_revoke },              /* revoke */          { &vop_revoke_desc, spec_revoke },              /* revoke */
         { &vop_mmap_desc, spec_mmap },                  /* mmap */          { &vop_mmap_desc, spec_mmap },                  /* mmap */
         { &vop_fsync_desc, ffs_fsync },                 /* fsync */          { &vop_fsync_desc, ffs_fsync },                 /* fsync */
Line 164  struct vnodeopv_entry_desc ffs_specop_en
Line 163  struct vnodeopv_entry_desc ffs_specop_en
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ufs_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 */
         { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }          { &vop_getpages_desc, spec_getpages },          /* getpages */
           { &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 }
 };  };
 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 *);
 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 */
         { &vop_create_desc, fifo_create },              /* create */          { &vop_create_desc, fifo_create },              /* create */
Line 191  struct vnodeopv_entry_desc ffs_fifoop_en
Line 192  struct vnodeopv_entry_desc ffs_fifoop_en
         { &vop_write_desc, ufsfifo_write },             /* write */          { &vop_write_desc, ufsfifo_write },             /* write */
         { &vop_lease_desc, fifo_lease_check },          /* lease */          { &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_poll_desc, fifo_poll },                  /* poll */          { &vop_poll_desc, fifo_poll },                  /* poll */
           { &vop_kqfilter_desc, fifo_kqfilter },          /* kqfilter */
         { &vop_revoke_desc, fifo_revoke },              /* revoke */          { &vop_revoke_desc, fifo_revoke },              /* revoke */
         { &vop_mmap_desc, fifo_mmap },                  /* mmap */          { &vop_mmap_desc, fifo_mmap },                  /* mmap */
         { &vop_fsync_desc, ffs_fsync },                 /* fsync */          { &vop_fsync_desc, ffs_fsync },                 /* fsync */
Line 215  struct vnodeopv_entry_desc ffs_fifoop_en
Line 218  struct vnodeopv_entry_desc ffs_fifoop_en
         { &vop_islocked_desc, ufs_islocked },           /* islocked */          { &vop_islocked_desc, ufs_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 */
         { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }          { &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 }
 };  };
 struct vnodeopv_desc ffs_fifoop_opv_desc =  const struct vnodeopv_desc ffs_fifoop_opv_desc =
         { &ffs_fifoop_p, ffs_fifoop_entries };          { &ffs_fifoop_p, ffs_fifoop_entries };
   
 int doclusterread = 1;  
 int doclusterwrite = 1;  
   
 #include <ufs/ufs/ufs_readwrite.c>  #include <ufs/ufs/ufs_readwrite.c>
   
   int
   ffs_fsync(void *v)
   {
           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 buf *bp;
           int s, num, error, i;
           struct indir ia[NIADDR + 1];
           int bsize;
           daddr_t blk_high;
           struct vnode *vp;
   
           /*
            * 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) ||
                           (ap->a_vp->v_type != VREG))
                   return ffs_full_fsync(v);
   
           vp = ap->a_vp;
   
           bsize = ap->a_vp->v_mount->mnt_stat.f_iosize;
           blk_high = ap->a_offhi / bsize;
           if (ap->a_offhi % bsize != 0)
                   blk_high++;
   
           /*
            * First, flush all pages in range.
            */
   
           simple_lock(&vp->v_interlock);
           error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),
               round_page(ap->a_offhi), PGO_CLEANIT |
               ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0));
           if (error) {
                   return error;
           }
   
           /*
            * Then, flush indirect blocks.
            */
   
           s = splbio();
           if (blk_high >= NDADDR) {
                   error = ufs_getlbns(vp, blk_high, ia, &num);
                   if (error) {
                           splx(s);
                           return error;
                   }
                   for (i = 0; i < num; i++) {
                           bp = incore(vp, ia[i].in_lbn);
                           if (bp != NULL) {
                                   simple_lock(&bp->b_interlock);
                                   if (!(bp->b_flags & B_BUSY) && (bp->b_flags & B_DELWRI)) {
                                           bp->b_flags |= B_BUSY | B_VFLUSH;
                                           simple_unlock(&bp->b_interlock);
                                           splx(s);
                                           bawrite(bp);
                                           s = splbio();
                                   } else {
                                           simple_unlock(&bp->b_interlock);
                                   }
                           }
                   }
           }
   
           if (ap->a_flags & FSYNC_WAIT) {
                   simple_lock(&global_v_numoutput_slock);
                   while (vp->v_numoutput > 0) {
                           vp->v_flag |= VBWAIT;
                           ltsleep(&vp->v_numoutput, PRIBIO + 1, "fsync_range", 0,
                                   &global_v_numoutput_slock);
                   }
                   simple_unlock(&global_v_numoutput_slock);
           }
           splx(s);
   
           error = ffs_update(vp, NULL, NULL,
               ((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_proc->p_cred, ap->a_l);
           }
   
           return error;
   }
   
   /*
    * Synch an open file.
    */
   /* ARGSUSED */
   static int
   ffs_full_fsync(void *v)
   {
           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;
           int s, error, passes, skipmeta, inodedeps_only, waitfor;
   
           if (vp->v_type == VBLK &&
               vp->v_specmountpoint != NULL &&
               (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
                   softdep_fsync_mountdev(vp);
   
           inodedeps_only = DOINGSOFTDEP(vp) && (ap->a_flags & FSYNC_RECLAIM)
               && vp->v_uobj.uo_npages == 0 && LIST_EMPTY(&vp->v_dirtyblkhd);
   
           /*
            * Flush all dirty data associated with a vnode.
            */
   
           if (vp->v_type == VREG || vp->v_type == VBLK) {
                   simple_lock(&vp->v_interlock);
                   error = VOP_PUTPAGES(vp, 0, 0, PGO_ALLPAGES | PGO_CLEANIT |
                       ((ap->a_flags & FSYNC_WAIT) ? PGO_SYNCIO : 0));
                   if (error) {
                           return error;
                   }
           }
   
           passes = NIADDR + 1;
           skipmeta = 0;
           if (ap->a_flags & FSYNC_WAIT)
                   skipmeta = 1;
           s = splbio();
   
   loop:
           LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs)
                   bp->b_flags &= ~B_SCANNED;
           for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
                   nbp = LIST_NEXT(bp, b_vnbufs);
                   simple_lock(&bp->b_interlock);
                   if (bp->b_flags & (B_BUSY | B_SCANNED)) {
                           simple_unlock(&bp->b_interlock);
                           continue;
                   }
                   if ((bp->b_flags & B_DELWRI) == 0)
                           panic("ffs_fsync: not dirty");
                   if (skipmeta && bp->b_lblkno < 0) {
                           simple_unlock(&bp->b_interlock);
                           continue;
                   }
                   simple_unlock(&bp->b_interlock);
                   bp->b_flags |= B_BUSY | B_VFLUSH | B_SCANNED;
                   splx(s);
                   /*
                    * On our final pass through, do all I/O synchronously
                    * so that we can find out if our flush is failing
                    * because of write errors.
                    */
                   if (passes > 0 || !(ap->a_flags & FSYNC_WAIT))
                           (void) bawrite(bp);
                   else if ((error = bwrite(bp)) != 0)
                           return (error);
                   s = splbio();
                   /*
                    * Since we may have slept during the I/O, we need
                    * to start from a known point.
                    */
                   nbp = LIST_FIRST(&vp->v_dirtyblkhd);
           }
           if (skipmeta) {
                   skipmeta = 0;
                   goto loop;
           }
           if (ap->a_flags & FSYNC_WAIT) {
                   simple_lock(&global_v_numoutput_slock);
                   while (vp->v_numoutput) {
                           vp->v_flag |= VBWAIT;
                           (void) ltsleep(&vp->v_numoutput, PRIBIO + 1,
                               "ffsfsync", 0, &global_v_numoutput_slock);
                   }
                   simple_unlock(&global_v_numoutput_slock);
                   splx(s);
   
                   /*
                    * Ensure that any filesystem metadata associated
                    * with the vnode has been written.
                    */
                   if ((error = softdep_sync_metadata(ap)) != 0)
                           return (error);
   
                   s = splbio();
                   if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
                           /*
                           * Block devices associated with filesystems may
                           * have new I/O requests posted for them even if
                           * the vnode is locked, so no amount of trying will
                           * get them clean. Thus we give block devices a
                           * good effort, then just give up. For all other file
                           * types, go around and try again until it is clean.
                           */
                           if (passes > 0) {
                                   passes--;
                                   goto loop;
                           }
   #ifdef DIAGNOSTIC
                           if (vp->v_type != VBLK)
                                   vprint("ffs_fsync: dirty", vp);
   #endif
                   }
           }
           splx(s);
   
           if (inodedeps_only)
                   waitfor = 0;
           else
                   waitfor = (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0;
           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_proc->p_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;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         register struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
           struct inode *ip = VTOI(vp);
           struct ufsmount *ump = ip->i_ump;
         int error;          int error;
   
         if ((error = ufs_reclaim(vp, ap->a_p)) != 0)          if ((error = ufs_reclaim(vp, ap->a_l)) != 0)
                 return (error);                  return (error);
         FREE(vp->v_data, VFSTOUFS(vp->v_mount)->um_devvp->v_tag == VT_MFS ?          if (ip->i_din.ffs1_din != NULL) {
             M_MFSNODE : M_FFSNODE);                  if (ump->um_fstype == UFS1)
                           pool_put(&ffs_dinode1_pool, ip->i_din.ffs1_din);
                   else
                           pool_put(&ffs_dinode2_pool, ip->i_din.ffs2_din);
           }
           /*
            * XXX MFS ends up here, too, to free an inode.  Should we create
            * XXX a separate pool for MFS inodes?
            */
           pool_put(&ffs_inode_pool, vp->v_data);
         vp->v_data = NULL;          vp->v_data = NULL;
         return (0);          return (0);
 }  }
   
   int
   ffs_getpages(void *v)
   {
           struct vop_getpages_args /* {
                   struct vnode *a_vp;
                   voff_t a_offset;
                   struct vm_page **a_m;
                   int *a_count;
                   int a_centeridx;
                   vm_prot_t a_access_type;
                   int a_advice;
                   int a_flags;
           } */ *ap = v;
           struct vnode *vp = ap->a_vp;
           struct inode *ip = VTOI(vp);
           struct fs *fs = ip->i_fs;
   
           /*
            * don't allow a softdep write to create pages for only part of a block.
            * the dependency tracking requires that all pages be in memory for
            * a block involved in a dependency.
            */
   
           if (ap->a_flags & PGO_OVERWRITE &&
               (blkoff(fs, ap->a_offset) != 0 ||
                blkoff(fs, *ap->a_count << PAGE_SHIFT) != 0) &&
               DOINGSOFTDEP(ap->a_vp)) {
                   if ((ap->a_flags & PGO_LOCKED) == 0) {
                           simple_unlock(&vp->v_interlock);
                   }
                   return EINVAL;
           }
           return genfs_getpages(v);
   }
   
   /*
    * 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
   ffs_openextattr(void *v)
   {
           struct vop_openextattr_args /* {
                   struct vnode *a_vp;
                   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_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;
           struct inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
           if (fs->fs_magic == FS_UFS1_MAGIC) {
   #ifdef UFS_EXTATTR
                   return (ufs_getextattr(ap));
   #else
                   return (EOPNOTSUPP);
   #endif
           }
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }
   
   int
   ffs_setextattr(void *v)
   {
           struct vop_setextattr_args /* {
                   struct vnode *a_vp;
                   int a_attrnamespace;
                   const char *a_name;
                   struct uio *a_uio;
                   kauth_cred_t a_cred;
                   struct proc *a_p;
           } */ *ap = v;
           struct inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
           if (fs->fs_magic == FS_UFS1_MAGIC) {
   #ifdef UFS_EXTATTR
                   return (ufs_setextattr(ap));
   #else
                   return (EOPNOTSUPP);
   #endif
           }
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }
   
   int
   ffs_listextattr(void *v)
   {
           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;
   
           /* 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_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 inode *ip = VTOI(ap->a_vp);
           struct fs *fs = ip->i_fs;
   
           if (fs->fs_magic == FS_UFS1_MAGIC) {
   #ifdef UFS_EXTATTR
                   return (ufs_deleteextattr(ap));
   #else
                   return (EOPNOTSUPP);
   #endif
           }
   
           /* XXX Not implemented for UFS2 file systems. */
           return (EOPNOTSUPP);
   }

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.77.8.3

CVSweb <webmaster@jp.NetBSD.org>