[BACK]Return to ffs_vfsops.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_vfsops.c between version 1.257 and 1.257.2.8

version 1.257, 2010/02/05 20:03:36 version 1.257.2.8, 2010/08/17 06:48:10
Line 67  __KERNEL_RCSID(0, "$NetBSD$");
Line 67  __KERNEL_RCSID(0, "$NetBSD$");
 #include "opt_ffs.h"  #include "opt_ffs.h"
 #include "opt_quota.h"  #include "opt_quota.h"
 #include "opt_wapbl.h"  #include "opt_wapbl.h"
   #include "opt_xip.h"
 #endif  #endif
   
 #include <sys/param.h>  #include <sys/param.h>
Line 391  ffs_mount(struct mount *mp, const char *
Line 392  ffs_mount(struct mount *mp, const char *
                         accessmode |= VWRITE;                          accessmode |= VWRITE;
                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);                  vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
                 error = genfs_can_mount(devvp, accessmode, l->l_cred);                  error = genfs_can_mount(devvp, accessmode, l->l_cred);
                 VOP_UNLOCK(devvp, 0);                  VOP_UNLOCK(devvp);
         }          }
   
         if (error) {          if (error) {
Line 422  ffs_mount(struct mount *mp, const char *
Line 423  ffs_mount(struct mount *mp, const char *
                 if (error) {                  if (error) {
                         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);                          vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
                         (void)VOP_CLOSE(devvp, xflags, NOCRED);                          (void)VOP_CLOSE(devvp, xflags, NOCRED);
                         VOP_UNLOCK(devvp, 0);                          VOP_UNLOCK(devvp);
                         goto fail;                          goto fail;
                 }                  }
   
Line 599  ffs_reload(struct mount *mp, kauth_cred_
Line 600  ffs_reload(struct mount *mp, kauth_cred_
         devvp = ump->um_devvp;          devvp = ump->um_devvp;
         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);          vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
         error = vinvalbuf(devvp, 0, cred, l, 0, 0);          error = vinvalbuf(devvp, 0, cred, l, 0, 0);
         VOP_UNLOCK(devvp, 0);          VOP_UNLOCK(devvp);
         if (error)          if (error)
                 panic("ffs_reload: dirty1");                  panic("ffs_reload: dirty1");
         /*          /*
Line 774  ffs_reload(struct mount *mp, kauth_cred_
Line 775  ffs_reload(struct mount *mp, kauth_cred_
                  */                   */
                 mutex_enter(&vp->v_interlock);                  mutex_enter(&vp->v_interlock);
                 mutex_exit(&mntvnode_lock);                  mutex_exit(&mntvnode_lock);
                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK)) {                  if (vget(vp, LK_EXCLUSIVE)) {
                         (void)vunmark(mvp);                          (void)vunmark(mvp);
                         goto loop;                          goto loop;
                 }                  }
Line 822  ffs_mountfs(struct vnode *devvp, struct 
Line 823  ffs_mountfs(struct vnode *devvp, struct 
         daddr_t sblockloc, fsblockloc;          daddr_t sblockloc, fsblockloc;
         int blks, fstype;          int blks, fstype;
         int error, i, bsize, ronly, bset = 0;          int error, i, bsize, ronly, bset = 0;
         uint64_t numsecs;  
         unsigned secsize;  
 #ifdef FFS_EI  #ifdef FFS_EI
         int needswap = 0;               /* keep gcc happy */          int needswap = 0;               /* keep gcc happy */
 #endif  #endif
         int32_t *lp;          int32_t *lp;
         kauth_cred_t cred;          kauth_cred_t cred;
         u_int32_t sbsize = 8192;        /* keep gcc happy*/          u_int32_t sbsize = 8192;        /* keep gcc happy*/
           int32_t fsbsize;
   
         dev = devvp->v_rdev;          dev = devvp->v_rdev;
         cred = l ? l->l_cred : NOCRED;          cred = l ? l->l_cred : NOCRED;
Line 837  ffs_mountfs(struct vnode *devvp, struct 
Line 837  ffs_mountfs(struct vnode *devvp, struct 
         /* Flush out any old buffers remaining from a previous use. */          /* Flush out any old buffers remaining from a previous use. */
         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);          vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
         error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);          error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
         VOP_UNLOCK(devvp, 0);          VOP_UNLOCK(devvp);
         if (error)          if (error)
                 return (error);                  return (error);
   
         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;          ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
         error = getdisksize(devvp, &numsecs, &secsize);  
         if (error)  
                 return (error);  
   
         bp = NULL;          bp = NULL;
         ump = NULL;          ump = NULL;
Line 891  ffs_mountfs(struct vnode *devvp, struct 
Line 888  ffs_mountfs(struct vnode *devvp, struct 
                 if (fs->fs_magic == FS_UFS1_MAGIC) {                  if (fs->fs_magic == FS_UFS1_MAGIC) {
                         sbsize = fs->fs_sbsize;                          sbsize = fs->fs_sbsize;
                         fstype = UFS1;                          fstype = UFS1;
                           fsbsize = fs->fs_bsize;
 #ifdef FFS_EI  #ifdef FFS_EI
                         needswap = 0;                          needswap = 0;
                 } else if (fs->fs_magic == bswap32(FS_UFS1_MAGIC)) {                  } else if (fs->fs_magic == bswap32(FS_UFS1_MAGIC)) {
                         sbsize = bswap32(fs->fs_sbsize);                          sbsize = bswap32(fs->fs_sbsize);
                         fstype = UFS1;                          fstype = UFS1;
                           fsbsize = bswap32(fs->fs_bsize);
                         needswap = 1;                          needswap = 1;
 #endif  #endif
                 } else if (fs->fs_magic == FS_UFS2_MAGIC) {                  } else if (fs->fs_magic == FS_UFS2_MAGIC) {
                         sbsize = fs->fs_sbsize;                          sbsize = fs->fs_sbsize;
                         fstype = UFS2;                          fstype = UFS2;
                           fsbsize = fs->fs_bsize;
 #ifdef FFS_EI  #ifdef FFS_EI
                         needswap = 0;                          needswap = 0;
                 } else if (fs->fs_magic == bswap32(FS_UFS2_MAGIC)) {                  } else if (fs->fs_magic == bswap32(FS_UFS2_MAGIC)) {
                         sbsize = bswap32(fs->fs_sbsize);                          sbsize = bswap32(fs->fs_sbsize);
                         fstype = UFS2;                          fstype = UFS2;
                           fsbsize = bswap32(fs->fs_bsize);
                         needswap = 1;                          needswap = 1;
 #endif  #endif
                 } else                  } else
Line 938  ffs_mountfs(struct vnode *devvp, struct 
Line 939  ffs_mountfs(struct vnode *devvp, struct 
                 if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))                  if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))
                         continue;                          continue;
   
                   /* Check that we can handle the file system blocksize */
                   if (fsbsize > MAXBSIZE) {
                           printf("ffs_mountfs: block size (%d) > MAXBSIZE (%d)\n",
                               fsbsize, MAXBSIZE);
                           continue;
                   }
   
                 /* Ok seems to be a good superblock */                  /* Ok seems to be a good superblock */
                 break;                  break;
         }          }
Line 1173  ffs_mountfs(struct vnode *devvp, struct 
Line 1181  ffs_mountfs(struct vnode *devvp, struct 
         mp->mnt_dev_bshift = DEV_BSHIFT;        /* XXX */          mp->mnt_dev_bshift = DEV_BSHIFT;        /* XXX */
         mp->mnt_flag |= MNT_LOCAL;          mp->mnt_flag |= MNT_LOCAL;
         mp->mnt_iflag |= IMNT_MPSAFE;          mp->mnt_iflag |= IMNT_MPSAFE;
   #ifdef XIP
           if ((mp->mnt_flag & MNT_RDONLY) == 0)
                   printf("XIP needs read-only mount\n");
           else {
                   void *physseg = NULL;
   
                   if ((VOP_IOCTL(devvp, DIOCGPHYSSEG, &physseg, FREAD,
                       cred) == 0) &&
                       physseg != NULL) {
                           mp->mnt_iflag |= IMNT_XIP;
                           devvp->v_physseg = physseg;
                   } else
                           printf("device doesn't support DIOCGPHYSSEG\n");
           }
   #endif
 #ifdef FFS_EI  #ifdef FFS_EI
         if (needswap)          if (needswap)
                 ump->um_flags |= UFS_NEEDSWAP;                  ump->um_flags |= UFS_NEEDSWAP;
Line 1475  ffs_flushfiles(struct mount *mp, int fla
Line 1498  ffs_flushfiles(struct mount *mp, int fla
          */           */
         vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);          vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
         error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0);          error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0);
         VOP_UNLOCK(ump->um_devvp, 0);          VOP_UNLOCK(ump->um_devvp);
         if (flags & FORCECLOSE) /* XXXDBJ */          if (flags & FORCECLOSE) /* XXXDBJ */
                 error = 0;                  error = 0;
   
Line 1560  ffs_sync(struct mount *mp, int waitfor, 
Line 1583  ffs_sync(struct mount *mp, int waitfor, 
          * threads waiting on fstrans may have locked vnodes.           * threads waiting on fstrans may have locked vnodes.
          */           */
         if (is_suspending)          if (is_suspending)
                 lk_flags = LK_INTERLOCK;                  lk_flags = 0;
         else          else
                 lk_flags = LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK;                  lk_flags = LK_EXCLUSIVE | LK_NOWAIT;
         /*          /*
          * Write back each (modified) inode.           * Write back each (modified) inode.
          */           */
Line 1665  loop:
Line 1688  loop:
                     (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG,                      (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG,
                     0, 0)) != 0)                      0, 0)) != 0)
                         allerror = error;                          allerror = error;
                 VOP_UNLOCK(ump->um_devvp, 0);                  VOP_UNLOCK(ump->um_devvp);
                 if (allerror == 0 && waitfor == MNT_WAIT && !mp->mnt_wapbl) {                  if (allerror == 0 && waitfor == MNT_WAIT && !mp->mnt_wapbl) {
                         mutex_enter(&mntvnode_lock);                          mutex_enter(&mntvnode_lock);
                         goto loop;                          goto loop;
Line 1748  ffs_vget(struct mount *mp, ino_t ino, st
Line 1771  ffs_vget(struct mount *mp, ino_t ino, st
   
         vp->v_vflag |= VV_LOCKSWORK;          vp->v_vflag |= VV_LOCKSWORK;
   
   #ifdef XIP
           if ((vp->v_mount->mnt_iflag & IMNT_XIP) != 0) {
                   vp->v_vflag |= VV_XIP;
           }
   #endif
   
         /*          /*
          * XXX MFS ends up here, too, to allocate an inode.  Should we           * XXX MFS ends up here, too, to allocate an inode.  Should we
          * XXX create another pool for MFS inodes?           * XXX create another pool for MFS inodes?
Legend:
Removed from v.1.257  
changed lines
  Added in v.1.257.2.8
CVSweb <webmaster@jp.NetBSD.org>