iversion: Rename make inode_cmp_iversion{+raw} to inode_eq_iversion{+raw}

The function inode_cmp_iversion{+raw} is counter-intuitive, because it
returns true when the counters are different and false when these are equal.

Rename it to inode_eq_iversion{+raw}, which will returns true when
the counters are equal and false otherwise.

Signed-off-by: Goffredo Baroncelli <kreijack@inwind.it>
Signed-off-by: Jeff Layton <jlayton@redhat.com>

diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index d180b46453cf9ae2be22948a1036b8e36d4e994c..b2bf7016e1b34655e3431e6f4fc2036c7491f9a2 100644 (file)
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -81,7 +81,7 @@ affs_readdir(struct file *file, struct dir_context *ctx)
         * we can jump directly to where we left off.
         */
        ino = (u32)(long)file->private_data;
-       if (ino && inode_cmp_iversion(inode, file->f_version) == 0) {
+       if (ino && inode_eq_iversion(inode, file->f_version)) {
                pr_debug("readdir() left off=%d\n", ino);
                goto inside;
        }

diff --git a/fs/exofs/dir.c b/fs/exofs/dir.c
index c5a53fcc43ea9050b5beda288ce6ece2d51e036c..f0138674c1ed4e1c07bb8d86062bae9eb4480596 100644 (file)
--- a/fs/exofs/dir.c
+++ b/fs/exofs/dir.c
@@ -242,7 +242,7 @@ exofs_readdir(struct file *file, struct dir_context *ctx)
        unsigned long n = pos >> PAGE_SHIFT;
        unsigned long npages = dir_pages(inode);
        unsigned chunk_mask = ~(exofs_chunk_size(inode)-1);
-       bool need_revalidate = inode_cmp_iversion(inode, file->f_version);
+       bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
 
        if (pos > inode->i_size - EXOFS_DIR_REC_LEN(1))
                return 0;

diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 4111085a129f14ed91ac8762fe35a9cd23b51c5f..3b8114def69309aabfced283d49cd7d81546b8b7 100644 (file)
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -294,7 +294,7 @@ ext2_readdir(struct file *file, struct dir_context *ctx)
        unsigned long npages = dir_pages(inode);
        unsigned chunk_mask = ~(ext2_chunk_size(inode)-1);
        unsigned char *types = NULL;
-       bool need_revalidate = inode_cmp_iversion(inode, file->f_version);
+       bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
 
        if (pos > inode->i_size - EXT2_DIR_REC_LEN(1))
                return 0;

diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index afda0a0499cedfa609f43dceaa53668003141a79..da87cf757f7defc1050299f67257517c7b9e22a5 100644 (file)
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -209,7 +209,7 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx)
                 * readdir(2), then we might be pointing to an invalid
                 * dirent right now.  Scan from the start of the block
                 * to make sure. */
