Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...

[firefly-linux-kernel-4.4.55.git] / fs / nfs / inode.c

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index af6e806044d7cee5d8047a56de6693388fc8d34f..eda8879171c47e3225ee6891a77aac70e1531af2 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -38,7 +38,6 @@
 #include <linux/slab.h>
 #include <linux/compat.h>
 #include <linux/freezer.h>
-#include <linux/crc32.h>
 
 #include <asm/uaccess.h>
 
@@ -52,6 +51,8 @@
 #include "nfs.h"
 #include "netns.h"
 
+#include "nfstrace.h"
+
 #define NFSDBG_FACILITY                NFSDBG_VFS
 
 #define NFS_64_BIT_INODE_NUMBERS_ENABLED       1
@@ -463,7 +464,6 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
                unlock_new_inode(inode);
        } else
                nfs_refresh_inode(inode, fattr);
-               nfs_setsecurity(inode, fattr, label);
        dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
                inode->i_sb->s_id,
                (long long)NFS_FILEID(inode),
@@ -504,6 +504,8 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
        if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
                return 0;
 
+       trace_nfs_setattr_enter(inode);
+
        /* Write all dirty data */
        if (S_ISREG(inode->i_mode)) {
                nfs_inode_dio_wait(inode);
@@ -523,6 +525,7 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
                error = nfs_refresh_inode(inode, fattr);
        nfs_free_fattr(fattr);
 out:
+       trace_nfs_setattr_exit(inode, error);
        return error;
 }
 EXPORT_SYMBOL_GPL(nfs_setattr);
@@ -538,7 +541,6 @@ EXPORT_SYMBOL_GPL(nfs_setattr);
  */
 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
 {
-       loff_t oldsize;
        int err;
 
        err = inode_newsize_ok(inode, offset);
@@ -546,11 +548,10 @@ static int nfs_vmtruncate(struct inode * inode, loff_t offset)
                goto out;
 
        spin_lock(&inode->i_lock);
-       oldsize = inode->i_size;
        i_size_write(inode, offset);
        spin_unlock(&inode->i_lock);
 
-       truncate_pagecache(inode, oldsize, offset);
+       truncate_pagecache(inode, offset);
 out:
        return err;
 }
@@ -592,6 +593,7 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
        int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
        int err;
 
+       trace_nfs_getattr_enter(inode);
        /* Flush out writes to the server in order to update c/mtime.  */
        if (S_ISREG(inode->i_mode)) {
                nfs_inode_dio_wait(inode);
@@ -622,6 +624,7 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
                stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
        }
 out:
+       trace_nfs_getattr_exit(inode, err);
        return err;
 }
 EXPORT_SYMBOL_GPL(nfs_getattr);
@@ -876,6 +879,8 @@ __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
        dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
                inode->i_sb->s_id, (long long)NFS_FILEID(inode));
 
+       trace_nfs_revalidate_inode_enter(inode);
+
        if (is_bad_inode(inode))
                goto out;
        if (NFS_STALE(inode))
@@ -926,6 +931,7 @@ err_out:
        nfs4_label_free(label);
 out:
        nfs_free_fattr(fattr);
+       trace_nfs_revalidate_inode_exit(inode, status);
        return status;
 }
 
@@ -963,9 +969,15 @@ EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
-       
+       int ret;
+
        if (mapping->nrpages != 0) {
-               int ret = invalidate_inode_pages2(mapping);
+               if (S_ISREG(inode->i_mode)) {
+                       ret = nfs_sync_mapping(mapping);
+                       if (ret < 0)
+                               return ret;
+               }
+               ret = invalidate_inode_pages2(mapping);
                if (ret < 0)
                        return ret;
        }
@@ -976,6 +988,7 @@ static int nfs_invalidate_mapping(struct inode *inode, struct address_space *map
        spin_unlock(&inode->i_lock);
        nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
        nfs_fscache_wait_on_invalidate(inode);
+
        dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
                        inode->i_sb->s_id, (long long)NFS_FILEID(inode));
        return 0;
@@ -1009,8 +1022,12 @@ int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
                if (ret < 0)
                        goto out;
        }
-       if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
+       if (nfsi->cache_validity & NFS_INO_INVALID_DATA) {
+               trace_nfs_invalidate_mapping_enter(inode);
                ret = nfs_invalidate_mapping(inode, mapping);
+               trace_nfs_invalidate_mapping_exit(inode, ret);
+       }
+
 out:
        return ret;
 }
@@ -1190,7 +1207,7 @@ u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
 {
        /* wireshark uses 32-bit AUTODIN crc and does a bitwise
         * not on the result */
-       return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
+       return nfs_fhandle_hash(fh);
 }
 
 /*
@@ -1269,9 +1286,17 @@ static int nfs_inode_attrs_need_update(const struct inode *inode, const struct n
 
 static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
 {
+       int ret;
+
+       trace_nfs_refresh_inode_enter(inode);
+
        if (nfs_inode_attrs_need_update(inode, fattr))
-               return nfs_update_inode(inode, fattr);
-       return nfs_check_inode_attributes(inode, fattr);
+               ret = nfs_update_inode(inode, fattr);
+       else
+               ret = nfs_check_inode_attributes(inode, fattr);
+
+       trace_nfs_refresh_inode_exit(inode, ret);
+       return ret;
 }
 
 /**