[XFS] kill the v_flag member in struct bhv_vnode

All flags previously handled at the vnode level are not in the xfs_inode
where we already have a flags mechanisms and free bits for flags
previously in the vnode.

SGI-PV: 969608
SGI-Modid: xfs-linux-melb:xfs-kern:29495a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 28ccca98839bd65f2208f7e086265ef7946bf06c..22a40bd0cce29bc66e0370b38dbe658eefd56d1d 100644 (file)
--- 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 1d72dbb1a73d5e644d0a282a8bf272156c88fb77..123659e74b53aa11c9595f5c74811f733914d49a 100644 (file)
--- 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 e2897912fec71b341c8111bc31f267d01e3cb5e2..ac6d34cc355d16313c5785b745e63dd20a3753af 100644 (file)
--- 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 83f5099603050f2bfdd0228a578fb8c46339fab8..0046bdd5b7f11df4bf077e5144e306f01608e6ee 100644 (file)
--- 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 4da034f4ae142aab6769c4c119b069c50f69fd51..98d5a7e13bd5126feba8e3875a16621294135dd9 100644 (file)
--- 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 650c24ab27e246db74db7a1cd0723572e47fb325..47bca4e4696b311848f7b85e3062e750f43348e3 100644 (file)
--- 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 342c57879901e325187ad2b0e04fa391515c39b4..e6c559aee446724cf5e43ca121d74f289e751afe 100644 (file)
--- 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 0f9ba6585c86b04ef9009f7b9a065ba703ef0d05..c8af208a73dce5bf70de7b4ea45c8fbaac3006b9 100644 (file)
--- 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    */
@@ -254,35 +242,6 @@ static inline struct bhv_vnode *vn_grab(struct bhv_vnode *vp)
 #define VNAMELEN(dentry)       ((dentry)->d_name.len)
 #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
  */
@@ -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 5806597b9ec4f9c57488326454a3f2f257775d1a..ee13d6d708c8ddf283c8f6dccd2c0337fae44972 100644 (file)
--- 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 6f88ac3b10ae3e3f44faccc8943de04746f2b2e6..79d724615c3977fa9cafb92edc7d40c9f720a23a 100644 (file)
--- 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 7ebbfa0c4f0ffa02cac3640810eb588f3832e3ad..f2c037a9564efa8e072fa5baa80d1ec90e520ce5 100644 (file)
--- 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);
        }