11 files changed, 33 insertions, 79 deletions

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 28ccca98839b..22a40bd0cce2 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -304,13 +304,13 @@ xfs_map_blocks(
         xfs_iomap_t             *mapp,
         int                     flags)
 {
-        bhv_vnode_t             *vp = vn_from_inode(inode);
+        xfs_inode_t             *ip = XFS_I(inode);
         int                     error, nmaps = 1;
 
-        error = xfs_bmap(xfs_vtoi(vp), offset, count,
+        error = xfs_bmap(ip, offset, count,
                                 flags, mapp, &nmaps);
         if (!error && (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)))
-                VMODIFY(vp);
+                xfs_iflags_set(ip, XFS_IMODIFIED);
         return -error;
 }
 
@@ -1246,10 +1246,7 @@ xfs_vm_writepages(
         struct address_space    *mapping,
         struct writeback_control *wbc)
 {
-        struct bhv_vnode        *vp = vn_from_inode(mapping->host);
-
-        if (VN_TRUNC(vp))
-                VUNTRUNCATE(vp);
+        xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
         return generic_writepages(mapping, wbc);
 }
 
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 1d72dbb1a73d..123659e74b53 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -193,13 +193,11 @@ xfs_file_fsync(
         struct dentry   *dentry,
         int             datasync)
 {
-        bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
         int             flags = FSYNC_WAIT;
 
         if (datasync)
                 flags |= FSYNC_DATA;
-        if (VN_TRUNC(vp))
-                VUNTRUNCATE(vp);
+        xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
         return -xfs_fsync(XFS_I(dentry->d_inode), flags,
                         (xfs_off_t)0, (xfs_off_t)-1);
 }
