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

Pull final vfs updates from Al Viro:

 - The ->i_mutex wrappers (with small prereq in lustre)

 - a fix for too early freeing of symlink bodies on shmem (they need to
   be RCU-delayed) (-stable fodder)

 - followup to dedupe stuff merged this cycle

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  vfs: abort dedupe loop if fatal signals are pending
  make sure that freeing shmem fast symlinks is RCU-delayed
  wrappers for ->i_mutex access
  lustre: remove unused declaration

6 files changed, 32 insertions, 32 deletions

diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index c82a21228a34..9cce67043f92 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -940,7 +940,7 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
         dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n",
                         filp, offset, whence);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         switch (whence) {
                 case 1:
                         offset += filp->f_pos;
@@ -957,7 +957,7 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence)
                 dir_ctx->duped = 0;
         }
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return offset;
 }
 
@@ -972,9 +972,9 @@ static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
 
         dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return 0;
 }
 
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 7ab7ec9f4eed..7a0cfd3266e5 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -580,7 +580,7 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter,
         if (!count)
                 goto out;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         result = nfs_sync_mapping(mapping);
         if (result)
                 goto out_unlock;
@@ -608,7 +608,7 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter,
         NFS_I(inode)->read_io += count;
         result = nfs_direct_read_schedule_iovec(dreq, iter, pos);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (!result) {
                 result = nfs_direct_wait(dreq);
@@ -622,7 +622,7 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter,
 out_release:
         nfs_direct_req_release(dreq);
 out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out:
         return result;
 }
@@ -1005,7 +1005,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
         pos = iocb->ki_pos;
         end = (pos + iov_iter_count(iter) - 1) >> PAGE_CACHE_SHIFT;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         result = nfs_sync_mapping(mapping);
         if (result)
@@ -1045,7 +1045,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
                                               pos >> PAGE_CACHE_SHIFT, end);
         }
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (!result) {
                 result = nfs_direct_wait(dreq);
@@ -1066,7 +1066,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
 out_release:
         nfs_direct_req_release(dreq);
 out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return result;
 }
 
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 4ef8f5addcad..748bb813b8ec 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -278,9 +278,9 @@ nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
                 if (ret != 0)
                         break;
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 ret = nfs_file_fsync_commit(file, start, end, datasync);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 /*
                  * If nfs_file_fsync_commit detected a server reboot, then
                  * resend all dirty pages that might have been covered by
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 8e24d886d2c5..86faecf8f328 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -661,9 +661,9 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
         trace_nfs_getattr_enter(inode);
         /* Flush out writes to the server in order to update c/mtime.  */
         if (S_ISREG(inode->i_mode)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 err = nfs_sync_inode(inode);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 if (err)
                         goto out;
         }
@@ -1178,9 +1178,9 @@ static int __nfs_revalidate_mapping(struct inode *inode,
         spin_unlock(&inode->i_lock);
         trace_nfs_invalidate_mapping_enter(inode);
         if (may_lock) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 ret = nfs_invalidate_mapping(inode, mapping);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         } else
                 ret = nfs_invalidate_mapping(inode, mapping);
         trace_nfs_invalidate_mapping_exit(inode, ret);
diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c
index 6e8174930a48..bd25dc7077f7 100644
--- a/fs/nfs/nfs42proc.c
+++ b/fs/nfs/nfs42proc.c
@@ -101,13 +101,13 @@ int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
         if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
                 return -EOPNOTSUPP;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         err = nfs42_proc_fallocate(&msg, filep, offset, len);
         if (err == -EOPNOTSUPP)
                 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
@@ -123,7 +123,7 @@ int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
                 return -EOPNOTSUPP;
 
         nfs_wb_all(inode);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         err = nfs42_proc_fallocate(&msg, filep, offset, len);
         if (err == 0)
@@ -131,7 +131,7 @@ int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
         if (err == -EOPNOTSUPP)
                 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 26f9a23e2b25..57ca1c8039c1 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -141,11 +141,11 @@ nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
                 if (ret != 0)
                         break;
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 ret = nfs_file_fsync_commit(file, start, end, datasync);
                 if (!ret)
                         ret = pnfs_sync_inode(inode, !!datasync);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 /*
                  * If nfs_file_fsync_commit detected a server reboot, then
                  * resend all dirty pages that might have been covered by
@@ -219,13 +219,13 @@ static int nfs42_clone_file_range(struct file *src_file, loff_t src_off,
 
         /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
         if (same_inode) {
-                mutex_lock(&src_inode->i_mutex);
+                inode_lock(src_inode);
         } else if (dst_inode < src_inode) {
-                mutex_lock_nested(&dst_inode->i_mutex, I_MUTEX_PARENT);
-                mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(dst_inode, I_MUTEX_PARENT);
+                inode_lock_nested(src_inode, I_MUTEX_CHILD);
         } else {
-                mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_PARENT);
-                mutex_lock_nested(&dst_inode->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(src_inode, I_MUTEX_PARENT);
+                inode_lock_nested(dst_inode, I_MUTEX_CHILD);
         }
 
         /* flush all pending writes on both src and dst so that server
@@ -246,13 +246,13 @@ static int nfs42_clone_file_range(struct file *src_file, loff_t src_off,
 
 out_unlock:
         if (same_inode) {
-                mutex_unlock(&src_inode->i_mutex);
+                inode_unlock(src_inode);
         } else if (dst_inode < src_inode) {
-                mutex_unlock(&src_inode->i_mutex);
-                mutex_unlock(&dst_inode->i_mutex);
+                inode_unlock(src_inode);
+                inode_unlock(dst_inode);
         } else {
-                mutex_unlock(&dst_inode->i_mutex);
-                mutex_unlock(&src_inode->i_mutex);
+                inode_unlock(dst_inode);
+                inode_unlock(src_inode);
         }
 out:
         return ret;