-               if (inode_cmp_iversion(inode, file->f_version)) {
+               if (!inode_eq_iversion(inode, file->f_version)) {
                        for (i = 0; i < sb->s_blocksize && i < offset; ) {
                                de = (struct ext4_dir_entry_2 *)
                                        (bh->b_data + i);
@@ -569,7 +569,7 @@ static int ext4_dx_readdir(struct file *file, struct dir_context *ctx)
                 * cached entries.
                 */
                if ((!info->curr_node) ||
-                   inode_cmp_iversion(inode, file->f_version)) {
+                   !inode_eq_iversion(inode, file->f_version)) {
                        info->curr_node = NULL;
                        free_rb_tree_fname(&info->root);
                        file->f_version = inode_query_iversion(inode);

diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index a8b987b7117356cfee659fe57b9b9379a4fc3751..adfc1f360dae605563cb8cf87a52fb32d9f9d2dc 100644 (file)
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -1495,7 +1495,7 @@ int ext4_read_inline_dir(struct file *file,
         * dirent right now.  Scan from the start of the inline
         * dir to make sure.
         */
-       if (inode_cmp_iversion(inode, file->f_version)) {
+       if (!inode_eq_iversion(inode, file->f_version)) {
                for (i = 0; i < extra_size && i < offset;) {
                        /*
                         * "." is with offset 0 and

diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index cefea792cde8e0624f7227d2251c1dad9a821474..2649759c478af4ec23c0378bd6de02ace44081d0 100644 (file)
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -46,7 +46,7 @@ static int vfat_revalidate_shortname(struct dentry *dentry)
 {
        int ret = 1;
        spin_lock(&dentry->d_lock);
-       if (inode_cmp_iversion(d_inode(dentry->d_parent), vfat_d_version(dentry)))
+       if (!inode_eq_iversion(d_inode(dentry->d_parent), vfat_d_version(dentry)))
                ret = 0;
        spin_unlock(&dentry->d_lock);
        return ret;

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index ceeaf0fb6657f38067b95d3f083c1ed4245ae6e1..7d893543cf3b37acdb7afe7ad423cecb63204697 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1314,7 +1314,7 @@ static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr
 
        if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
                        && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
-                       && !inode_cmp_iversion_raw(inode, fattr->pre_change_attr)) {
+                       && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
                inode_set_iversion_raw(inode, fattr->change_attr);
                if (S_ISDIR(inode->i_mode))
                        nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
@@ -1373,7 +1373,7 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat
 
        if (!nfs_file_has_buffered_writers(nfsi)) {
                /* Verify a few of the more important attributes */
-               if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && inode_cmp_iversion_raw(inode, fattr->change_attr))
+               if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
                        invalid |= NFS_INO_INVALID_ATTR | NFS_INO_REVAL_PAGECACHE;
 
                if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
@@ -1803,7 +1803,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 
        /* More cache consistency checks */
        if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
-               if (inode_cmp_iversion_raw(inode, fattr->change_attr)) {
+               if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
                        dprintk("NFS: change_attr change on server for file %s/%ld\n",
                                        inode->i_sb->s_id, inode->i_ino);
                        /* Could it be a race with writeback? */

diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index b7520e20a770edc16a47256e358f63c8719f4494..977763d4c27df57d3f1c94bd665e8bfd8f540e2c 100644 (file)
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -1776,7 +1776,7 @@ static int ocfs2_dir_foreach_blk_id(struct inode *inode,
                 * readdir(2), then we might be pointing to an invalid
                 * dirent right now.  Scan from the start of the block
                 * to make sure. */
-               if (inode_cmp_iversion(inode, *f_version)) {
+               if (!inode_eq_iversion(inode, *f_version)) {
                        for (i = 0; i < i_size_read(inode) && i < offset; ) {
                                de = (struct ocfs2_dir_entry *)
                                        (data->id_data + i);
@@ -1870,7 +1870,7 @@ static int ocfs2_dir_foreach_blk_el(struct inode *inode,
                 * readdir(2), then we might be pointing to an invalid
                 * dirent right now.  Scan from the start of the block
                 * to make sure. */
-               if (inode_cmp_iversion(inode, *f_version)) {
+               if (!inode_eq_iversion(inode, *f_version)) {
                        for (i = 0; i < sb->s_blocksize && i < offset; ) {
                                de = (struct ocfs2_dir_entry *) (bh->b_data + i);
                                /* It's too expensive to do a full

diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 50dfce0008646c0a0ad746294a1a465adfc85cd4..b721d0bda5e5d18f6d189c9ee035f9fdd28990ed 100644 (file)
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -429,7 +429,7 @@ ufs_readdir(struct file *file, struct dir_context *ctx)
        unsigned long n = pos >> PAGE_SHIFT;
        unsigned long npages = dir_pages(inode);
        unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
-       bool need_revalidate = inode_cmp_iversion(inode, file->f_version);
+       bool need_revalidate = !inode_eq_iversion(inode, file->f_version);
        unsigned flags = UFS_SB(sb)->s_flags;
 
        UFSD("BEGIN\n");

diff --git a/include/linux/iversion.h b/include/linux/iversion.h
index 3d2fd06495ecb26ba000db9aa081c1384ff583c2..be50ef7cedab21a23aa847a6f8fe91967416aa9e 100644 (file)
--- a/include/linux/iversion.h
+++ b/include/linux/iversion.h
@@ -45,7 +45,7 @@
  *
  * With this implementation, the value should always appear to observers to
  * increase over time if the file has changed. It's recommended to use
- * inode_cmp_iversion() helper to compare values.
+ * inode_eq_iversion() helper to compare values.
  *
  * Note that some filesystems (e.g. NFS and AFS) just use the field to store
  * a server-provided value (for the most part). For that reason, those
@@ -305,33 +305,33 @@ inode_query_iversion(struct inode *inode)
 }
 
 /**
- * inode_cmp_iversion_raw - check whether the raw i_version counter has changed
+ * inode_eq_iversion_raw - check whether the raw i_version counter has changed
  * @inode: inode to check
  * @old: old value to check against its i_version
  *
- * Compare the current raw i_version counter with a previous one. Returns false
- * if they are the same or true if they are different.
+ * Compare the current raw i_version counter with a previous one. Returns true
+ * if they are the same or false if they are different.
  */
 static inline bool
-inode_cmp_iversion_raw(const struct inode *inode, u64 old)
+inode_eq_iversion_raw(const struct inode *inode, u64 old)
 {
-       return inode_peek_iversion_raw(inode) != old;
+       return inode_peek_iversion_raw(inode) == old;
 }
 
 /**
- * inode_cmp_iversion - check whether the i_version counter has changed
+ * inode_eq_iversion - check whether the i_version counter has changed
  * @inode: inode to check
  * @old: old value to check against its i_version
  *
- * Compare an i_version counter with a previous one. Returns false if they are
- * the same, and true if they are different.
+ * Compare an i_version counter with a previous one. Returns true if they are
+ * the same, and false if they are different.
  *
  * Note that we don't need to set the QUERIED flag in this case, as the value
  * in the inode is not being recorded for later use.
  */
 static inline bool
-inode_cmp_iversion(const struct inode *inode, u64 old)
+inode_eq_iversion(const struct inode *inode, u64 old)
 {
-       return inode_peek_iversion(inode) != old;
+       return inode_peek_iversion(inode) == old;
 }
 #endif

diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index 061425dd64003a24204ff6f685e89d417cedc4d4..2cfb0c71496766b3b69f8700f0bf7f07789ca7c6 100644 (file)
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -135,7 +135,7 @@ static void ima_check_last_writer(struct integrity_iint_cache *iint,
                update = test_and_clear_bit(IMA_UPDATE_XATTR,
                                            &iint->atomic_flags);
                if (!IS_I_VERSION(inode) ||
-                   inode_cmp_iversion(inode, iint->version) ||
+                   !inode_eq_iversion(inode, iint->version) ||
                    (iint->flags & IMA_NEW_FILE)) {
                        iint->flags &= ~(IMA_DONE_MASK | IMA_NEW_FILE);
                        iint->measured_pcrs = 0;