@@ -277,10 +275,9 @@ xfs_file_ioctl(
 {
         int             error;
         struct inode    *inode = filp->f_path.dentry->d_inode;
-        bhv_vnode_t     *vp = vn_from_inode(inode);
 
         error = xfs_ioctl(XFS_I(inode), filp, 0, cmd, (void __user *)p);
-        VMODIFY(vp);
+        xfs_iflags_set(XFS_I(inode), XFS_IMODIFIED);
 
         /* NOTE:  some of the ioctl's return positive #'s as a
          *        byte count indicating success, such as
@@ -299,10 +296,9 @@ xfs_file_ioctl_invis(
 {
         int             error;
         struct inode    *inode = filp->f_path.dentry->d_inode;
-        bhv_vnode_t     *vp = vn_from_inode(inode);
 
         error = xfs_ioctl(XFS_I(inode), filp, IO_INVIS, cmd, (void __user *)p);
-        VMODIFY(vp);
+        xfs_iflags_set(XFS_I(inode), XFS_IMODIFIED);
 
         /* NOTE:  some of the ioctl's return positive #'s as a
          *        byte count indicating success, such as
diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index e2897912fec7..ac6d34cc355d 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -61,8 +61,7 @@ xfs_flushinval_pages(
         int             ret = 0;
 
         if (VN_CACHED(vp)) {
-                if (VN_TRUNC(vp))
-                        VUNTRUNCATE(vp);
+                xfs_iflags_clear(ip, XFS_ITRUNCATED);
                 ret = filemap_write_and_wait(inode->i_mapping);
                 if (!ret)
                         truncate_inode_pages(inode->i_mapping, first);
@@ -84,8 +83,7 @@ xfs_flush_pages(
         int             ret2;
 
         if (VN_DIRTY(vp)) {
-                if (VN_TRUNC(vp))
-                        VUNTRUNCATE(vp);
+                xfs_iflags_clear(ip, XFS_ITRUNCATED);
                 ret = filemap_fdatawrite(inode->i_mapping);
                 if (flags & XFS_B_ASYNC)
                         return ret;
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index 83f509960305..0046bdd5b7f1 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -371,7 +371,6 @@ xfs_compat_ioctl(
         unsigned long   arg)
 {
         struct inode    *inode = file->f_path.dentry->d_inode;
-        bhv_vnode_t     *vp = vn_from_inode(inode);
         int             error;
 
         switch (cmd) {
@@ -459,7 +458,7 @@ xfs_compat_ioctl(
         }
 
         error = xfs_ioctl(XFS_I(inode), file, mode, cmd, (void __user *)arg);
-        VMODIFY(vp);
+        xfs_iflags_set(XFS_I(inode), XFS_IMODIFIED);
 
         return error;
 }
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 4da034f4ae14..98d5a7e13bd5 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -221,7 +221,7 @@ xfs_init_security(
         error = xfs_attr_set(XFS_I(ip), name, value,
                         length, ATTR_SECURE);
         if (!error)
-                VMODIFY(vp);
+                xfs_iflags_set(XFS_I(ip), XFS_IMODIFIED);
 
         kfree(name);
         kfree(value);
@@ -327,7 +327,7 @@ xfs_vn_mknod(
                 if (!error) {
                         error = _ACL_INHERIT(vp, &vattr, default_acl);
                         if (!error)
-                                VMODIFY(vp);
+                                xfs_iflags_set(XFS_I(&vp->v_inode), XFS_IMODIFIED);
                         else
                                 xfs_cleanup_inode(dir, vp, dentry, mode);
                 }
@@ -409,7 +409,7 @@ xfs_vn_link(
         if (unlikely(error)) {
                 VN_RELE(vp);
         } else {
-                VMODIFY(vn_from_inode(dir));
+                xfs_iflags_set(XFS_I(dir), XFS_IMODIFIED);
                 xfs_validate_fields(ip, &vattr);
                 d_instantiate(dentry, ip);
         }
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 650c24ab27e2..47bca4e4696b 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -197,7 +197,7 @@ xfs_revalidate_inode(
                 inode->i_flags |= S_NOATIME;
         else
                 inode->i_flags &= ~S_NOATIME;
-        vp->v_flag &= ~VMODIFIED;
+        xfs_iflags_clear(ip, XFS_IMODIFIED);
 }
 
 void
@@ -441,13 +441,12 @@ xfs_fs_clear_inode(
         if (XFS_I(inode))
                 xfs_inactive(XFS_I(inode));
 
-        VN_LOCK(vp);
-        vp->v_flag &= ~VMODIFIED;
-        VN_UNLOCK(vp, 0);
 
-        if (XFS_I(inode))
+        if (XFS_I(inode)) {
+                xfs_iflags_clear(XFS_I(inode), XFS_IMODIFIED);
                 if (xfs_reclaim(XFS_I(inode)))
                         panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, vp);
+        }
 
         ASSERT(XFS_I(inode) == NULL);
 
diff --git a/fs/xfs/linux-2.6/xfs_vnode.c b/fs/xfs/linux-2.6/xfs_vnode.c
index 342c57879901..e6c559aee446 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.c
+++ b/fs/xfs/linux-2.6/xfs_vnode.c
@@ -84,9 +84,6 @@ vn_initialize(
         XFS_STATS_INC(vn_active);
         XFS_STATS_INC(vn_alloc);
 
-        vp->v_flag = VMODIFIED;
-        spinlock_init(&vp->v_lock, "v_lock");
-
         spin_lock(&vnumber_lock);
         if (!++vn_generation)   /* v_number shouldn't be zero */
                 vn_generation++;
@@ -157,7 +154,7 @@ __vn_revalidate(
         error = xfs_getattr(xfs_vtoi(vp), vattr, 0);
         if (likely(!error)) {
                 vn_revalidate_core(vp, vattr);
-                VUNMODIFY(vp);
+                xfs_iflags_clear(xfs_vtoi(vp), XFS_IMODIFIED);
         }
         return -error;
 }
@@ -182,10 +179,8 @@ vn_hold(
 
         XFS_STATS_INC(vn_hold);
 
-        VN_LOCK(vp);
         inode = igrab(vn_to_inode(vp));
         ASSERT(inode);
-        VN_UNLOCK(vp, 0);
 
         return vp;
 }
@@ -199,7 +194,7 @@ vn_hold(
 /*  2 */                (void *)(__psint_t) line,               \
 /*  3 */                (void *)(__psint_t)(vn_count(vp)),      \
 /*  4 */                (void *)(ra),                           \
-/*  5 */                (void *)(__psunsigned_t)(vp)->v_flag,   \
+/*  5 */                NULL,                                   \
 /*  6 */                (void *)(__psint_t)current_cpu(),       \
 /*  7 */                (void *)(__psint_t)current_pid(),       \
 /*  8 */                (void *)__return_address,               \
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 0f9ba6585c86..c8af208a73dc 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -27,20 +27,8 @@ struct attrlist_cursor_kern;
 typedef struct dentry   bhv_vname_t;
 typedef __u64           bhv_vnumber_t;
 
-typedef enum bhv_vflags {
-        VMODIFIED       = 0x08, /* XFS inode state possibly differs */
-                                /* to the Linux inode state. */
-        VTRUNCATED      = 0x40, /* truncated down so flush-on-close */
-} bhv_vflags_t;
-
-/*
- * MP locking protocols:
- *      v_flag,                                 VN_LOCK/VN_UNLOCK
- */
 typedef struct bhv_vnode {
-        bhv_vflags_t    v_flag;                 /* vnode flags (see above) */
         bhv_vnumber_t   v_number;               /* in-core vnode number */
-        spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
         atomic_t        v_iocount;              /* outstanding I/O count */
 #ifdef XFS_VNODE_TRACE
         struct ktrace   *v_trace;               /* trace header structure    */
@@ -255,35 +243,6 @@ static inline struct bhv_vnode *vn_grab(struct bhv_vnode *vp)
 #define VNAME_TO_VNODE(dentry)  (vn_from_inode((dentry)->d_inode))
 
 /*
- * Vnode spinlock manipulation.
- */
-#define VN_LOCK(vp)             mutex_spinlock(&(vp)->v_lock)
-#define VN_UNLOCK(vp, s)        mutex_spinunlock(&(vp)->v_lock, s)
-
-STATIC_INLINE void vn_flagset(struct bhv_vnode *vp, uint flag)
-{
-        spin_lock(&vp->v_lock);
-        vp->v_flag |= flag;
-        spin_unlock(&vp->v_lock);
-}
-
-STATIC_INLINE uint vn_flagclr(struct bhv_vnode *vp, uint flag)
-{
-        uint    cleared;
-
-        spin_lock(&vp->v_lock);
-        cleared = (vp->v_flag & flag);
-        vp->v_flag &= ~flag;
-        spin_unlock(&vp->v_lock);
-        return cleared;
-}
-
-#define VMODIFY(vp)     vn_flagset(vp, VMODIFIED)
-#define VUNMODIFY(vp)   vn_flagclr(vp, VMODIFIED)
-#define VTRUNCATE(vp)   vn_flagset(vp, VTRUNCATED)
-#define VUNTRUNCATE(vp) vn_flagclr(vp, VTRUNCATED)
-
-/*
  * Dealing with bad inodes
  */
 static inline void vn_mark_bad(struct bhv_vnode *vp)
@@ -322,7 +281,6 @@ static inline void vn_atime_to_time_t(bhv_vnode_t *vp, time_t *tt)
 #define VN_CACHED(vp)   (vn_to_inode(vp)->i_mapping->nrpages)
 #define VN_DIRTY(vp)    mapping_tagged(vn_to_inode(vp)->i_mapping, \
                                         PAGECACHE_TAG_DIRTY)
-#define VN_TRUNC(vp)    ((vp)->v_flag & VTRUNCATED)
 
 /*
  * Flags to vop_setattr/getattr.
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index 5806597b9ec4..ee13d6d708c8 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -336,6 +336,7 @@ finish_inode:
         ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) ==
                ((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0));
 
+        xfs_iflags_set(ip, XFS_IMODIFIED);
         *ipp = ip;
 
         /*
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 6f88ac3b10ae..79d724615c39 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -391,6 +391,9 @@ xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 #define XFS_IRECLAIMABLE 0x0020 /* inode can be reclaimed */
 #define XFS_INEW        0x0040
 #define XFS_IFILESTREAM 0x0080  /* inode is in a filestream directory */
+#define XFS_IMODIFIED   0x0100  /* XFS inode state possibly differs */
+                                /* to the Linux inode state. */
+#define XFS_ITRUNCATED  0x0200  /* truncated down so flush-on-close */
 
 /*
  * Flags for inode locking.
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 7ebbfa0c4f0f..f2c037a9564e 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -660,7 +660,7 @@ xfs_setattr(
                          * vnode and flush it when the file is closed, and
                          * do not wait the usual (long) time for writeout.
                          */
-                        VTRUNCATE(vp);
+                        xfs_iflags_set(ip, XFS_ITRUNCATED);
                 }
                 /*
                  * Have to do this even if the file's size doesn't change.
@@ -1519,6 +1519,8 @@ xfs_release(
                 return 0;
 
         if (!XFS_FORCED_SHUTDOWN(mp)) {
+                int truncated;
+
                 /*
                  * If we are using filestreams, and we have an unlinked
                  * file that we are processing the last close on, then nothing
@@ -1539,7 +1541,13 @@ xfs_release(
                  * significantly reducing the time window where we'd otherwise
                  * be exposed to that problem.
                  */
-                if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
+                spin_lock(&ip->i_flags_lock);
+                truncated = __xfs_iflags_test(ip, XFS_ITRUNCATED);
+                if (truncated)
+                        ip->i_flags &= ~XFS_ITRUNCATED;
+                spin_unlock(&ip->i_flags_lock);
+
+                if (truncated && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
                         xfs_flush_pages(ip, 0, -1, XFS_B_ASYNC, FI_NONE);
         }