177 files changed, 908 insertions, 883 deletions

diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 5038fd578e65..2936a0044c04 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -1799,9 +1799,9 @@ static int spufs_mfc_fsync(struct file *file, loff_t start, loff_t end, int data
         struct inode *inode = file_inode(file);
         int err = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (!err) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 err = spufs_mfc_flush(file, NULL);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         return err;
 }
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index ad4840f86be1..dfa863876778 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -163,7 +163,7 @@ static void spufs_prune_dir(struct dentry *dir)
 {
         struct dentry *dentry, *tmp;
 
-        mutex_lock(&d_inode(dir)->i_mutex);
+        inode_lock(d_inode(dir));
         list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
                 spin_lock(&dentry->d_lock);
                 if (simple_positive(dentry)) {
@@ -180,7 +180,7 @@ static void spufs_prune_dir(struct dentry *dir)
                 }
         }
         shrink_dcache_parent(dir);
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 }
 
 /* Caller must hold parent->i_mutex */
@@ -225,9 +225,9 @@ static int spufs_dir_close(struct inode *inode, struct file *file)
         parent = d_inode(dir->d_parent);
         ctx = SPUFS_I(d_inode(dir))->i_ctx;
 
-        mutex_lock_nested(&parent->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(parent, I_MUTEX_PARENT);
         ret = spufs_rmdir(parent, dir);
-        mutex_unlock(&parent->i_mutex);
+        inode_unlock(parent);
         WARN_ON(ret);
 
         return dcache_dir_close(inode, file);
@@ -270,7 +270,7 @@ spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
         inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         dget(dentry);
         inc_nlink(dir);
@@ -291,7 +291,7 @@ spufs_mkdir(struct inode *dir, struct dentry *dentry, unsigned int flags,
         if (ret)
                 spufs_rmdir(dir, dentry);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
index b2e5902bd8f4..0f3da2cb2bd6 100644
--- a/arch/s390/hypfs/inode.c
+++ b/arch/s390/hypfs/inode.c
@@ -67,7 +67,7 @@ static void hypfs_remove(struct dentry *dentry)
         struct dentry *parent;
 
         parent = dentry->d_parent;
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         if (simple_positive(dentry)) {
                 if (d_is_dir(dentry))
                         simple_rmdir(d_inode(parent), dentry);
@@ -76,7 +76,7 @@ static void hypfs_remove(struct dentry *dentry)
         }
         d_delete(dentry);
         dput(dentry);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 }
 
 static void hypfs_delete_tree(struct dentry *root)
@@ -331,7 +331,7 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         dentry = lookup_one_len(name, parent, strlen(name));
         if (IS_ERR(dentry)) {
                 dentry = ERR_PTR(-ENOMEM);
@@ -359,7 +359,7 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
         d_instantiate(dentry, inode);
         dget(dentry);
 fail:
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         return dentry;
 }
 
diff --git a/block/ioctl.c b/block/ioctl.c
index 2c84683aada5..77f5d17779d6 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -455,12 +455,12 @@ static int blkdev_daxset(struct block_device *bdev, unsigned long argp)
         if (arg && !blkdev_dax_capable(bdev))
                 return -ENOTTY;
 
-        mutex_lock(&bdev->bd_inode->i_mutex);
+        inode_lock(bdev->bd_inode);
         if (bdev->bd_map_count == 0)
                 inode_set_flags(bdev->bd_inode, arg, S_DAX);
         else
                 rc = -EBUSY;
-        mutex_unlock(&bdev->bd_inode->i_mutex);
+        inode_unlock(bdev->bd_inode);
         return rc;
 }
 #else
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 68f03141e432..44a74cf1372c 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -215,9 +215,9 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
                 newattrs.ia_uid = uid;
                 newattrs.ia_gid = gid;
                 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID;
-                mutex_lock(&d_inode(dentry)->i_mutex);
+                inode_lock(d_inode(dentry));
                 notify_change(dentry, &newattrs, NULL);
-                mutex_unlock(&d_inode(dentry)->i_mutex);
+                inode_unlock(d_inode(dentry));
 
                 /* mark as kernel-created inode */
                 d_inode(dentry)->i_private = &thread;
@@ -244,7 +244,7 @@ static int dev_rmdir(const char *name)
                 err = -ENOENT;
         }
         dput(dentry);
-        mutex_unlock(&d_inode(parent.dentry)->i_mutex);
+        inode_unlock(d_inode(parent.dentry));
         path_put(&parent);
         return err;
 }
@@ -321,9 +321,9 @@ static int handle_remove(const char *nodename, struct device *dev)
                         newattrs.ia_mode = stat.mode & ~0777;
                         newattrs.ia_valid =
                                 ATTR_UID|ATTR_GID|ATTR_MODE;
-                        mutex_lock(&d_inode(dentry)->i_mutex);
+                        inode_lock(d_inode(dentry));
                         notify_change(dentry, &newattrs, NULL);
-                        mutex_unlock(&d_inode(dentry)->i_mutex);
+                        inode_unlock(d_inode(dentry));
                         err = vfs_unlink(d_inode(parent.dentry), dentry, NULL);
                         if (!err || err == -ENOENT)
                                 deleted = 1;
@@ -332,7 +332,7 @@ static int handle_remove(const char *nodename, struct device *dev)
                 err = -ENOENT;
         }
         dput(dentry);
-        mutex_unlock(&d_inode(parent.dentry)->i_mutex);
+        inode_unlock(d_inode(parent.dentry));
 
         path_put(&parent);
         if (deleted && strchr(nodename, '/'))
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index ad80c85e0857..d048d2009e89 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -964,9 +964,9 @@ aoecmd_sleepwork(struct work_struct *work)
                 ssize = get_capacity(d->gd);
                 bd = bdget_disk(d->gd, 0);
                 if (bd) {
-                        mutex_lock(&bd->bd_inode->i_mutex);
+                        inode_lock(bd->bd_inode);
                         i_size_write(bd->bd_inode, (loff_t)ssize<<9);
-                        mutex_unlock(&bd->bd_inode->i_mutex);
+                        inode_unlock(bd->bd_inode);
                         bdput(bd);
                 }
                 spin_lock_irq(&d->lock);
diff --git a/drivers/block/drbd/drbd_debugfs.c b/drivers/block/drbd/drbd_debugfs.c
index 96a0107a72ea..4de95bbff486 100644
--- a/drivers/block/drbd/drbd_debugfs.c
+++ b/drivers/block/drbd/drbd_debugfs.c
@@ -434,12 +434,12 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo
         if (!parent || d_really_is_negative(parent))
                 goto out;
         /* serialize with d_delete() */
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         /* Make sure the object is still alive */
         if (simple_positive(file->f_path.dentry)
         && kref_get_unless_zero(kref))
                 ret = 0;
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         if (!ret) {
                 ret = single_open(file, show, data);
                 if (ret)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 6b1721f978c2..4f6f94c43412 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -689,7 +689,7 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
 {
         loff_t ret;
 
-        mutex_lock(&file_inode(file)->i_mutex);
+        inode_lock(file_inode(file));
         switch (orig) {
         case SEEK_CUR:
                 offset += file->f_pos;
@@ -706,7 +706,7 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
         default:
                 ret = -EINVAL;
         }
-        mutex_unlock(&file_inode(file)->i_mutex);
+        inode_unlock(file_inode(file));
         return ret;
 }
 
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 0b311fa277ef..b526dc15c271 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -290,9 +290,9 @@ static int ps3flash_fsync(struct file *file, loff_t start, loff_t end, int datas
 {
         struct inode *inode = file_inode(file);
         int err;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         err = ps3flash_writeback(ps3flash_dev);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 13ef22bd9459..fcdf37913a26 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -89,14 +89,14 @@ static int create_file(const char *name, umode_t mode,
 {
         int error;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         *dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(*dentry))
                 error = qibfs_mknod(d_inode(parent), *dentry,
                                     mode, fops, data);
         else
                 error = PTR_ERR(*dentry);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 
         return error;
 }
@@ -481,7 +481,7 @@ static int remove_device_files(struct super_block *sb,
         int ret, i;
 
         root = dget(sb->s_root);
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
         snprintf(unit, sizeof(unit), "%u", dd->unit);
         dir = lookup_one_len(unit, root, strlen(unit));
 
@@ -491,7 +491,7 @@ static int remove_device_files(struct super_block *sb,
                 goto bail;
         }
 
-        mutex_lock(&d_inode(dir)->i_mutex);
+        inode_lock(d_inode(dir));
         remove_file(dir, "counters");
         remove_file(dir, "counter_names");
         remove_file(dir, "portcounter_names");
@@ -506,13 +506,13 @@ static int remove_device_files(struct super_block *sb,
                 }
         }
         remove_file(dir, "flash");
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         ret = simple_rmdir(d_inode(root), dir);
         d_delete(dir);
         dput(dir);
 
 bail:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         dput(root);
         return ret;
 }
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 54e056d3be02..ee2b74d1d1b5 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -174,9 +174,9 @@ static int vol_cdev_fsync(struct file *file, loff_t start, loff_t end,
         struct ubi_device *ubi = desc->vol->ubi;
         struct inode *inode = file_inode(file);
         int err;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         err = ubi_sync(ubi->ubi_num);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index dd92c5edf219..b48ac6300c79 100644
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -138,22 +138,22 @@ static int __oprofilefs_create_file(struct dentry *root, char const *name,
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
         dentry = d_alloc_name(root, name);
         if (!dentry) {
-                mutex_unlock(&d_inode(root)->i_mutex);
+                inode_unlock(d_inode(root));
                 return -ENOMEM;
         }
         inode = oprofilefs_get_inode(root->d_sb, S_IFREG | perm);
         if (!inode) {
                 dput(dentry);
-                mutex_unlock(&d_inode(root)->i_mutex);
+                inode_unlock(d_inode(root));
                 return -ENOMEM;
         }
         inode->i_fop = fops;
         inode->i_private = priv;
         d_add(dentry, inode);
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         return 0;
 }
 
@@ -215,22 +215,22 @@ struct dentry *oprofilefs_mkdir(struct dentry *parent, char const *name)
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         dentry = d_alloc_name(parent, name);
         if (!dentry) {
-                mutex_unlock(&d_inode(parent)->i_mutex);
+                inode_unlock(d_inode(parent));
                 return NULL;
         }
         inode = oprofilefs_get_inode(parent->d_sb, S_IFDIR | 0755);
         if (!inode) {
                 dput(dentry);
-                mutex_unlock(&d_inode(parent)->i_mutex);
+                inode_unlock(d_inode(parent));
                 return NULL;
         }
         inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
         d_add(dentry, inode);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         return dentry;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index 7b355319079c..8982f7d1b374 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -1858,7 +1858,7 @@ static loff_t ll_dir_seek(struct file *file, loff_t offset, int origin)
         int api32 = ll_need_32bit_api(sbi);
         loff_t ret = -EINVAL;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         switch (origin) {
         case SEEK_SET:
                 break;
@@ -1896,7 +1896,7 @@ static loff_t ll_dir_seek(struct file *file, loff_t offset, int origin)
         goto out;
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index c92d58b770ec..39e2ffd5f97f 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -2082,17 +2082,17 @@ putgl:
         /* update time if requested */
         rc = 0;
         if (llss->ia2.ia_valid != 0) {
-                mutex_lock(&llss->inode1->i_mutex);
+                inode_lock(llss->inode1);
                 rc = ll_setattr(file1->f_path.dentry, &llss->ia2);
-                mutex_unlock(&llss->inode1->i_mutex);
+                inode_unlock(llss->inode1);
         }
 
         if (llss->ia1.ia_valid != 0) {
                 int rc1;
 
-                mutex_lock(&llss->inode2->i_mutex);
+                inode_lock(llss->inode2);
                 rc1 = ll_setattr(file2->f_path.dentry, &llss->ia1);
-                mutex_unlock(&llss->inode2->i_mutex);
+                inode_unlock(llss->inode2);
                 if (rc == 0)
                         rc = rc1;
         }
@@ -2179,13 +2179,13 @@ static int ll_hsm_import(struct inode *inode, struct file *file,
                          ATTR_MTIME | ATTR_MTIME_SET |
                          ATTR_ATIME | ATTR_ATIME_SET;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         rc = ll_setattr_raw(file->f_path.dentry, attr, true);
         if (rc == -ENODATA)
                 rc = 0;
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         kfree(attr);
 free_hss:
@@ -2609,7 +2609,7 @@ int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
 
         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* catch async errors that were recorded back when async writeback
          * failed for pages in this mapping. */
@@ -2641,7 +2641,7 @@ int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                         fd->fd_write_failed = false;
         }
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return rc;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index 1db93af62bad..b2fc5b3786ee 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -1277,7 +1277,7 @@ int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import)
                 return -ENOMEM;
 
         if (!S_ISDIR(inode->i_mode))
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         memcpy(&op_data->op_attr, attr, sizeof(*attr));
 
@@ -1358,7 +1358,7 @@ out:
         ll_finish_md_op_data(op_data);
 
         if (!S_ISDIR(inode->i_mode)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if ((attr->ia_valid & ATTR_SIZE) && !hsm_import)
                         inode_dio_wait(inode);
         }
diff --git a/drivers/staging/lustre/lustre/llite/llite_nfs.c b/drivers/staging/lustre/lustre/llite/llite_nfs.c
index e578a1130ad1..18aab25f9cd9 100644
--- a/drivers/staging/lustre/lustre/llite/llite_nfs.c
+++ b/drivers/staging/lustre/lustre/llite/llite_nfs.c
@@ -245,9 +245,9 @@ static int ll_get_name(struct dentry *dentry, char *name,
                 goto out;
         }
 
-        mutex_lock(&dir->i_mutex);
+        inode_lock(dir);
         rc = ll_dir_read(dir, &lgd.ctx);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         if (!rc && !lgd.lgd_found)
                 rc = -ENOENT;
 out:
diff --git a/drivers/staging/lustre/lustre/llite/lloop.c b/drivers/staging/lustre/lustre/llite/lloop.c
index 420d39123877..871924b3f2e7 100644
--- a/drivers/staging/lustre/lustre/llite/lloop.c
+++ b/drivers/staging/lustre/lustre/llite/lloop.c
@@ -257,9 +257,9 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
          *    be asked to write less pages once, this purely depends on
          *    implementation. Anyway, we should be careful to avoid deadlocking.
          */
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         bytes = ll_direct_rw_pages(env, io, rw, inode, pvec);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         cl_io_fini(env, io);
         return (bytes == pvec->ldp_size) ? 0 : (int)bytes;
 }
diff --git a/drivers/staging/lustre/lustre/llite/rw.c b/drivers/staging/lustre/lustre/llite/rw.c
index 95cdb0c58b04..f355474967d6 100644
--- a/drivers/staging/lustre/lustre/llite/rw.c
+++ b/drivers/staging/lustre/lustre/llite/rw.c
@@ -115,8 +115,8 @@ static struct ll_cl_context *ll_cl_init(struct file *file,
                 struct inode *inode = vmpage->mapping->host;
                 loff_t pos;
 
-                if (mutex_trylock(&inode->i_mutex)) {
-                        mutex_unlock(&(inode)->i_mutex);
+                if (inode_trylock(inode)) {
+                        inode_unlock((inode));
 
                         /* this is too bad. Someone is trying to write the
                          * page w/o holding inode mutex. This means we can
diff --git a/drivers/staging/lustre/lustre/llite/rw26.c b/drivers/staging/lustre/lustre/llite/rw26.c
index 39fa13b74cbd..711fda93a58d 100644
--- a/drivers/staging/lustre/lustre/llite/rw26.c
+++ b/drivers/staging/lustre/lustre/llite/rw26.c
@@ -403,7 +403,7 @@ static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter,
          * 1. Need inode mutex to operate transient pages.
          */
         if (iov_iter_rw(iter) == READ)
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
 
         LASSERT(obj->cob_transient_pages == 0);
         while (iov_iter_count(iter)) {
@@ -454,7 +454,7 @@ static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter,
 out:
         LASSERT(obj->cob_transient_pages == 0);
         if (iov_iter_rw(iter) == READ)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         if (tot_bytes > 0) {
                 if (iov_iter_rw(iter) == WRITE) {
diff --git a/drivers/staging/lustre/lustre/llite/vvp_io.c b/drivers/staging/lustre/lustre/llite/vvp_io.c
index f68e972886ca..0920ac6b3003 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_io.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_io.c
@@ -439,7 +439,7 @@ static int vvp_io_setattr_start(const struct lu_env *env,
         struct inode    *inode = ccc_object_inode(io->ci_obj);
         int result = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         if (cl_io_is_trunc(io))
                 result = vvp_io_setattr_trunc(env, ios, inode,
                                         io->u.ci_setattr.sa_attr.lvb_size);
@@ -459,7 +459,7 @@ static void vvp_io_setattr_end(const struct lu_env *env,
                  * because osc has already notified to destroy osc_extents. */
                 vvp_do_vmtruncate(inode, io->u.ci_setattr.sa_attr.lvb_size);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 }
 
 static void vvp_io_setattr_fini(const struct lu_env *env,
diff --git a/drivers/staging/lustre/lustre/llite/vvp_page.c b/drivers/staging/lustre/lustre/llite/vvp_page.c
index 99c0d7aee921..a133475a7c74 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_page.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_page.c
@@ -428,7 +428,7 @@ static void vvp_transient_page_verify(const struct cl_page *page)
 {
         struct inode *inode = ccc_object_inode(page->cp_obj);
 
-        LASSERT(!mutex_trylock(&inode->i_mutex));
+        LASSERT(!inode_trylock(inode));
 }
 
 static int vvp_transient_page_own(const struct lu_env *env,
@@ -480,9 +480,9 @@ static int vvp_transient_page_is_vmlocked(const struct lu_env *env,
         struct inode    *inode = ccc_object_inode(slice->cpl_obj);
         int     locked;
 
-        locked = !mutex_trylock(&inode->i_mutex);
+        locked = !inode_trylock(inode);
         if (!locked)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         return locked ? -EBUSY : -ENODATA;
 }
 
@@ -502,7 +502,7 @@ static void vvp_transient_page_fini(const struct lu_env *env,
         struct ccc_object *clobj = cl2ccc(clp->cp_obj);
 
         vvp_page_fini_common(cp);
-        LASSERT(!mutex_trylock(&clobj->cob_inode->i_mutex));
+        LASSERT(!inode_trylock(clobj->cob_inode));
         clobj->cob_transient_pages--;
 }
 
@@ -548,7 +548,7 @@ int vvp_page_init(const struct lu_env *env, struct cl_object *obj,
         } else {
                 struct ccc_object *clobj = cl2ccc(obj);
 
-                LASSERT(!mutex_trylock(&clobj->cob_inode->i_mutex));
+                LASSERT(!inode_trylock(clobj->cob_inode));
                 cl_page_slice_add(page, &cpg->cpg_cl, obj,
                                 &vvp_transient_page_ops);
                 clobj->cob_transient_pages++;
diff --git a/drivers/staging/rdma/ipath/ipath_fs.c b/drivers/staging/rdma/ipath/ipath_fs.c
index 796af6867007..476fcdf05acb 100644
--- a/drivers/staging/rdma/ipath/ipath_fs.c
+++ b/drivers/staging/rdma/ipath/ipath_fs.c
@@ -82,14 +82,14 @@ static int create_file(const char *name, umode_t mode,
 {
         int error;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         *dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(*dentry))
                 error = ipathfs_mknod(d_inode(parent), *dentry,
                                       mode, fops, data);
         else
                 error = PTR_ERR(*dentry);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 
         return error;
 }
@@ -295,7 +295,7 @@ static int remove_device_files(struct super_block *sb,
         int ret;
 
         root = dget(sb->s_root);
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
         snprintf(unit, sizeof unit, "%02d", dd->ipath_unit);
         dir = lookup_one_len(unit, root, strlen(unit));
 
@@ -311,7 +311,7 @@ static int remove_device_files(struct super_block *sb,
         ret = simple_rmdir(d_inode(root), dir);
 
 bail:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         dput(root);
         return ret;
 }
diff --git a/drivers/usb/gadget/function/f_printer.c b/drivers/usb/gadget/function/f_printer.c
index 0fbfb2b2aa08..26ccad5d8680 100644
--- a/drivers/usb/gadget/function/f_printer.c
+++ b/drivers/usb/gadget/function/f_printer.c
@@ -673,7 +673,7 @@ printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync)
         unsigned long           flags;
         int                     tx_list_empty;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         spin_lock_irqsave(&dev->lock, flags);
         tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
         spin_unlock_irqrestore(&dev->lock, flags);
@@ -683,7 +683,7 @@ printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync)
                 wait_event_interruptible(dev->tx_flush_wait,
                                 (likely(list_empty(&dev->tx_reqs_active))));
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return 0;
 }
diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c
index 365afd7e14f8..7e179f81d05c 100644
--- a/drivers/usb/gadget/legacy/inode.c
+++ b/drivers/usb/gadget/legacy/inode.c
@@ -1521,10 +1521,10 @@ static void destroy_ep_files (struct dev_data *dev)
                 spin_unlock_irq (&dev->lock);
 
                 /* break link to dcache */
-                mutex_lock (&parent->i_mutex);
+                inode_lock(parent);
                 d_delete (dentry);
                 dput (dentry);
-                mutex_unlock (&parent->i_mutex);
+                inode_unlock(parent);
 
                 spin_lock_irq (&dev->lock);
         }
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index f92f5aff0dd5..8755b2c2aada 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -91,7 +91,7 @@ static ssize_t queue_dbg_read(struct file *file, char __user *buf,
         if (!access_ok(VERIFY_WRITE, buf, nbytes))
                 return -EFAULT;
 
-        mutex_lock(&file_inode(file)->i_mutex);
+        inode_lock(file_inode(file));
         list_for_each_entry_safe(req, tmp_req, queue, queue) {
                 len = snprintf(tmpbuf, sizeof(tmpbuf),
                                 "%8p %08x %c%c%c %5d %c%c%c\n",
@@ -118,7 +118,7 @@ static ssize_t queue_dbg_read(struct file *file, char __user *buf,
                 nbytes -= len;
                 buf += len;
         }
-        mutex_unlock(&file_inode(file)->i_mutex);
+        inode_unlock(file_inode(file));
 
         return actual;
 }
@@ -143,7 +143,7 @@ static int regs_dbg_open(struct inode *inode, struct file *file)
         u32 *data;
         int ret = -ENOMEM;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         udc = inode->i_private;
         data = kmalloc(inode->i_size, GFP_KERNEL);
         if (!data)
@@ -158,7 +158,7 @@ static int regs_dbg_open(struct inode *inode, struct file *file)
         ret = 0;
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
@@ -169,11 +169,11 @@ static ssize_t regs_dbg_read(struct file *file, char __user *buf,
         struct inode *inode = file_inode(file);
         int ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = simple_read_from_buffer(buf, nbytes, ppos,
                         file->private_data,
                         file_inode(file)->i_size);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
diff --git a/drivers/video/fbdev/core/fb_defio.c b/drivers/video/fbdev/core/fb_defio.c
index 3fc63c208d08..57721c73177f 100644
--- a/drivers/video/fbdev/core/fb_defio.c
+++ b/drivers/video/fbdev/core/fb_defio.c
@@ -78,13 +78,13 @@ int fb_deferred_io_fsync(struct file *file, loff_t start, loff_t end, int datasy
         if (!info->fbdefio)
                 return 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* Kill off the delayed work */
         cancel_delayed_work_sync(&info->deferred_work);
 
         /* Run it immediately */
         schedule_delayed_work(&info->deferred_work, 0);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return 0;
 }
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 7bf835f85bc8..eadc894faea2 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -449,14 +449,14 @@ static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end,
         if (retval)
                 return retval;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
 
         fid = filp->private_data;
         v9fs_blank_wstat(&wstat);
 
         retval = p9_client_wstat(fid, &wstat);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return retval;
 }
@@ -472,13 +472,13 @@ int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
         if (retval)
                 return retval;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
 
         fid = filp->private_data;
 
         retval = p9_client_fsync(fid, datasync);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return retval;
 }
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 659c579c4588..0548c53f41d5 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -33,11 +33,11 @@ affs_file_release(struct inode *inode, struct file *filp)
                  inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
 
         if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (inode->i_size != AFFS_I(inode)->mmu_private)
                         affs_truncate(inode);
                 affs_free_prealloc(inode);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         return 0;
@@ -958,12 +958,12 @@ int affs_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
         if (err)
                 return err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = write_inode_now(inode, 0);
         err = sync_blockdev(inode->i_sb->s_bdev);
         if (!ret)
                 ret = err;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 const struct file_operations affs_file_operations = {
diff --git a/fs/afs/flock.c b/fs/afs/flock.c
index 4baf1d2b39e4..d91a9c9cfbd0 100644
--- a/fs/afs/flock.c
+++ b/fs/afs/flock.c
@@ -483,7 +483,7 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl)
 
         fl->fl_type = F_UNLCK;
 
-        mutex_lock(&vnode->vfs_inode.i_mutex);
+        inode_lock(&vnode->vfs_inode);
 
         /* check local lock records first */
         ret = 0;
@@ -505,7 +505,7 @@ static int afs_do_getlk(struct file *file, struct file_lock *fl)
         }
 
 error:
-        mutex_unlock(&vnode->vfs_inode.i_mutex);
+        inode_unlock(&vnode->vfs_inode);
         _leave(" = %d [%hd]", ret, fl->fl_type);
         return ret;
 }
diff --git a/fs/afs/write.c b/fs/afs/write.c
index 0714abcd7f32..dfef94f70667 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -693,7 +693,7 @@ int afs_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)
                 return ret;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* use a writeback record as a marker in the queue - when this reaches
          * the front of the queue, all the outstanding writes are either
@@ -735,7 +735,7 @@ int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         afs_put_writeback(wb);
         _leave(" = %d", ret);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/attr.c b/fs/attr.c
index 6530ced19697..25b24d0f6c88 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -195,7 +195,7 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **de
         struct timespec now;
         unsigned int ia_valid = attr->ia_valid;
 
-        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
+        WARN_ON_ONCE(!inode_is_locked(inode));
 
         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_TIMES_SET)) {
                 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 78f005f37847..3a3ced779fc7 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -638,11 +638,11 @@ static ssize_t bm_entry_write(struct file *file, const char __user *buffer,
         case 3:
                 /* Delete this handler. */
                 root = dget(file->f_path.dentry->d_sb->s_root);
-                mutex_lock(&d_inode(root)->i_mutex);
+                inode_lock(d_inode(root));
 
                 kill_node(e);
 
-                mutex_unlock(&d_inode(root)->i_mutex);
+                inode_unlock(d_inode(root));
                 dput(root);
                 break;
         default:
@@ -675,7 +675,7 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
                 return PTR_ERR(e);
 
         root = dget(sb->s_root);
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
         dentry = lookup_one_len(e->name, root, strlen(e->name));
         err = PTR_ERR(dentry);
         if (IS_ERR(dentry))
@@ -711,7 +711,7 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
 out2:
         dput(dentry);
 out:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         dput(root);
 
         if (err) {
@@ -754,12 +754,12 @@ static ssize_t bm_status_write(struct file *file, const char __user *buffer,
         case 3:
                 /* Delete all handlers. */
                 root = dget(file->f_path.dentry->d_sb->s_root);
-                mutex_lock(&d_inode(root)->i_mutex);
+                inode_lock(d_inode(root));
 
                 while (!list_empty(&entries))
                         kill_node(list_entry(entries.next, Node, list));
 
-                mutex_unlock(&d_inode(root)->i_mutex);
+                inode_unlock(d_inode(root));
                 dput(root);
                 break;
         default:
diff --git a/fs/block_dev.c b/fs/block_dev.c
index ba762ea07f67..2c3aeab17e20 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -346,9 +346,9 @@ static loff_t block_llseek(struct file *file, loff_t offset, int whence)
         struct inode *bd_inode = bdev_file_inode(file);
         loff_t retval;
 
-        mutex_lock(&bd_inode->i_mutex);
+        inode_lock(bd_inode);
         retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode));
-        mutex_unlock(&bd_inode->i_mutex);
+        inode_unlock(bd_inode);
         return retval;
 }
         
@@ -1142,9 +1142,9 @@ void bd_set_size(struct block_device *bdev, loff_t size)
 {
         unsigned bsize = bdev_logical_block_size(bdev);
 
-        mutex_lock(&bdev->bd_inode->i_mutex);
+        inode_lock(bdev->bd_inode);
         i_size_write(bdev->bd_inode, size);
-        mutex_unlock(&bdev->bd_inode->i_mutex);
+        inode_unlock(bdev->bd_inode);
         while (bsize < PAGE_CACHE_SIZE) {
                 if (size & bsize)
                         break;
@@ -1741,9 +1741,9 @@ static void blkdev_vm_open(struct vm_area_struct *vma)
         struct inode *bd_inode = bdev_file_inode(vma->vm_file);
         struct block_device *bdev = I_BDEV(bd_inode);
 
-        mutex_lock(&bd_inode->i_mutex);
+        inode_lock(bd_inode);
         bdev->bd_map_count++;
-        mutex_unlock(&bd_inode->i_mutex);
+        inode_unlock(bd_inode);
 }
 
 static void blkdev_vm_close(struct vm_area_struct *vma)
@@ -1751,9 +1751,9 @@ static void blkdev_vm_close(struct vm_area_struct *vma)
         struct inode *bd_inode = bdev_file_inode(vma->vm_file);
         struct block_device *bdev = I_BDEV(bd_inode);
 
-        mutex_lock(&bd_inode->i_mutex);
+        inode_lock(bd_inode);
         bdev->bd_map_count--;
-        mutex_unlock(&bd_inode->i_mutex);
+        inode_unlock(bd_inode);
 }
 
 static const struct vm_operations_struct blkdev_dax_vm_ops = {
@@ -1777,7 +1777,7 @@ static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)
         struct block_device *bdev = I_BDEV(bd_inode);
 
         file_accessed(file);
-        mutex_lock(&bd_inode->i_mutex);
+        inode_lock(bd_inode);
         bdev->bd_map_count++;
         if (IS_DAX(bd_inode)) {
                 vma->vm_ops = &blkdev_dax_vm_ops;
@@ -1785,7 +1785,7 @@ static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)
         } else {
                 vma->vm_ops = &blkdev_default_vm_ops;
         }
-        mutex_unlock(&bd_inode->i_mutex);
+        inode_unlock(bd_inode);
 
         return 0;
 }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 9f5cc1e8e126..098bb8f690c9 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1762,17 +1762,17 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
         loff_t pos;
         size_t count;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         err = generic_write_checks(iocb, from);
         if (err <= 0) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return err;
         }
 
         current->backing_dev_info = inode_to_bdi(inode);
         err = file_remove_privs(file);
         if (err) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 goto out;
         }
 
@@ -1783,7 +1783,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
          * to stop this write operation to ensure FS consistency.
          */
         if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 err = -EROFS;
                 goto out;
         }
@@ -1804,7 +1804,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
                 end_pos = round_up(pos + count, root->sectorsize);
                 err = btrfs_cont_expand(inode, i_size_read(inode), end_pos);
                 if (err) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         goto out;
                 }
         }
@@ -1820,7 +1820,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
                         iocb->ki_pos = pos + num_written;
         }
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         /*
          * We also have to set last_sub_trans to the current log transid,
@@ -1909,7 +1909,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         atomic_inc(&root->log_batch);
         full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
                              &BTRFS_I(inode)->runtime_flags);
@@ -1961,7 +1961,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
                 ret = start_ordered_ops(inode, start, end);
         }
         if (ret) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 goto out;
         }
         atomic_inc(&root->log_batch);
@@ -2007,7 +2007,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
                  */
                 clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
                           &BTRFS_I(inode)->runtime_flags);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 goto out;
         }
 
@@ -2031,7 +2031,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         trans = btrfs_start_transaction(root, 0);
         if (IS_ERR(trans)) {
                 ret = PTR_ERR(trans);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 goto out;
         }
         trans->sync = true;
@@ -2054,7 +2054,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
          * file again, but that will end up using the synchronization
          * inside btrfs_sync_log to keep things safe.
          */
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         /*
          * If any of the ordered extents had an error, just return it to user
@@ -2303,7 +2303,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ino_size = round_up(inode->i_size, PAGE_CACHE_SIZE);
         ret = find_first_non_hole(inode, &offset, &len);
         if (ret < 0)
@@ -2343,7 +2343,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                 truncated_page = true;
                 ret = btrfs_truncate_page(inode, offset, 0, 0);
                 if (ret) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         return ret;
                 }
         }
@@ -2419,7 +2419,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                 ret = btrfs_wait_ordered_range(inode, lockstart,
                                                lockend - lockstart + 1);
                 if (ret) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         return ret;
                 }
         }
@@ -2574,7 +2574,7 @@ out_only_mutex:
                         ret = btrfs_end_transaction(trans, root);
                 }
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (ret && !err)
                 err = ret;
         return err;
@@ -2658,7 +2658,7 @@ static long btrfs_fallocate(struct file *file, int mode,
         if (ret < 0)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = inode_newsize_ok(inode, alloc_end);
         if (ret)
                 goto out;
@@ -2816,7 +2816,7 @@ out:
          * So this is completely used as cleanup.
          */
         btrfs_qgroup_free_data(inode, alloc_start, alloc_end - alloc_start);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         /* Let go of our reservation. */
         btrfs_free_reserved_data_space(inode, alloc_start,
                                        alloc_end - alloc_start);
@@ -2892,7 +2892,7 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
         struct inode *inode = file->f_mapping->host;
         int ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         switch (whence) {
         case SEEK_END:
         case SEEK_CUR:
@@ -2901,20 +2901,20 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
         case SEEK_DATA:
         case SEEK_HOLE:
                 if (offset >= i_size_read(inode)) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         return -ENXIO;
                 }
 
                 ret = find_desired_extent(inode, &offset, whence);
                 if (ret) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         return ret;
                 }
         }
 
         offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return offset;
 }
 
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 1b79dc9b12e4..e28f3d4691af 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -8447,7 +8447,7 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
                  * not unlock the i_mutex at this case.
                  */
                 if (offset + count <= inode->i_size) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         relock = true;
                 }
                 ret = btrfs_delalloc_reserve_space(inode, offset, count);
@@ -8504,7 +8504,7 @@ out:
         if (wakeup)
                 inode_dio_end(inode);
         if (relock)
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
 
         return ret;
 }
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 9028737ee9b5..952172ca7e45 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -240,7 +240,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         ip_oldflags = ip->flags;
         i_oldflags = inode->i_flags;
@@ -358,7 +358,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         }
 
  out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         mnt_drop_write_file(file);
         return ret;
 }
@@ -881,7 +881,7 @@ out_up_read:
 out_dput:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         return error;
 }
 
@@ -1393,18 +1393,18 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                         ra_index += cluster;
                 }
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
                         BTRFS_I(inode)->force_compress = compress_type;
                 ret = cluster_pages_for_defrag(inode, pages, i, cluster);
                 if (ret < 0) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         goto out_ra;
                 }
 
                 defrag_count += ret;
                 balance_dirty_pages_ratelimited(inode->i_mapping);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 if (newer_than) {
                         if (newer_off == (u64)-1)
@@ -1465,9 +1465,9 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
 
 out_ra:
         if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         if (!file)
                 kfree(ra);
@@ -2430,7 +2430,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                 goto out_dput;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * Don't allow to delete a subvolume with send in progress. This is
@@ -2543,7 +2543,7 @@ out_up_write:
                 spin_unlock(&dest->root_item_lock);
         }
 out_unlock_inode:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (!err) {
                 d_invalidate(dentry);
                 btrfs_invalidate_inodes(dest);
@@ -2559,7 +2559,7 @@ out_unlock_inode:
 out_dput:
         dput(dentry);
 out_unlock_dir:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
 out_drop_write:
         mnt_drop_write_file(file);
 out:
@@ -2857,8 +2857,8 @@ static inline void lock_extent_range(struct inode *inode, u64 off, u64 len)
 
 static void btrfs_double_inode_unlock(struct inode *inode1, struct inode *inode2)
 {
-        mutex_unlock(&inode1->i_mutex);
-        mutex_unlock(&inode2->i_mutex);
+        inode_unlock(inode1);
+        inode_unlock(inode2);
 }
 
 static void btrfs_double_inode_lock(struct inode *inode1, struct inode *inode2)
@@ -2866,8 +2866,8 @@ static void btrfs_double_inode_lock(struct inode *inode1, struct inode *inode2)
         if (inode1 < inode2)
                 swap(inode1, inode2);
 
-        mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT);
-        mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(inode1, I_MUTEX_PARENT);
+        inode_lock_nested(inode2, I_MUTEX_CHILD);
 }
 
 static void btrfs_double_extent_unlock(struct inode *inode1, u64 loff1,
@@ -3026,7 +3026,7 @@ static int btrfs_extent_same(struct inode *src, u64 loff, u64 olen,
                 return 0;
 
         if (same_inode) {
-                mutex_lock(&src->i_mutex);
+                inode_lock(src);
 
                 ret = extent_same_check_offsets(src, loff, &len, olen);
                 if (ret)
@@ -3101,7 +3101,7 @@ static int btrfs_extent_same(struct inode *src, u64 loff, u64 olen,
         btrfs_cmp_data_free(&cmp);
 out_unlock:
         if (same_inode)
-                mutex_unlock(&src->i_mutex);
+                inode_unlock(src);
         else
                 btrfs_double_inode_unlock(src, dst);
 
@@ -3749,7 +3749,7 @@ static noinline int btrfs_clone_files(struct file *file, struct file *file_src,
         if (!same_inode) {
                 btrfs_double_inode_lock(src, inode);
         } else {
-                mutex_lock(&src->i_mutex);
+                inode_lock(src);
         }
 
         /* determine range to clone */
@@ -3820,7 +3820,7 @@ out_unlock:
         if (!same_inode)
                 btrfs_double_inode_unlock(src, inode);
         else
-                mutex_unlock(&src->i_mutex);
+                inode_unlock(src);
         return ret;
 }
 
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index ef6d8fc85853..fd1c4d982463 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3030,7 +3030,7 @@ int prealloc_file_extent_cluster(struct inode *inode,
         int ret = 0;
 
         BUG_ON(cluster->start != cluster->boundary[0]);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         ret = btrfs_check_data_free_space(inode, cluster->start,
                                           cluster->end + 1 - cluster->start);
@@ -3057,7 +3057,7 @@ int prealloc_file_extent_cluster(struct inode *inode,
         btrfs_free_reserved_data_space(inode, cluster->start,
                                        cluster->end + 1 - cluster->start);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index b1a68530e911..92bf5ee732fb 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -4279,7 +4279,7 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
                 return PTR_ERR(inode);
 
         /* Avoid truncate/dio/punch hole.. */
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         inode_dio_wait(inode);
 
         physical_for_dev_replace = nocow_ctx->physical_for_dev_replace;
@@ -4358,7 +4358,7 @@ next_page:
         }
         ret = COPY_COMPLETE;
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         iput(inode);
         return ret;
 }
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index fd953c361a43..6c68d6356197 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -126,7 +126,7 @@ static int do_setxattr(struct btrfs_trans_handle *trans,
          * locks the inode's i_mutex before calling setxattr or removexattr.
          */
         if (flags & XATTR_REPLACE) {
-                ASSERT(mutex_is_locked(&inode->i_mutex));
+                ASSERT(inode_is_locked(inode));
                 di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode),
                                         name, name_len, 0);
                 if (!di)
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index afa023dded5b..675a3332d72f 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -446,7 +446,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
                 return 0;
 
         cachefiles_begin_secure(cache, &saved_cred);
-        mutex_lock(&d_inode(object->backer)->i_mutex);
+        inode_lock(d_inode(object->backer));
 
         /* if there's an extension to a partial page at the end of the backing
          * file, we need to discard the partial page so that we pick up new
@@ -465,7 +465,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
         ret = notify_change(object->backer, &newattrs, NULL);
 
 truncate_failed:
-        mutex_unlock(&d_inode(object->backer)->i_mutex);
+        inode_unlock(d_inode(object->backer));
         cachefiles_end_secure(cache, saved_cred);
 
         if (ret == -EIO) {
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index c4b893453e0e..1c2334c163dd 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -295,7 +295,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
                                 cachefiles_mark_object_buried(cache, rep, why);
                 }
 
-                mutex_unlock(&d_inode(dir)->i_mutex);
+                inode_unlock(d_inode(dir));
 
                 if (ret == -EIO)
                         cachefiles_io_error(cache, "Unlink failed");
@@ -306,7 +306,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
 
         /* directories have to be moved to the graveyard */
         _debug("move stale object to graveyard");
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 
 try_again:
         /* first step is to make up a grave dentry in the graveyard */
@@ -423,13 +423,13 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
 
         dir = dget_parent(object->dentry);
 
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
 
         if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
                 /* object allocation for the same key preemptively deleted this
                  * object's file so that it could create its own file */
                 _debug("object preemptively buried");
-                mutex_unlock(&d_inode(dir)->i_mutex);
+                inode_unlock(d_inode(dir));
                 ret = 0;
         } else {
                 /* we need to check that our parent is _still_ our parent - it
@@ -442,7 +442,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
                         /* it got moved, presumably by cachefilesd culling it,
                          * so it's no longer in the key path and we can ignore
                          * it */
-                        mutex_unlock(&d_inode(dir)->i_mutex);
+                        inode_unlock(d_inode(dir));
                         ret = 0;
                 }
         }
@@ -501,7 +501,7 @@ lookup_again:
         /* search the current directory for the element name */
         _debug("lookup '%s'", name);
 
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
 
         start = jiffies;
         next = lookup_one_len(name, dir, nlen);
@@ -585,7 +585,7 @@ lookup_again:
         /* process the next component */
         if (key) {
                 _debug("advance");
-                mutex_unlock(&d_inode(dir)->i_mutex);
+                inode_unlock(d_inode(dir));
                 dput(dir);
                 dir = next;
                 next = NULL;
@@ -623,7 +623,7 @@ lookup_again:
         /* note that we're now using this object */
         ret = cachefiles_mark_object_active(cache, object);
 
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(dir);
         dir = NULL;
 
@@ -705,7 +705,7 @@ lookup_error:
                 cachefiles_io_error(cache, "Lookup failed");
         next = NULL;
 error:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(next);
 error_out2:
         dput(dir);
@@ -729,7 +729,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         _enter(",,%s", dirname);
 
         /* search the current directory for the element name */
-        mutex_lock(&d_inode(dir)->i_mutex);
+        inode_lock(d_inode(dir));
 
         start = jiffies;
         subdir = lookup_one_len(dirname, dir, strlen(dirname));
@@ -768,7 +768,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
                        d_backing_inode(subdir)->i_ino);
         }
 
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 
         /* we need to make sure the subdir is a directory */
         ASSERT(d_backing_inode(subdir));
@@ -800,19 +800,19 @@ check_error:
         return ERR_PTR(ret);
 
 mkdir_error:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(subdir);
         pr_err("mkdir %s failed with error %d\n", dirname, ret);
         return ERR_PTR(ret);
 
 lookup_error:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         ret = PTR_ERR(subdir);
         pr_err("Lookup %s failed with error %d\n", dirname, ret);
         return ERR_PTR(ret);
 
 nomem_d_alloc:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         _leave(" = -ENOMEM");
         return ERR_PTR(-ENOMEM);
 }
@@ -837,7 +837,7 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
         //       dir, filename);
 
         /* look up the victim */
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
 
         start = jiffies;
         victim = lookup_one_len(filename, dir, strlen(filename));
@@ -852,7 +852,7 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
          * at the netfs's request whilst the cull was in progress
          */
         if (d_is_negative(victim)) {
-                mutex_unlock(&d_inode(dir)->i_mutex);
+                inode_unlock(d_inode(dir));
                 dput(victim);
                 _leave(" = -ENOENT [absent]");
                 return ERR_PTR(-ENOENT);
@@ -881,13 +881,13 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
 
 object_in_use:
         read_unlock(&cache->active_lock);
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(victim);
         //_leave(" = -EBUSY [in use]");
         return ERR_PTR(-EBUSY);
 
 lookup_error:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         ret = PTR_ERR(victim);
         if (ret == -ENOENT) {
                 /* file or dir now absent - probably retired by netfs */
@@ -947,7 +947,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
         return 0;
 
 error_unlock:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 error:
         dput(victim);
         if (ret == -ENOENT) {
@@ -982,7 +982,7 @@ int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
         if (IS_ERR(victim))
                 return PTR_ERR(victim);
 
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(victim);
         //_leave(" = 0");
         return 0;
diff --git a/fs/ceph/cache.c b/fs/ceph/cache.c
index a4766ded1ba7..7680e2626815 100644
--- a/fs/ceph/cache.c
+++ b/fs/ceph/cache.c
@@ -197,7 +197,7 @@ void ceph_fscache_register_inode_cookie(struct ceph_fs_client* fsc,
                 return;
 
         /* Avoid multiple racing open requests */
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (ci->fscache)
                 goto done;
@@ -207,7 +207,7 @@ void ceph_fscache_register_inode_cookie(struct ceph_fs_client* fsc,
                                              ci, true);
         fscache_check_consistency(ci->fscache);
 done:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
 }
 
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index c69e1253b47b..cdbf8cf3d52c 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -2030,7 +2030,7 @@ int ceph_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         if (datasync)
                 goto out;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         dirty = try_flush_caps(inode, &flush_tid);
         dout("fsync dirty caps are %s\n", ceph_cap_string(dirty));
@@ -2046,7 +2046,7 @@ int ceph_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 ret = wait_event_interruptible(ci->i_cap_wq,
                                         caps_are_flushed(inode, flush_tid));
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out:
         dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
         return ret;
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 9314b4ea2375..fd11fb231a2e 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -507,7 +507,7 @@ static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence)
         loff_t old_offset = ceph_make_fpos(fi->frag, fi->next_offset);
         loff_t retval;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         retval = -EINVAL;
         switch (whence) {
         case SEEK_CUR:
@@ -542,7 +542,7 @@ static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence)
                 }
         }
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return retval;
 }
 
diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index fe02ae7f056a..3b3172357326 100644
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -215,7 +215,7 @@ static int ceph_get_name(struct dentry *parent, char *name,
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
 
         req->r_inode = d_inode(child);
         ihold(d_inode(child));
@@ -224,7 +224,7 @@ static int ceph_get_name(struct dentry *parent, char *name,
         req->r_num_caps = 2;
         err = ceph_mdsc_do_request(mdsc, NULL, req);
 
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 
         if (!err) {
                 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 3c68e6aee2f0..10c5ae79696e 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -1014,7 +1014,7 @@ static ssize_t ceph_write_iter(struct kiocb *iocb, struct iov_iter *from)
         if (!prealloc_cf)
                 return -ENOMEM;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* We can write back this queue in page reclaim */
         current->backing_dev_info = inode_to_bdi(inode);
@@ -1070,7 +1070,7 @@ retry_snap:
             (iocb->ki_flags & IOCB_DIRECT) || (fi->flags & CEPH_F_SYNC)) {
                 struct ceph_snap_context *snapc;
                 struct iov_iter data;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 spin_lock(&ci->i_ceph_lock);
                 if (__ceph_have_pending_cap_snap(ci)) {
@@ -1097,7 +1097,7 @@ retry_snap:
                                 "got EOLDSNAPC, retrying\n",
                                 inode, ceph_vinop(inode),
                                 pos, (unsigned)count);
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                         goto retry_snap;
                 }
                 if (written > 0)
@@ -1117,7 +1117,7 @@ retry_snap:
                         iocb->ki_pos = pos + written;
                 if (inode->i_size > old_size)
                         ceph_fscache_update_objectsize(inode);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         if (written >= 0) {
@@ -1147,7 +1147,7 @@ retry_snap:
         goto out_unlocked;
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out_unlocked:
         ceph_free_cap_flush(prealloc_cf);
         current->backing_dev_info = NULL;
@@ -1162,7 +1162,7 @@ static loff_t ceph_llseek(struct file *file, loff_t offset, int whence)
         struct inode *inode = file->f_mapping->host;
         int ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (whence == SEEK_END || whence == SEEK_DATA || whence == SEEK_HOLE) {
                 ret = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE, false);
@@ -1207,7 +1207,7 @@ static loff_t ceph_llseek(struct file *file, loff_t offset, int whence)
         offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return offset;
 }
 
@@ -1363,7 +1363,7 @@ static long ceph_fallocate(struct file *file, int mode,
         if (!prealloc_cf)
                 return -ENOMEM;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (ceph_snap(inode) != CEPH_NOSNAP) {
                 ret = -EROFS;
@@ -1418,7 +1418,7 @@ static long ceph_fallocate(struct file *file, int mode,
 
         ceph_put_cap_refs(ci, got);
 unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         ceph_free_cap_flush(prealloc_cf);
         return ret;
 }
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index c4c1169814b2..e24ca79b140c 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -640,9 +640,9 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
                 while (*s && *s != sep)
                         s++;
 
-                mutex_lock(&dir->i_mutex);
+                inode_lock(dir);
                 child = lookup_one_len(p, dentry, s - p);
-                mutex_unlock(&dir->i_mutex);
+                inode_unlock(dir);
                 dput(dentry);
                 dentry = child;
         } while (!IS_ERR(dentry));
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 0a2752b79e72..ff882aeaccc6 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2267,7 +2267,7 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (rc)
                 return rc;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         xid = get_xid();
 
@@ -2292,7 +2292,7 @@ int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
         }
 
         free_xid(xid);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return rc;
 }
 
@@ -2309,7 +2309,7 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (rc)
                 return rc;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         xid = get_xid();
 
@@ -2326,7 +2326,7 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         }
 
         free_xid(xid);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return rc;
 }
 
@@ -2672,7 +2672,7 @@ cifs_writev(struct kiocb *iocb, struct iov_iter *from)
          * with a brlock that prevents writing.
          */
         down_read(&cinode->lock_sem);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         rc = generic_write_checks(iocb, from);
         if (rc <= 0)
@@ -2685,7 +2685,7 @@ cifs_writev(struct kiocb *iocb, struct iov_iter *from)
         else
                 rc = -EACCES;
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (rc > 0) {
                 ssize_t err = generic_write_sync(file, iocb->ki_pos - rc, rc);
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index fda9f4311212..42e731b8c80a 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -427,13 +427,13 @@ static int coda_readdir(struct file *coda_file, struct dir_context *ctx)
         if (host_file->f_op->iterate) {
                 struct inode *host_inode = file_inode(host_file);
 
-                mutex_lock(&host_inode->i_mutex);
+                inode_lock(host_inode);
                 ret = -ENOENT;
                 if (!IS_DEADDIR(host_inode)) {
                         ret = host_file->f_op->iterate(host_file, ctx);
                         file_accessed(host_file);
                 }
-                mutex_unlock(&host_inode->i_mutex);
+                inode_unlock(host_inode);
                 return ret;
         }
         /* Venus: we must read Venus dirents from a file */
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 1da3805f3ddc..f47c7483863b 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -71,12 +71,12 @@ coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
 
         host_file = cfi->cfi_container;
         file_start_write(host_file);
-        mutex_lock(&coda_inode->i_mutex);
+        inode_lock(coda_inode);
         ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos);
         coda_inode->i_size = file_inode(host_file)->i_size;
         coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9;
         coda_inode->i_mtime = coda_inode->i_ctime = CURRENT_TIME_SEC;
-        mutex_unlock(&coda_inode->i_mutex);
+        inode_unlock(coda_inode);
         file_end_write(host_file);
         return ret;
 }
@@ -203,7 +203,7 @@ int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync)
         err = filemap_write_and_wait_range(coda_inode->i_mapping, start, end);
         if (err)
                 return err;
-        mutex_lock(&coda_inode->i_mutex);
+        inode_lock(coda_inode);
 
         cfi = CODA_FTOC(coda_file);
         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
@@ -212,7 +212,7 @@ int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync)
         err = vfs_fsync(host_file, datasync);
         if (!err && !datasync)
                 err = venus_fsync(coda_inode->i_sb, coda_i2f(coda_inode));
-        mutex_unlock(&coda_inode->i_mutex);
+        inode_unlock(coda_inode);
 
         return err;
 }
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index cab612b2ae76..f419519ec41f 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -640,13 +640,13 @@ static void detach_groups(struct config_group *group)
 
                 child = sd->s_dentry;
 
-                mutex_lock(&d_inode(child)->i_mutex);
+                inode_lock(d_inode(child));
 
                 configfs_detach_group(sd->s_element);
                 d_inode(child)->i_flags |= S_DEAD;
                 dont_mount(child);
 
-                mutex_unlock(&d_inode(child)->i_mutex);
+                inode_unlock(d_inode(child));
 
                 d_delete(child);
                 dput(child);
@@ -834,11 +834,11 @@ static int configfs_attach_item(struct config_item *parent_item,
                          * the VFS may already have hit and used them. Thus,
                          * we must lock them as rmdir() would.
                          */
-                        mutex_lock(&d_inode(dentry)->i_mutex);
+                        inode_lock(d_inode(dentry));
                         configfs_remove_dir(item);
                         d_inode(dentry)->i_flags |= S_DEAD;
                         dont_mount(dentry);
-                        mutex_unlock(&d_inode(dentry)->i_mutex);
+                        inode_unlock(d_inode(dentry));
                         d_delete(dentry);
                 }
         }
@@ -874,7 +874,7 @@ static int configfs_attach_group(struct config_item *parent_item,
                  * We must also lock the inode to remove it safely in case of
                  * error, as rmdir() would.
                  */
-                mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
                 configfs_adjust_dir_dirent_depth_before_populate(sd);
                 ret = populate_groups(to_config_group(item));
                 if (ret) {
@@ -883,7 +883,7 @@ static int configfs_attach_group(struct config_item *parent_item,
                         dont_mount(dentry);
                 }
                 configfs_adjust_dir_dirent_depth_after_populate(sd);
-                mutex_unlock(&d_inode(dentry)->i_mutex);
+                inode_unlock(d_inode(dentry));
                 if (ret)
                         d_delete(dentry);
         }
@@ -1135,7 +1135,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
          * subsystem is really registered, and so we need to lock out
          * configfs_[un]register_subsystem().
          */
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
 
         subsys_sd = configfs_find_subsys_dentry(root->d_fsdata, s_item);
         if (!subsys_sd) {
@@ -1147,7 +1147,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
         ret = configfs_do_depend_item(subsys_sd->s_dentry, target);
 
 out_unlock_fs:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 
         /*
          * If we succeeded, the fs is pinned via other methods.  If not,
@@ -1230,7 +1230,7 @@ int configfs_depend_item_unlocked(struct configfs_subsystem *caller_subsys,
                  * additional locking to prevent other subsystem from being
                  * unregistered
                  */
-                mutex_lock(&d_inode(root->cg_item.ci_dentry)->i_mutex);
+                inode_lock(d_inode(root->cg_item.ci_dentry));
 
                 /*
                  * As we are trying to depend item from other subsystem
@@ -1254,7 +1254,7 @@ out_root_unlock:
                  * We were called from subsystem other than our target so we
                  * took some locks so now it's time to release them
                  */
-                mutex_unlock(&d_inode(root->cg_item.ci_dentry)->i_mutex);
+                inode_unlock(d_inode(root->cg_item.ci_dentry));
 
         return ret;
 }
@@ -1561,7 +1561,7 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
         down_write(&configfs_rename_sem);
         parent = item->parent->dentry;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
 
         new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
         if (!IS_ERR(new_dentry)) {
@@ -1577,7 +1577,7 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
                         error = -EEXIST;
                 dput(new_dentry);
         }
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         up_write(&configfs_rename_sem);
 
         return error;
@@ -1590,7 +1590,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
         struct configfs_dirent * parent_sd = dentry->d_fsdata;
         int err;
 
-        mutex_lock(&d_inode(dentry)->i_mutex);
+        inode_lock(d_inode(dentry));
         /*
          * Fake invisibility if dir belongs to a group/default groups hierarchy
          * being attached
@@ -1603,7 +1603,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
                 else
                         err = 0;
         }
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
 
         return err;
 }
@@ -1613,11 +1613,11 @@ static int configfs_dir_close(struct inode *inode, struct file *file)
         struct dentry * dentry = file->f_path.dentry;
         struct configfs_dirent * cursor = file->private_data;
 
-        mutex_lock(&d_inode(dentry)->i_mutex);
+        inode_lock(d_inode(dentry));
         spin_lock(&configfs_dirent_lock);
         list_del_init(&cursor->s_sibling);
         spin_unlock(&configfs_dirent_lock);
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
 
         release_configfs_dirent(cursor);
 
@@ -1698,7 +1698,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry * dentry = file->f_path.dentry;
 
-        mutex_lock(&d_inode(dentry)->i_mutex);
+        inode_lock(d_inode(dentry));
         switch (whence) {
                 case 1:
                         offset += file->f_pos;
@@ -1706,7 +1706,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&d_inode(dentry)->i_mutex);
+                        inode_unlock(d_inode(dentry));
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -1732,7 +1732,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                         spin_unlock(&configfs_dirent_lock);
                 }
         }
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
         return offset;
 }
 
@@ -1767,14 +1767,14 @@ int configfs_register_group(struct config_group *parent_group,
 
         parent = parent_group->cg_item.ci_dentry;
 
-        mutex_lock_nested(&d_inode(parent)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
         ret = create_default_group(parent_group, group);
         if (!ret) {
                 spin_lock(&configfs_dirent_lock);
                 configfs_dir_set_ready(group->cg_item.ci_dentry->d_fsdata);
                 spin_unlock(&configfs_dirent_lock);
         }
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         return ret;
 }
 EXPORT_SYMBOL(configfs_register_group);
@@ -1791,7 +1791,7 @@ void configfs_unregister_group(struct config_group *group)
         struct dentry *dentry = group->cg_item.ci_dentry;
         struct dentry *parent = group->cg_item.ci_parent->ci_dentry;
 
-        mutex_lock_nested(&d_inode(parent)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
         spin_lock(&configfs_dirent_lock);
         configfs_detach_prep(dentry, NULL);
         spin_unlock(&configfs_dirent_lock);
@@ -1800,7 +1800,7 @@ void configfs_unregister_group(struct config_group *group)
         d_inode(dentry)->i_flags |= S_DEAD;
         dont_mount(dentry);
         d_delete(dentry);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 
         dput(dentry);
 
@@ -1872,7 +1872,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
         sd = root->d_fsdata;
         link_group(to_config_group(sd->s_element), group);
 
-        mutex_lock_nested(&d_inode(root)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(root), I_MUTEX_PARENT);
 
         err = -ENOMEM;
         dentry = d_alloc_name(root, group->cg_item.ci_name);
@@ -1892,7 +1892,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
                 }
         }
 
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 
         if (err) {
                 unlink_group(group);
@@ -1913,9 +1913,9 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
                 return;
         }
 
-        mutex_lock_nested(&d_inode(root)->i_mutex,
+        inode_lock_nested(d_inode(root),
                           I_MUTEX_PARENT);
-        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
         mutex_lock(&configfs_symlink_mutex);
         spin_lock(&configfs_dirent_lock);
         if (configfs_detach_prep(dentry, NULL)) {
@@ -1926,11 +1926,11 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
         configfs_detach_group(&group->cg_item);
         d_inode(dentry)->i_flags |= S_DEAD;
         dont_mount(dentry);
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
 
         d_delete(dentry);
 
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 
         dput(dentry);
 
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index 3687187c8ea5..33b7ee34eda5 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -540,10 +540,10 @@ int configfs_create_file(struct config_item * item, const struct configfs_attrib
         umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
         int error = 0;
 
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_NORMAL);
+        inode_lock_nested(d_inode(dir), I_MUTEX_NORMAL);
         error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode,
                                      CONFIGFS_ITEM_ATTR);
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 
         return error;
 }
@@ -562,10 +562,10 @@ int configfs_create_bin_file(struct config_item *item,
         umode_t mode = (bin_attr->cb_attr.ca_mode & S_IALLUGO) | S_IFREG;
         int error = 0;
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_NORMAL);
+        inode_lock_nested(dir->d_inode, I_MUTEX_NORMAL);
         error = configfs_make_dirent(parent_sd, NULL, (void *) bin_attr, mode,
                                      CONFIGFS_ITEM_BIN_ATTR);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        inode_unlock(dir->d_inode);
 
         return error;
 }
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 0cc810e9dccc..cee087d8f7e0 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -255,7 +255,7 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
                 /* no inode means this hasn't been made visible yet */
                 return;
 
-        mutex_lock(&d_inode(dir)->i_mutex);
+        inode_lock(d_inode(dir));
         list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
                 if (!sd->s_element)
                         continue;
@@ -268,5 +268,5 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
                         break;
                 }
         }
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 }
diff --git a/fs/dax.c b/fs/dax.c
index 7af879759064..55aa273145a8 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -248,10 +248,10 @@ ssize_t dax_do_io(struct kiocb *iocb, struct inode *inode,
 
         if ((flags & DIO_LOCKING) && iov_iter_rw(iter) == READ) {
                 struct address_space *mapping = inode->i_mapping;
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 retval = filemap_write_and_wait_range(mapping, pos, end - 1);
                 if (retval) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         goto out;
                 }
         }
@@ -263,7 +263,7 @@ ssize_t dax_do_io(struct kiocb *iocb, struct inode *inode,
         retval = dax_io(inode, iter, pos, end, get_block, &bh);
 
         if ((flags & DIO_LOCKING) && iov_iter_rw(iter) == READ)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         if ((retval > 0) && end_io)
                 end_io(iocb, pos, retval, bh.b_private);
diff --git a/fs/dcache.c b/fs/dcache.c
index b4539e84e577..92d5140de851 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -2462,7 +2462,7 @@ EXPORT_SYMBOL(d_rehash);
  */
 void dentry_update_name_case(struct dentry *dentry, struct qstr *name)
 {
-        BUG_ON(!mutex_is_locked(&dentry->d_parent->d_inode->i_mutex));
+        BUG_ON(!inode_is_locked(dentry->d_parent->d_inode));
         BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */
 
         spin_lock(&dentry->d_lock);
@@ -2738,7 +2738,7 @@ static int __d_unalias(struct inode *inode,
         if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex))
                 goto out_err;
         m1 = &dentry->d_sb->s_vfs_rename_mutex;
-        if (!mutex_trylock(&alias->d_parent->d_inode->i_mutex))
+        if (!inode_trylock(alias->d_parent->d_inode))
                 goto out_err;
         m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index b7fcc0de0b2f..bece948b363d 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -265,7 +265,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
         if (!parent)
                 parent = debugfs_mount->mnt_root;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
                 dput(dentry);
@@ -273,7 +273,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
         }
 
         if (IS_ERR(dentry)) {
-                mutex_unlock(&d_inode(parent)->i_mutex);
+                inode_unlock(d_inode(parent));
                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
         }
 
@@ -282,7 +282,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
 
 static struct dentry *failed_creating(struct dentry *dentry)
 {
-        mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
+        inode_unlock(d_inode(dentry->d_parent));
         dput(dentry);
         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
         return NULL;
@@ -290,7 +290,7 @@ static struct dentry *failed_creating(struct dentry *dentry)
 
 static struct dentry *end_creating(struct dentry *dentry)
 {
-        mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
+        inode_unlock(d_inode(dentry->d_parent));
         return dentry;
 }
 
@@ -560,9 +560,9 @@ void debugfs_remove(struct dentry *dentry)
         if (!parent || d_really_is_negative(parent))
                 return;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         ret = __debugfs_remove(dentry, parent);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         if (!ret)
                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
 }
@@ -594,7 +594,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
 
         parent = dentry;
  down:
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
  loop:
         /*
          * The parent->d_subdirs is protected by the d_lock. Outside that
@@ -609,7 +609,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
                 /* perhaps simple_empty(child) makes more sense */
                 if (!list_empty(&child->d_subdirs)) {
                         spin_unlock(&parent->d_lock);
-                        mutex_unlock(&d_inode(parent)->i_mutex);
+                        inode_unlock(d_inode(parent));
                         parent = child;
                         goto down;
                 }
@@ -630,10 +630,10 @@ void debugfs_remove_recursive(struct dentry *dentry)
         }
         spin_unlock(&parent->d_lock);
 
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         child = parent;
         parent = parent->d_parent;
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
 
         if (child != dentry)
                 /* go up */
@@ -641,7 +641,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
 
         if (!__debugfs_remove(child, parent))
                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
 }
 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
 
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index c35ffdc12bba..1f107fd51328 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -255,7 +255,7 @@ static int mknod_ptmx(struct super_block *sb)
         if (!uid_valid(root_uid) || !gid_valid(root_gid))
                 return -EINVAL;
 
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
 
         /* If we have already created ptmx node, return */
         if (fsi->ptmx_dentry) {
@@ -292,7 +292,7 @@ static int mknod_ptmx(struct super_block *sb)
         fsi->ptmx_dentry = dentry;
         rc = 0;
 out:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         return rc;
 }
 
@@ -615,7 +615,7 @@ struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
 
         sprintf(s, "%d", index);
 
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
 
         dentry = d_alloc_name(root, s);
         if (dentry) {
@@ -626,7 +626,7 @@ struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
                 inode = ERR_PTR(-ENOMEM);
         }
 
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 
         return inode;
 }
@@ -671,7 +671,7 @@ void devpts_pty_kill(struct inode *inode)
 
         BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
 
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
 
         dentry = d_find_alias(inode);
 
@@ -680,7 +680,7 @@ void devpts_pty_kill(struct inode *inode)
         dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
         dput(dentry);           /* d_find_alias above */
 
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 }
 
 static int __init init_devpts_fs(void)
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 602e8441bc0f..1b2f7ffc8b84 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1157,12 +1157,12 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
                                         iocb->ki_filp->f_mapping;
 
                         /* will be released by direct_io_worker */
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
 
                         retval = filemap_write_and_wait_range(mapping, offset,
                                                               end - 1);
                         if (retval) {
-                                mutex_unlock(&inode->i_mutex);
+                                inode_unlock(inode);
                                 kmem_cache_free(dio_cache, dio);
                                 goto out;
                         }
@@ -1173,7 +1173,7 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
         dio->i_size = i_size_read(inode);
         if (iov_iter_rw(iter) == READ && offset >= dio->i_size) {
                 if (dio->flags & DIO_LOCKING)
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                 kmem_cache_free(dio_cache, dio);
                 retval = 0;
                 goto out;
@@ -1295,7 +1295,7 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
          * of protecting us from looking up uninitialized blocks.
          */
         if (iov_iter_rw(iter) == READ && (dio->flags & DIO_LOCKING))
-                mutex_unlock(&dio->inode->i_mutex);
+                inode_unlock(dio->inode);
 
         /*
          * The only time we want to leave bios in flight is when a successful
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 040aa879d634..4e685ac1024d 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -41,13 +41,13 @@ static struct dentry *lock_parent(struct dentry *dentry)
         struct dentry *dir;
 
         dir = dget_parent(dentry);
-        mutex_lock_nested(&(d_inode(dir)->i_mutex), I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
         return dir;
 }
 
 static void unlock_dir(struct dentry *dir)
 {
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         dput(dir);
 }
 
@@ -397,11 +397,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
         int rc = 0;
 
         lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
-        mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dir_dentry));
         lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name,
                                       lower_dir_dentry,
                                       ecryptfs_dentry->d_name.len);
-        mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dir_dentry));
         if (IS_ERR(lower_dentry)) {
                 rc = PTR_ERR(lower_dentry);
                 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -426,11 +426,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                        "filename; rc = [%d]\n", __func__, rc);
                 goto out;
         }
-        mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dir_dentry));
         lower_dentry = lookup_one_len(encrypted_and_encoded_name,
                                       lower_dir_dentry,
                                       encrypted_and_encoded_name_size);
-        mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dir_dentry));
         if (IS_ERR(lower_dentry)) {
                 rc = PTR_ERR(lower_dentry);
                 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -869,9 +869,9 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
         if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
                 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 
-                mutex_lock(&d_inode(lower_dentry)->i_mutex);
+                inode_lock(d_inode(lower_dentry));
                 rc = notify_change(lower_dentry, &lower_ia, NULL);
-                mutex_unlock(&d_inode(lower_dentry)->i_mutex);
+                inode_unlock(d_inode(lower_dentry));
         }
         return rc;
 }
@@ -970,9 +970,9 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
         if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
                 lower_ia.ia_valid &= ~ATTR_MODE;
 
-        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dentry));
         rc = notify_change(lower_dentry, &lower_ia, NULL);
-        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dentry));
 out:
         fsstack_copy_attr_all(inode, lower_inode);
         return rc;
@@ -1048,10 +1048,10 @@ ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dentry));
         rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value,
                                                    size);
-        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dentry));
 out:
         return rc;
 }
@@ -1075,9 +1075,9 @@ ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dentry));
         rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
-        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dentry));
 out:
         return rc;
 }
@@ -1092,9 +1092,9 @@ static int ecryptfs_removexattr(struct dentry *dentry, const char *name)
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        inode_lock(d_inode(lower_dentry));
         rc = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name);
-        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
+        inode_unlock(d_inode(lower_dentry));
 out:
         return rc;
 }
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index caba848ac763..c6ced4cbf0cf 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -436,7 +436,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
                 rc = -ENOMEM;
                 goto out;
         }
-        mutex_lock(&lower_inode->i_mutex);
+        inode_lock(lower_inode);
         size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
                                            xattr_virt, PAGE_CACHE_SIZE);
         if (size < 0)
@@ -444,7 +444,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
         put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
         rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
                                          xattr_virt, size, 0);
-        mutex_unlock(&lower_inode->i_mutex);
+        inode_unlock(lower_inode);
         if (rc)
                 printk(KERN_ERR "Error whilst attempting to write inode size "
                        "to lower file xattr; rc = [%d]\n", rc);
diff --git a/fs/efivarfs/file.c b/fs/efivarfs/file.c
index 90001da9abfd..c424e4813ec8 100644
--- a/fs/efivarfs/file.c
+++ b/fs/efivarfs/file.c
@@ -50,9 +50,9 @@ static ssize_t efivarfs_file_write(struct file *file,
                 d_delete(file->f_path.dentry);
                 dput(file->f_path.dentry);
         } else {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 i_size_write(inode, datasize + sizeof(attributes));
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         bytes = count;
diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c
index 86a2121828c3..b8a564f29107 100644
--- a/fs/efivarfs/super.c
+++ b/fs/efivarfs/super.c
@@ -160,10 +160,10 @@ static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
         efivar_entry_size(entry, &size);
         efivar_entry_add(entry, &efivarfs_list);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         inode->i_private = entry;
         i_size_write(inode, size + sizeof(entry->var.Attributes));
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         d_add(dentry, inode);
 
         return 0;
diff --git a/fs/exec.c b/fs/exec.c
index 828ec5f07de0..dcd4ac7d3f1e 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1307,13 +1307,13 @@ static void bprm_fill_uid(struct linux_binprm *bprm)
                 return;
 
         /* Be careful if suid/sgid is set */
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* reload atomically mode/uid/gid now that lock held */
         mode = inode->i_mode;
         uid = inode->i_uid;
         gid = inode->i_gid;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         /* We ignore suid/sgid if there are no mappings for them in the ns */
         if (!kuid_has_mapping(bprm->cred->user_ns, uid) ||
diff --git a/fs/exofs/file.c b/fs/exofs/file.c
index 906de66e8e7e..28645f0640f7 100644
--- a/fs/exofs/file.c
+++ b/fs/exofs/file.c
@@ -52,9 +52,9 @@ static int exofs_file_fsync(struct file *filp, loff_t start, loff_t end,
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = sync_inode_metadata(filp->f_mapping->host, 1);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 714cd37a6ba3..c46f1a190b8d 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -124,10 +124,10 @@ static struct dentry *reconnect_one(struct vfsmount *mnt,
         int err;
 
         parent = ERR_PTR(-EACCES);
-        mutex_lock(&dentry->d_inode->i_mutex);
+        inode_lock(dentry->d_inode);
         if (mnt->mnt_sb->s_export_op->get_parent)
                 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        inode_unlock(dentry->d_inode);
 
         if (IS_ERR(parent)) {
                 dprintk("%s: get_parent of %ld failed, err %d\n",
@@ -143,9 +143,9 @@ static struct dentry *reconnect_one(struct vfsmount *mnt,
         if (err)
                 goto out_err;
         dprintk("%s: found name: %s\n", __func__, nbuf);
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
         tmp = lookup_one_len(nbuf, parent, strlen(nbuf));
-        mutex_unlock(&parent->d_inode->i_mutex);
+        inode_unlock(parent->d_inode);
         if (IS_ERR(tmp)) {
                 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
                 goto out_err;
@@ -503,10 +503,10 @@ struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
                  */
                 err = exportfs_get_name(mnt, target_dir, nbuf, result);
                 if (!err) {
-                        mutex_lock(&target_dir->d_inode->i_mutex);
+                        inode_lock(target_dir->d_inode);
                         nresult = lookup_one_len(nbuf, target_dir,
                                                  strlen(nbuf));
-                        mutex_unlock(&target_dir->d_inode->i_mutex);
+                        inode_unlock(target_dir->d_inode);
                         if (!IS_ERR(nresult)) {
                                 if (nresult->d_inode) {
                                         dput(result);
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index 5d46c09863f0..b386af2e45f4 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -51,10 +51,10 @@ long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
                 flags = ext2_mask_flags(inode->i_mode, flags);
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 /* Is it quota file? Do not allow user to mess with it */
                 if (IS_NOQUOTA(inode)) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         ret = -EPERM;
                         goto setflags_out;
                 }
@@ -68,7 +68,7 @@ long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                  */
                 if ((flags ^ oldflags) & (EXT2_APPEND_FL | EXT2_IMMUTABLE_FL)) {
                         if (!capable(CAP_LINUX_IMMUTABLE)) {
-                                mutex_unlock(&inode->i_mutex);
+                                inode_unlock(inode);
                                 ret = -EPERM;
                                 goto setflags_out;
                         }
@@ -80,7 +80,7 @@ long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
                 ext2_set_inode_flags(inode);
                 inode->i_ctime = CURRENT_TIME_SEC;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 mark_inode_dirty(inode);
 setflags_out:
@@ -102,10 +102,10 @@ setflags_out:
                         goto setversion_out;
                 }
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 inode->i_ctime = CURRENT_TIME_SEC;
                 inode->i_generation = generation;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 mark_inode_dirty(inode);
 setversion_out:
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 1c127213363a..0662b285dc8a 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2896,7 +2896,7 @@ do {								\
 static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
 {
         WARN_ON_ONCE(S_ISREG(inode->i_mode) &&
-                     !mutex_is_locked(&inode->i_mutex));
+                     !inode_is_locked(inode));
         down_write(&EXT4_I(inode)->i_data_sem);
         if (newsize > EXT4_I(inode)->i_disksize)
                 EXT4_I(inode)->i_disksize = newsize;
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index b52fea3b7219..0ffabaf90aa5 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4799,7 +4799,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
         else
                 max_blocks -= lblk;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * Indirect files do not support unwritten extnets
@@ -4902,7 +4902,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
 out_dio:
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
@@ -4973,7 +4973,7 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
         if (mode & FALLOC_FL_KEEP_SIZE)
                 flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * We only support preallocation for extent-based files only
@@ -5006,7 +5006,7 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
                                                 EXT4_I(inode)->i_sync_tid);
         }
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         trace_ext4_fallocate_exit(inode, offset, max_blocks, ret);
         return ret;
 }
@@ -5492,7 +5492,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
                         return ret;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /*
          * There is no need to overlap collapse range with EOF, in which case
          * it is effectively a truncate operation
@@ -5587,7 +5587,7 @@ out_mmap:
         up_write(&EXT4_I(inode)->i_mmap_sem);
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
@@ -5638,7 +5638,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
                         return ret;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* Currently just for extent based files */
         if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
                 ret = -EOPNOTSUPP;
@@ -5757,7 +5757,7 @@ out_mmap:
         up_write(&EXT4_I(inode)->i_mmap_sem);
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
@@ -5792,8 +5792,8 @@ ext4_swap_extents(handle_t *handle, struct inode *inode1,
 
         BUG_ON(!rwsem_is_locked(&EXT4_I(inode1)->i_data_sem));
         BUG_ON(!rwsem_is_locked(&EXT4_I(inode2)->i_data_sem));
-        BUG_ON(!mutex_is_locked(&inode1->i_mutex));
-        BUG_ON(!mutex_is_locked(&inode2->i_mutex));
+        BUG_ON(!inode_is_locked(inode1));
+        BUG_ON(!inode_is_locked(inode2));
 
         *erp = ext4_es_remove_extent(inode1, lblk1, count);
         if (unlikely(*erp))
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 749b222e6498..8eb87e3e2752 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -113,7 +113,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                 ext4_unwritten_wait(inode);
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = generic_write_checks(iocb, from);
         if (ret <= 0)
                 goto out;
@@ -169,7 +169,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         }
 
         ret = __generic_file_write_iter(iocb, from);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (ret > 0) {
                 ssize_t err;
@@ -186,7 +186,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         return ret;
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (aio_mutex)
                 mutex_unlock(aio_mutex);
         return ret;
@@ -561,11 +561,11 @@ static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
         int blkbits;
         int ret = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         isize = i_size_read(inode);
         if (offset >= isize) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return -ENXIO;
         }
 
@@ -613,7 +613,7 @@ static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize)
                 dataoff = (loff_t)last << blkbits;
         } while (last <= end);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (dataoff > isize)
                 return -ENXIO;
@@ -634,11 +634,11 @@ static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
         int blkbits;
         int ret = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         isize = i_size_read(inode);
         if (offset >= isize) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return -ENXIO;
         }
 
@@ -689,7 +689,7 @@ static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize)
                 break;
         } while (last <= end);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (holeoff > isize)
                 holeoff = isize;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index d964195ea0e2..83bc8bfb3bea 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3231,7 +3231,7 @@ static ssize_t ext4_ext_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
         overwrite = *((int *)iocb->private);
 
         if (overwrite)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         /*
          * We could direct write to holes and fallocate.
@@ -3331,7 +3331,7 @@ retake_lock:
                 inode_dio_end(inode);
         /* take i_mutex locking again if we do a ovewrite dio */
         if (overwrite)
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
 
         return ret;
 }
@@ -3653,7 +3653,7 @@ int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
         handle_t *handle;
         loff_t size = i_size_read(inode);
 
-        WARN_ON(!mutex_is_locked(&inode->i_mutex));
+        WARN_ON(!inode_is_locked(inode));
         if (offset > size || offset + len < size)
                 return 0;
 
@@ -3707,7 +3707,7 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
                         return ret;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* No need to punch hole beyond i_size */
         if (offset >= inode->i_size)
@@ -3809,7 +3809,7 @@ out_dio:
         up_write(&EXT4_I(inode)->i_mmap_sem);
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
@@ -3879,7 +3879,7 @@ void ext4_truncate(struct inode *inode)
          * have i_mutex locked because it's not necessary.
          */
         if (!(inode->i_state & (I_NEW|I_FREEING)))
-                WARN_ON(!mutex_is_locked(&inode->i_mutex));
+                WARN_ON(!inode_is_locked(inode));
         trace_ext4_truncate_enter(inode);
 
         if (!ext4_can_truncate(inode))
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 2b0cb84255eb..0f6c36922c24 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -330,7 +330,7 @@ static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
                 return err;
 
         err = -EPERM;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* Is it quota file? Do not allow user to mess with it */
         if (IS_NOQUOTA(inode))
                 goto out_unlock;
@@ -381,7 +381,7 @@ out_dirty:
 out_stop:
         ext4_journal_stop(handle);
 out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         mnt_drop_write_file(filp);
         return err;
 }
@@ -464,9 +464,9 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
                 flags = ext4_mask_flags(inode->i_mode, flags);
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 err = ext4_ioctl_setflags(inode, flags);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 mnt_drop_write_file(filp);
                 return err;
         }
@@ -497,7 +497,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                         goto setversion_out;
                 }
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
                 if (IS_ERR(handle)) {
                         err = PTR_ERR(handle);
@@ -512,7 +512,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 ext4_journal_stop(handle);
 
 unlock_out:
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 setversion_out:
                 mnt_drop_write_file(filp);
                 return err;
@@ -658,9 +658,9 @@ group_add_out:
                  * ext4_ext_swap_inode_data before we switch the
                  * inode format to prevent read.
                  */
-                mutex_lock(&(inode->i_mutex));
+                inode_lock((inode));
                 err = ext4_ext_migrate(inode);
-                mutex_unlock(&(inode->i_mutex));
+                inode_unlock((inode));
                 mnt_drop_write_file(filp);
                 return err;
         }
@@ -876,11 +876,11 @@ encryption_policy_out:
                 flags = ext4_xflags_to_iflags(fa.fsx_xflags);
                 flags = ext4_mask_flags(inode->i_mode, flags);
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
                          (flags & EXT4_FL_XFLAG_VISIBLE);
                 err = ext4_ioctl_setflags(inode, flags);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 mnt_drop_write_file(filp);
                 if (err)
                         return err;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 854f75de4599..06574dd77614 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2753,7 +2753,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
                 return 0;
 
         WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
-                     !mutex_is_locked(&inode->i_mutex));
+                     !inode_is_locked(inode));
         /*
          * Exit early if inode already is on orphan list. This is a big speedup
          * since we don't have to contend on the global s_orphan_lock.
@@ -2835,7 +2835,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode)
                 return 0;
 
         WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
-                     !mutex_is_locked(&inode->i_mutex));
+                     !inode_is_locked(inode));
         /* Do this quick check before taking global s_orphan_lock. */
         if (list_empty(&ei->i_orphan))
                 return 0;
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 00c98fab6333..3ed01ec011d7 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -2286,10 +2286,10 @@ static void ext4_orphan_cleanup(struct super_block *sb,
                                         __func__, inode->i_ino, inode->i_size);
                         jbd_debug(2, "truncating inode %lu to %lld bytes\n",
                                   inode->i_ino, inode->i_size);
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                         truncate_inode_pages(inode->i_mapping, inode->i_size);
                         ext4_truncate(inode);
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         nr_truncates++;
                 } else {
                         if (test_opt(sb, DEBUG))
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ac9e7c6aac74..5c06db17e41f 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -794,7 +794,7 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                         return ret;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         isize = i_size_read(inode);
         if (start >= isize)
@@ -860,7 +860,7 @@ out:
         if (ret == 1)
                 ret = 0;
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 18ddb1e5182a..ea272be62677 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -333,7 +333,7 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
         loff_t isize;
         int err = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         isize = i_size_read(inode);
         if (offset >= isize)
@@ -388,10 +388,10 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
 found:
         if (whence == SEEK_HOLE && data_ofs > isize)
                 data_ofs = isize;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return vfs_setpos(file, data_ofs, maxbytes);
 fail:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return -ENXIO;
 }
 
@@ -1219,7 +1219,7 @@ static long f2fs_fallocate(struct file *file, int mode,
                         FALLOC_FL_INSERT_RANGE))
                 return -EOPNOTSUPP;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (mode & FALLOC_FL_PUNCH_HOLE) {
                 if (offset >= inode->i_size)
@@ -1243,7 +1243,7 @@ static long f2fs_fallocate(struct file *file, int mode,
         }
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         trace_f2fs_fallocate(inode, mode, offset, len, ret);
         return ret;
@@ -1307,13 +1307,13 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
 
         flags = f2fs_mask_flags(inode->i_mode, flags);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         oldflags = fi->i_flags;
 
         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
                 if (!capable(CAP_LINUX_IMMUTABLE)) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         ret = -EPERM;
                         goto out;
                 }
@@ -1322,7 +1322,7 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
         flags = flags & FS_FL_USER_MODIFIABLE;
         flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
         fi->i_flags = flags;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         f2fs_set_inode_flags(inode);
         inode->i_ctime = CURRENT_TIME;
@@ -1667,7 +1667,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
 
         f2fs_balance_fs(sbi, true);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* writeback all dirty pages in the range */
         err = filemap_write_and_wait_range(inode->i_mapping, range->start,
@@ -1778,7 +1778,7 @@ do_map:
 clear_out:
         clear_inode_flag(F2FS_I(inode), FI_DO_DEFRAG);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (!err)
                 range->len = (u64)total << PAGE_CACHE_SHIFT;
         return err;
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 7def96caec5f..d0b95c95079b 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -769,7 +769,7 @@ static int fat_ioctl_readdir(struct inode *inode, struct file *file,
 
         buf.dirent = dirent;
         buf.result = 0;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         buf.ctx.pos = file->f_pos;
         ret = -ENOENT;
         if (!IS_DEADDIR(inode)) {
@@ -777,7 +777,7 @@ static int fat_ioctl_readdir(struct inode *inode, struct file *file,
                                     short_only, both ? &buf : NULL);
                 file->f_pos = buf.ctx.pos;
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (ret >= 0)
                 ret = buf.result;
         return ret;
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 43d3475da83a..f70185668832 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -24,9 +24,9 @@ static int fat_ioctl_get_attributes(struct inode *inode, u32 __user *user_attr)
 {
         u32 attr;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         attr = fat_make_attrs(inode);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return put_user(attr, user_attr);
 }
@@ -47,7 +47,7 @@ static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
         err = mnt_want_write_file(file);
         if (err)
                 goto out;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * ATTR_VOLUME and ATTR_DIR cannot be changed; this also
@@ -109,7 +109,7 @@ static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
         fat_save_attrs(inode, attr);
         mark_inode_dirty(inode);
 out_unlock_inode:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         mnt_drop_write_file(file);
 out:
         return err;
@@ -246,7 +246,7 @@ static long fat_fallocate(struct file *file, int mode,
         if (!S_ISREG(inode->i_mode))
                 return -EOPNOTSUPP;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         if (mode & FALLOC_FL_KEEP_SIZE) {
                 ondisksize = inode->i_blocks << 9;
                 if ((offset + len) <= ondisksize)
@@ -272,7 +272,7 @@ static long fat_fallocate(struct file *file, int mode,
         }
 
 error:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 712601f299b8..4b855b65d457 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -944,7 +944,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
         if (!parent)
                 return -ENOENT;
 
-        mutex_lock(&parent->i_mutex);
+        inode_lock(parent);
         if (!S_ISDIR(parent->i_mode))
                 goto unlock;
 
@@ -962,7 +962,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
         fuse_invalidate_entry(entry);
 
         if (child_nodeid != 0 && d_really_is_positive(entry)) {
-                mutex_lock(&d_inode(entry)->i_mutex);
+                inode_lock(d_inode(entry));
                 if (get_node_id(d_inode(entry)) != child_nodeid) {
                         err = -ENOENT;
                         goto badentry;
@@ -983,7 +983,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
                 clear_nlink(d_inode(entry));
                 err = 0;
  badentry:
-                mutex_unlock(&d_inode(entry)->i_mutex);
+                inode_unlock(d_inode(entry));
                 if (!err)
                         d_delete(entry);
         } else {
@@ -992,7 +992,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
         dput(entry);
 
  unlock:
-        mutex_unlock(&parent->i_mutex);
+        inode_unlock(parent);
         iput(parent);
         return err;
 }
@@ -1504,7 +1504,7 @@ void fuse_set_nowrite(struct inode *inode)
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_inode *fi = get_fuse_inode(inode);
 
-        BUG_ON(!mutex_is_locked(&inode->i_mutex));
+        BUG_ON(!inode_is_locked(inode));
 
         spin_lock(&fc->lock);
         BUG_ON(fi->writectr < 0);
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index aa03aab6a24f..b03d253ece15 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -207,7 +207,7 @@ int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
                 return err;
 
         if (lock_inode)
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
 
         err = fuse_do_open(fc, get_node_id(inode), file, isdir);
 
@@ -215,7 +215,7 @@ int fuse_open_common(struct inode *inode, struct file *file, bool isdir)
                 fuse_finish_open(inode, file);
 
         if (lock_inode)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         return err;
 }
@@ -413,9 +413,9 @@ static int fuse_flush(struct file *file, fl_owner_t id)
         if (err)
                 return err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         fuse_sync_writes(inode);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         req = fuse_get_req_nofail_nopages(fc, file);
         memset(&inarg, 0, sizeof(inarg));
@@ -450,7 +450,7 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
         if (is_bad_inode(inode))
                 return -EIO;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * Start writeback against all dirty pages of the inode, then
@@ -486,7 +486,7 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
                 err = 0;
         }
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
@@ -1160,7 +1160,7 @@ static ssize_t fuse_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                 return generic_file_write_iter(iocb, from);
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* We can write back this queue in page reclaim */
         current->backing_dev_info = inode_to_bdi(inode);
@@ -1210,7 +1210,7 @@ static ssize_t fuse_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         }
 out:
         current->backing_dev_info = NULL;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return written ? written : err;
 }
@@ -1322,10 +1322,10 @@ ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
 
         if (!cuse && fuse_range_is_writeback(inode, idx_from, idx_to)) {
                 if (!write)
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                 fuse_sync_writes(inode);
                 if (!write)
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
         }
 
         while (count) {
@@ -1413,14 +1413,14 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
                 return -EIO;
 
         /* Don't allow parallel writes to the same file */
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         res = generic_write_checks(iocb, from);
         if (res > 0)
                 res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
         fuse_invalidate_attr(inode);
         if (res > 0)
                 fuse_write_update_size(inode, iocb->ki_pos);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return res;
 }
@@ -2287,17 +2287,17 @@ static loff_t fuse_file_llseek(struct file *file, loff_t offset, int whence)
                 retval = generic_file_llseek(file, offset, whence);
                 break;
         case SEEK_END:
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 retval = fuse_update_attributes(inode, NULL, file, NULL);
                 if (!retval)
                         retval = generic_file_llseek(file, offset, whence);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 break;
         case SEEK_HOLE:
         case SEEK_DATA:
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 retval = fuse_lseek(file, offset, whence);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 break;
         default:
                 retval = -EINVAL;
@@ -2944,7 +2944,7 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,
                 return -EOPNOTSUPP;
 
         if (lock_inode) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (mode & FALLOC_FL_PUNCH_HOLE) {
                         loff_t endbyte = offset + length - 1;
                         err = filemap_write_and_wait_range(inode->i_mapping,
@@ -2990,7 +2990,7 @@ out:
                 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
 
         if (lock_inode)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
         return err;
 }
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 7412863cda1e..c9384f932975 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -914,7 +914,7 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t le
         if ((mode & ~FALLOC_FL_KEEP_SIZE) || gfs2_is_jdata(ip))
                 return -EOPNOTSUPP;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
         ret = gfs2_glock_nq(&gh);
@@ -946,7 +946,7 @@ out_unlock:
         gfs2_glock_dq(&gh);
 out_uninit:
         gfs2_holder_uninit(&gh);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 3e94400d587c..352f958769e1 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -2067,7 +2067,7 @@ static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
         if (ret)
@@ -2094,7 +2094,7 @@ static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 
         gfs2_glock_dq_uninit(&gh);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index be6d9c450b22..a39891344259 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -888,7 +888,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
                 return -ENOMEM;
 
         sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
-        mutex_lock(&ip->i_inode.i_mutex);
+        inode_lock(&ip->i_inode);
         for (qx = 0; qx < num_qd; qx++) {
                 error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
                                            GL_NOCACHE, &ghs[qx]);
@@ -953,7 +953,7 @@ out_alloc:
 out:
         while (qx--)
                 gfs2_glock_dq_uninit(&ghs[qx]);
-        mutex_unlock(&ip->i_inode.i_mutex);
+        inode_unlock(&ip->i_inode);
         kfree(ghs);
         gfs2_log_flush(ip->i_gl->gl_name.ln_sbd, ip->i_gl, NORMAL_FLUSH);
         return error;
@@ -1674,7 +1674,7 @@ static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,
         if (error)
                 goto out_put;
 
-        mutex_lock(&ip->i_inode.i_mutex);
+        inode_lock(&ip->i_inode);
         error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
         if (error)
                 goto out_unlockput;
@@ -1739,7 +1739,7 @@ out_i:
 out_q:
         gfs2_glock_dq_uninit(&q_gh);
 out_unlockput:
-        mutex_unlock(&ip->i_inode.i_mutex);
+        inode_unlock(&ip->i_inode);
 out_put:
         qd_put(qd);
         return error;
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 70788e03820a..e9f2b855f831 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -173,9 +173,9 @@ static int hfs_dir_release(struct inode *inode, struct file *file)
 {
         struct hfs_readdir_data *rd = file->private_data;
         if (rd) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 list_del(&rd->list);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 kfree(rd);
         }
         return 0;
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index b99ebddb10cb..6686bf39a5b5 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -570,13 +570,13 @@ static int hfs_file_release(struct inode *inode, struct file *file)
         if (HFS_IS_RSRC(inode))
                 inode = HFS_I(inode)->rsrc_inode;
         if (atomic_dec_and_test(&HFS_I(inode)->opencnt)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 hfs_file_truncate(inode);
                 //if (inode->i_flags & S_DEAD) {
                 //      hfs_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);
                 //      hfs_delete_inode(inode);
                 //}
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         return 0;
 }
@@ -656,7 +656,7 @@ static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
         ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (ret)
                 return ret;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* sync the inode to buffers */
         ret = write_inode_now(inode, 0);
@@ -668,7 +668,7 @@ static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
         err = sync_blockdev(sb->s_bdev);
         if (!ret)
                 ret = err;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index d0f39dcbb58e..a4e867e08947 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -284,9 +284,9 @@ static int hfsplus_dir_release(struct inode *inode, struct file *file)
 {
         struct hfsplus_readdir_data *rd = file->private_data;
         if (rd) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 list_del(&rd->list);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 kfree(rd);
         }
         return 0;
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 19b33f8151f1..1a6394cdb54e 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -229,14 +229,14 @@ static int hfsplus_file_release(struct inode *inode, struct file *file)
         if (HFSPLUS_IS_RSRC(inode))
                 inode = HFSPLUS_I(inode)->rsrc_inode;
         if (atomic_dec_and_test(&HFSPLUS_I(inode)->opencnt)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 hfsplus_file_truncate(inode);
                 if (inode->i_flags & S_DEAD) {
                         hfsplus_delete_cat(inode->i_ino,
                                            HFSPLUS_SB(sb)->hidden_dir, NULL);
                         hfsplus_delete_inode(inode);
                 }
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         return 0;
 }
@@ -286,7 +286,7 @@ int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
         error = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (error)
                 return error;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * Sync inode metadata into the catalog and extent trees.
@@ -327,7 +327,7 @@ int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
         if (!test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
                 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return error;
 }
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 0624ce4e0702..32a49e292b6a 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -93,7 +93,7 @@ static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
                 goto out_drop_write;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if ((flags & (FS_IMMUTABLE_FL|FS_APPEND_FL)) ||
             inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
@@ -126,7 +126,7 @@ static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
         mark_inode_dirty(inode);
 
 out_unlock_inode:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out_drop_write:
         mnt_drop_write_file(file);
 out:
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index cfaa18c7a337..d1abbee281d1 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -378,9 +378,9 @@ static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = fsync_file(HOSTFS_I(inode)->fd, datasync);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index dc540bfcee1d..e57a53c13d86 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -33,7 +33,7 @@ static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
         if (whence == SEEK_DATA || whence == SEEK_HOLE)
                 return -EINVAL;
 
-        mutex_lock(&i->i_mutex);
+        inode_lock(i);
         hpfs_lock(s);
 
         /*pr_info("dir lseek\n");*/
@@ -48,12 +48,12 @@ static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
 ok:
         filp->f_pos = new_off;
         hpfs_unlock(s);
-        mutex_unlock(&i->i_mutex);
+        inode_unlock(i);
         return new_off;
 fail:
         /*pr_warn("illegal lseek: %016llx\n", new_off);*/
         hpfs_unlock(s);
-        mutex_unlock(&i->i_mutex);
+        inode_unlock(i);
         return -ESPIPE;
 }
 
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 8bbf7f3e2a27..e1f465a389d5 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -141,7 +141,7 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 
         vma_len = (loff_t)(vma->vm_end - vma->vm_start);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         file_accessed(file);
 
         ret = -ENOMEM;
@@ -157,7 +157,7 @@ static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
         if (vma->vm_flags & VM_WRITE && inode->i_size < len)
                 inode->i_size = len;
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
@@ -530,7 +530,7 @@ static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
         if (hole_end > hole_start) {
                 struct address_space *mapping = inode->i_mapping;
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 i_mmap_lock_write(mapping);
                 if (!RB_EMPTY_ROOT(&mapping->i_mmap))
                         hugetlb_vmdelete_list(&mapping->i_mmap,
@@ -538,7 +538,7 @@ static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                                                 hole_end  >> PAGE_SHIFT);
                 i_mmap_unlock_write(mapping);
                 remove_inode_hugepages(inode, hole_start, hole_end);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         return 0;
@@ -572,7 +572,7 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset,
         start = offset >> hpage_shift;
         end = (offset + len + hpage_size - 1) >> hpage_shift;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* We need to check rlimit even when FALLOC_FL_KEEP_SIZE */
         error = inode_newsize_ok(inode, offset + len);
@@ -659,7 +659,7 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset,
                 i_size_write(inode, offset + len);
         inode->i_ctime = CURRENT_TIME;
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return error;
 }
 
diff --git a/fs/inode.c b/fs/inode.c
index e491e54d2430..bb8685220292 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -966,9 +966,9 @@ void lock_two_nondirectories(struct inode *inode1, struct inode *inode2)
                 swap(inode1, inode2);
 
         if (inode1 && !S_ISDIR(inode1->i_mode))
-                mutex_lock(&inode1->i_mutex);
+                inode_lock(inode1);
         if (inode2 && !S_ISDIR(inode2->i_mode) && inode2 != inode1)
-                mutex_lock_nested(&inode2->i_mutex, I_MUTEX_NONDIR2);
+                inode_lock_nested(inode2, I_MUTEX_NONDIR2);
 }
 EXPORT_SYMBOL(lock_two_nondirectories);
 
@@ -980,9 +980,9 @@ EXPORT_SYMBOL(lock_two_nondirectories);
 void unlock_two_nondirectories(struct inode *inode1, struct inode *inode2)
 {
         if (inode1 && !S_ISDIR(inode1->i_mode))
-                mutex_unlock(&inode1->i_mutex);
+                inode_unlock(inode1);
         if (inode2 && !S_ISDIR(inode2->i_mode) && inode2 != inode1)
-                mutex_unlock(&inode2->i_mutex);
+                inode_unlock(inode2);
 }
 EXPORT_SYMBOL(unlock_two_nondirectories);
 
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 29466c380958..116a333e9c77 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -434,9 +434,9 @@ int generic_block_fiemap(struct inode *inode,
                          u64 len, get_block_t *get_block)
 {
         int ret;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = __generic_block_fiemap(inode, fieinfo, start, len, get_block);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 EXPORT_SYMBOL(generic_block_fiemap);
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index f509f62e12f6..c5ac5944bc1b 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -39,10 +39,10 @@ int jffs2_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* Trigger GC to flush any pending writes for this inode */
         jffs2_flush_wbuf_gc(c, inode->i_ino);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return 0;
 }
diff --git a/fs/jfs/file.c b/fs/jfs/file.c
index 0e026a7bdcd4..4ce7735dd042 100644
--- a/fs/jfs/file.c
+++ b/fs/jfs/file.c
@@ -38,17 +38,17 @@ int jfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         if (rc)
                 return rc;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         if (!(inode->i_state & I_DIRTY_ALL) ||
             (datasync && !(inode->i_state & I_DIRTY_DATASYNC))) {
                 /* Make sure committed changes hit the disk */
                 jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return rc;
         }
 
         rc |= jfs_commit_inode(inode, 1);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return rc ? -EIO : 0;
 }
diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c
index 8db8b7d61e40..8653cac7e12e 100644
--- a/fs/jfs/ioctl.c
+++ b/fs/jfs/ioctl.c
@@ -96,7 +96,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 }
 
                 /* Lock against other parallel changes of flags */
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
 
                 jfs_get_inode_flags(jfs_inode);
                 oldflags = jfs_inode->mode2;
@@ -109,7 +109,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                         ((flags ^ oldflags) &
                         (JFS_APPEND_FL | JFS_IMMUTABLE_FL))) {
                         if (!capable(CAP_LINUX_IMMUTABLE)) {
-                                mutex_unlock(&inode->i_mutex);
+                                inode_unlock(inode);
                                 err = -EPERM;
                                 goto setflags_out;
                         }
@@ -120,7 +120,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 jfs_inode->mode2 = flags;
 
                 jfs_set_inode_flags(inode);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 inode->i_ctime = CURRENT_TIME_SEC;
                 mark_inode_dirty(inode);
 setflags_out:
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 900925b5eb8c..4f5d85ba8e23 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -792,7 +792,7 @@ static ssize_t jfs_quota_write(struct super_block *sb, int type,
         struct buffer_head tmp_bh;
         struct buffer_head *bh;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         while (towrite > 0) {
                 tocopy = sb->s_blocksize - offset < towrite ?
                                 sb->s_blocksize - offset : towrite;
@@ -824,7 +824,7 @@ static ssize_t jfs_quota_write(struct super_block *sb, int type,
         }
 out:
         if (len == towrite) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return err;
         }
         if (inode->i_size < off+len-towrite)
@@ -832,7 +832,7 @@ out:
         inode->i_version++;
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         mark_inode_dirty(inode);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return len - towrite;
 }
 
diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index 821973853340..996b7742c90b 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -1511,9 +1511,9 @@ static loff_t kernfs_dir_fop_llseek(struct file *file, loff_t offset,
         struct inode *inode = file_inode(file);
         loff_t ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = generic_file_llseek(file, offset, whence);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return ret;
 }
diff --git a/fs/libfs.c b/fs/libfs.c
index 01491299f348..0ca80b2af420 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -89,7 +89,7 @@ EXPORT_SYMBOL(dcache_dir_close);
 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry *dentry = file->f_path.dentry;
-        mutex_lock(&d_inode(dentry)->i_mutex);
+        inode_lock(d_inode(dentry));
         switch (whence) {
                 case 1:
                         offset += file->f_pos;
@@ -97,7 +97,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&d_inode(dentry)->i_mutex);
+                        inode_unlock(d_inode(dentry));
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -124,7 +124,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
                         spin_unlock(&dentry->d_lock);
                 }
         }
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
         return offset;
 }
 EXPORT_SYMBOL(dcache_dir_lseek);
@@ -941,7 +941,7 @@ int __generic_file_fsync(struct file *file, loff_t start, loff_t end,
         if (err)
                 return err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = sync_mapping_buffers(inode->i_mapping);
         if (!(inode->i_state & I_DIRTY_ALL))
                 goto out;
@@ -953,7 +953,7 @@ int __generic_file_fsync(struct file *file, loff_t start, loff_t end,
                 ret = err;
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 EXPORT_SYMBOL(__generic_file_fsync);
diff --git a/fs/locks.c b/fs/locks.c
index af1ed74a657f..7c5f91be9b65 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1650,12 +1650,12 @@ generic_add_lease(struct file *filp, long arg, struct file_lock **flp, void **pr
          * bother, maybe that's a sign this just isn't a good file to
          * hand out a delegation on.
          */
-        if (is_deleg && !mutex_trylock(&inode->i_mutex))
+        if (is_deleg && !inode_trylock(inode))
                 return -EAGAIN;
 
         if (is_deleg && arg == F_WRLCK) {
                 /* Write delegations are not currently supported: */
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 WARN_ON_ONCE(1);
                 return -EINVAL;
         }
@@ -1732,7 +1732,7 @@ out:
         spin_unlock(&ctx->flc_lock);
         locks_dispose_list(&dispose);
         if (is_deleg)
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         if (!error && !my_fl)
                 *flp = NULL;
         return error;
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index 1a6f0167b16a..61eaeb1b6cac 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -204,12 +204,12 @@ long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 if (err)
                         return err;
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 oldflags = li->li_flags;
                 flags &= LOGFS_FL_USER_MODIFIABLE;
                 flags |= oldflags & ~LOGFS_FL_USER_MODIFIABLE;
                 li->li_flags = flags;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 inode->i_ctime = CURRENT_TIME;
                 mark_inode_dirty_sync(inode);
@@ -230,11 +230,11 @@ int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         logfs_get_wblocks(sb, NULL, WF_LOCK);
         logfs_write_anchor(sb);
         logfs_put_wblocks(sb, NULL, WF_LOCK);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return 0;
 }
diff --git a/fs/namei.c b/fs/namei.c
index bceefd5588a2..f624d132e01e 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1629,9 +1629,9 @@ static int lookup_slow(struct nameidata *nd, struct path *path)
         parent = nd->path.dentry;
         BUG_ON(nd->inode != parent->d_inode);
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
         dentry = __lookup_hash(&nd->last, parent, nd->flags);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        inode_unlock(parent->d_inode);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
         path->mnt = nd->path.mnt;
@@ -2229,10 +2229,10 @@ struct dentry *kern_path_locked(const char *name, struct path *path)
                 putname(filename);
                 return ERR_PTR(-EINVAL);
         }
-        mutex_lock_nested(&path->dentry->d_inode->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
         d = __lookup_hash(&last, path->dentry, 0);
         if (IS_ERR(d)) {
-                mutex_unlock(&path->dentry->d_inode->i_mutex);
+                inode_unlock(path->dentry->d_inode);
                 path_put(path);
         }
         putname(filename);
@@ -2282,7 +2282,7 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
         unsigned int c;
         int err;
 
-        WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
+        WARN_ON_ONCE(!inode_is_locked(base->d_inode));
 
         this.name = name;
         this.len = len;
@@ -2380,9 +2380,9 @@ struct dentry *lookup_one_len_unlocked(const char *name,
         if (ret)
                 return ret;
 
-        mutex_lock(&base->d_inode->i_mutex);
+        inode_lock(base->d_inode);
         ret =  __lookup_hash(&this, base, 0);
-        mutex_unlock(&base->d_inode->i_mutex);
+        inode_unlock(base->d_inode);
         return ret;
 }
 EXPORT_SYMBOL(lookup_one_len_unlocked);
@@ -2463,7 +2463,7 @@ mountpoint_last(struct nameidata *nd, struct path *path)
                 goto done;
         }
 
-        mutex_lock(&dir->d_inode->i_mutex);
+        inode_lock(dir->d_inode);
         dentry = d_lookup(dir, &nd->last);
         if (!dentry) {
                 /*
@@ -2473,16 +2473,16 @@ mountpoint_last(struct nameidata *nd, struct path *path)
                  */
                 dentry = d_alloc(dir, &nd->last);
                 if (!dentry) {
-                        mutex_unlock(&dir->d_inode->i_mutex);
+                        inode_unlock(dir->d_inode);
                         return -ENOMEM;
                 }
                 dentry = lookup_real(dir->d_inode, dentry, nd->flags);
                 if (IS_ERR(dentry)) {
-                        mutex_unlock(&dir->d_inode->i_mutex);
+                        inode_unlock(dir->d_inode);
                         return PTR_ERR(dentry);
                 }
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
+        inode_unlock(dir->d_inode);
 
 done:
         if (d_is_negative(dentry)) {
@@ -2672,7 +2672,7 @@ struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
         struct dentry *p;
 
         if (p1 == p2) {
-                mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
+                inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
                 return NULL;
         }
 
@@ -2680,29 +2680,29 @@ struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
 
         p = d_ancestor(p2, p1);
         if (p) {
-                mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
-                mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
+                inode_lock_nested(p1->d_inode, I_MUTEX_CHILD);
                 return p;
         }
 
         p = d_ancestor(p1, p2);
         if (p) {
-                mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
-                mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
+                inode_lock_nested(p2->d_inode, I_MUTEX_CHILD);
                 return p;
         }
 
-        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
-        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT2);
+        inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
+        inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);
         return NULL;
 }
 EXPORT_SYMBOL(lock_rename);
 
 void unlock_rename(struct dentry *p1, struct dentry *p2)
 {
-        mutex_unlock(&p1->d_inode->i_mutex);
+        inode_unlock(p1->d_inode);
         if (p1 != p2) {
-                mutex_unlock(&p2->d_inode->i_mutex);
+                inode_unlock(p2->d_inode);
                 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
         }
 }
@@ -3141,9 +3141,9 @@ retry_lookup:
                  * dropping this one anyway.
                  */
         }
-        mutex_lock(&dir->d_inode->i_mutex);
+        inode_lock(dir->d_inode);
         error = lookup_open(nd, &path, file, op, got_write, opened);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        inode_unlock(dir->d_inode);
 
         if (error <= 0) {
                 if (error)
@@ -3489,7 +3489,7 @@ static struct dentry *filename_create(int dfd, struct filename *name,
          * Do the final lookup.
          */
         lookup_flags |= LOOKUP_CREATE | LOOKUP_EXCL;
-        mutex_lock_nested(&path->dentry->d_inode->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
         dentry = __lookup_hash(&last, path->dentry, lookup_flags);
         if (IS_ERR(dentry))
                 goto unlock;
@@ -3518,7 +3518,7 @@ fail:
         dput(dentry);
         dentry = ERR_PTR(error);
 unlock:
-        mutex_unlock(&path->dentry->d_inode->i_mutex);
+        inode_unlock(path->dentry->d_inode);
         if (!err2)
                 mnt_drop_write(path->mnt);
 out:
@@ -3538,7 +3538,7 @@ EXPORT_SYMBOL(kern_path_create);
 void done_path_create(struct path *path, struct dentry *dentry)
 {
         dput(dentry);
-        mutex_unlock(&path->dentry->d_inode->i_mutex);
+        inode_unlock(path->dentry->d_inode);
         mnt_drop_write(path->mnt);
         path_put(path);
 }
@@ -3735,7 +3735,7 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
                 return -EPERM;
 
         dget(dentry);
-        mutex_lock(&dentry->d_inode->i_mutex);
+        inode_lock(dentry->d_inode);
 
         error = -EBUSY;
         if (is_local_mountpoint(dentry))
@@ -3755,7 +3755,7 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
         detach_mounts(dentry);
 
 out:
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        inode_unlock(dentry->d_inode);
         dput(dentry);
         if (!error)
                 d_delete(dentry);
@@ -3794,7 +3794,7 @@ retry:
         if (error)
                 goto exit1;
 
-        mutex_lock_nested(&path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
         dentry = __lookup_hash(&last, path.dentry, lookup_flags);
         error = PTR_ERR(dentry);
         if (IS_ERR(dentry))
@@ -3810,7 +3810,7 @@ retry:
 exit3:
         dput(dentry);
 exit2:
-        mutex_unlock(&path.dentry->d_inode->i_mutex);
+        inode_unlock(path.dentry->d_inode);
         mnt_drop_write(path.mnt);
 exit1:
         path_put(&path);
@@ -3856,7 +3856,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegate
         if (!dir->i_op->unlink)
                 return -EPERM;
 
-        mutex_lock(&target->i_mutex);
+        inode_lock(target);
         if (is_local_mountpoint(dentry))
                 error = -EBUSY;
         else {
@@ -3873,7 +3873,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegate
                 }
         }
 out:
-        mutex_unlock(&target->i_mutex);
+        inode_unlock(target);
 
         /* We don't d_delete() NFS sillyrenamed files--they still exist. */
         if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
@@ -3916,7 +3916,7 @@ retry:
         if (error)
                 goto exit1;
 retry_deleg:
-        mutex_lock_nested(&path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
         dentry = __lookup_hash(&last, path.dentry, lookup_flags);
         error = PTR_ERR(dentry);
         if (!IS_ERR(dentry)) {
@@ -3934,7 +3934,7 @@ retry_deleg:
 exit2:
                 dput(dentry);
         }
-        mutex_unlock(&path.dentry->d_inode->i_mutex);
+        inode_unlock(path.dentry->d_inode);
         if (inode)
                 iput(inode);    /* truncate the inode here */
         inode = NULL;
@@ -4086,7 +4086,7 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
         if (error)
                 return error;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* Make sure we don't allow creating hardlink to an unlinked file */
         if (inode->i_nlink == 0 && !(inode->i_state & I_LINKABLE))
                 error =  -ENOENT;
@@ -4103,7 +4103,7 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
                 inode->i_state &= ~I_LINKABLE;
                 spin_unlock(&inode->i_lock);
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (!error)
                 fsnotify_link(dir, inode, new_dentry);
         return error;
@@ -4303,7 +4303,7 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (!is_dir || (flags & RENAME_EXCHANGE))
                 lock_two_nondirectories(source, target);
         else if (target)
-                mutex_lock(&target->i_mutex);
+                inode_lock(target);
 
         error = -EBUSY;
         if (is_local_mountpoint(old_dentry) || is_local_mountpoint(new_dentry))
@@ -4356,7 +4356,7 @@ out:
         if (!is_dir || (flags & RENAME_EXCHANGE))
                 unlock_two_nondirectories(source, target);
         else if (target)
-                mutex_unlock(&target->i_mutex);
+                inode_unlock(target);
         dput(new_dentry);
         if (!error) {
                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
diff --git a/fs/namespace.c b/fs/namespace.c
index a830e1463704..4fb1691b4355 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1961,9 +1961,9 @@ static struct mountpoint *lock_mount(struct path *path)
         struct vfsmount *mnt;
         struct dentry *dentry = path->dentry;
 retry:
-        mutex_lock(&dentry->d_inode->i_mutex);
+        inode_lock(dentry->d_inode);
         if (unlikely(cant_mount(dentry))) {
-                mutex_unlock(&dentry->d_inode->i_mutex);
+                inode_unlock(dentry->d_inode);
                 return ERR_PTR(-ENOENT);
         }
         namespace_lock();
@@ -1974,13 +1974,13 @@ retry:
                         mp = new_mountpoint(dentry);
                 if (IS_ERR(mp)) {
                         namespace_unlock();
-                        mutex_unlock(&dentry->d_inode->i_mutex);
+                        inode_unlock(dentry->d_inode);
                         return mp;
                 }
                 return mp;
         }
         namespace_unlock();
-        mutex_unlock(&path->dentry->d_inode->i_mutex);
+        inode_unlock(path->dentry->d_inode);
         path_put(path);
         path->mnt = mnt;
         dentry = path->dentry = dget(mnt->mnt_root);
@@ -1992,7 +1992,7 @@ static void unlock_mount(struct mountpoint *where)
         struct dentry *dentry = where->m_dentry;
         put_mountpoint(where);
         namespace_unlock();
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        inode_unlock(dentry->d_inode);
 }
 
 static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index f0e3e9e747dd..26c2de2de13f 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -369,7 +369,7 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
         if (!res) {
                 struct inode *inode = d_inode(dentry);
 
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) {
                         ncp_new_dentry(dentry);
                         val=1;
@@ -377,7 +377,7 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
                         ncp_dbg(2, "found, but dirEntNum changed\n");
 
                 ncp_update_inode2(inode, &finfo);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
 finished:
@@ -639,9 +639,9 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
         } else {
                 struct inode *inode = d_inode(newdent);
 
-                mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
+                inode_lock_nested(inode, I_MUTEX_CHILD);
                 ncp_update_inode2(inode, entry);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         if (ctl.idx >= NCP_DIRCACHE_SIZE) {
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 011324ce9df2..dd38ca1f2ecb 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -224,10 +224,10 @@ ncp_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         iocb->ki_pos = pos;
 
         if (pos > i_size_read(inode)) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (pos > i_size_read(inode))
                         i_size_write(inode, pos);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         ncp_dbg(1, "exit %pD2\n", file);
 outrel:
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;
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 819ad812c71b..4cba7865f496 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -55,10 +55,10 @@ nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u
         struct inode *inode = d_inode(resfh->fh_dentry);
         int status;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         status = security_inode_setsecctx(resfh->fh_dentry,
                 label->data, label->len);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (status)
                 /*
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 79f0307a5ec8..dc8ebecf5618 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -192,7 +192,7 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
 
         dir = nn->rec_file->f_path.dentry;
         /* lock the parent */
-        mutex_lock(&d_inode(dir)->i_mutex);
+        inode_lock(d_inode(dir));
 
         dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
         if (IS_ERR(dentry)) {
@@ -213,7 +213,7 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
 out_put:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         if (status == 0) {
                 if (nn->in_grace) {
                         crp = nfs4_client_to_reclaim(dname, nn);
@@ -286,7 +286,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
         }
 
         status = iterate_dir(nn->rec_file, &ctx.ctx);
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
 
         list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
                 if (!status) {
@@ -302,7 +302,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
                 list_del(&entry->list);
                 kfree(entry);
         }
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         nfs4_reset_creds(original_cred);
 
         list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
@@ -322,7 +322,7 @@ nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 
         dir = nn->rec_file->f_path.dentry;
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
         dentry = lookup_one_len(name, dir, namlen);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
@@ -335,7 +335,7 @@ nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
 out:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
         return status;
 }
 
diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index 0770bcb543c8..f84fe6bf9aee 100644
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -288,7 +288,7 @@ fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
         }
 
         inode = d_inode(dentry);
-        mutex_lock_nested(&inode->i_mutex, subclass);
+        inode_lock_nested(inode, subclass);
         fill_pre_wcc(fhp);
         fhp->fh_locked = true;
 }
@@ -307,7 +307,7 @@ fh_unlock(struct svc_fh *fhp)
 {
         if (fhp->fh_locked) {
                 fill_post_wcc(fhp);
-                mutex_unlock(&d_inode(fhp->fh_dentry)->i_mutex);
+                inode_unlock(d_inode(fhp->fh_dentry));
                 fhp->fh_locked = false;
         }
 }
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 6739077f17fe..5d2a57e4c03a 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -493,9 +493,9 @@ __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
 
         dentry = fhp->fh_dentry;
 
-        mutex_lock(&d_inode(dentry)->i_mutex);
+        inode_lock(d_inode(dentry));
         host_error = security_inode_setsecctx(dentry, label->data, label->len);
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
         return nfserrno(host_error);
 }
 #else
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 10b22527a617..21a1e2e0d92f 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -1003,7 +1003,7 @@ int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
         if (ret)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         isize = i_size_read(inode);
 
@@ -1113,6 +1113,6 @@ int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
         if (ret == 1)
                 ret = 0;
 
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
index aba43811d6ef..e8fe24882b5b 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -158,7 +158,7 @@ static int nilfs_ioctl_setflags(struct inode *inode, struct file *filp,
 
         flags = nilfs_mask_flags(inode->i_mode, flags);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         oldflags = NILFS_I(inode)->i_flags;
 
@@ -186,7 +186,7 @@ static int nilfs_ioctl_setflags(struct inode *inode, struct file *filp,
         nilfs_mark_inode_dirty(inode);
         ret = nilfs_transaction_commit(inode->i_sb);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         mnt_drop_write_file(filp);
         return ret;
 }
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 9e38dafa3bc7..b2eff5816adc 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1509,7 +1509,7 @@ static int ntfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
         err = filemap_write_and_wait_range(vi->i_mapping, start, end);
         if (err)
                 return err;
-        mutex_lock(&vi->i_mutex);
+        inode_lock(vi);
 
         BUG_ON(!S_ISDIR(vi->i_mode));
         /* If the bitmap attribute inode is in memory sync it, too. */
@@ -1532,7 +1532,7 @@ static int ntfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
         else
                 ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx.  Error "
                                 "%u.", datasync ? "data" : "", vi->i_ino, -ret);
-        mutex_unlock(&vi->i_mutex);
+        inode_unlock(vi);
         return ret;
 }
 
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 9d383e5eff0e..bed4d427dfae 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1944,14 +1944,14 @@ static ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         ssize_t written = 0;
         ssize_t err;
 
-        mutex_lock(&vi->i_mutex);
+        inode_lock(vi);
         /* We can write back this queue in page reclaim. */
         current->backing_dev_info = inode_to_bdi(vi);
         err = ntfs_prepare_file_for_write(iocb, from);
         if (iov_iter_count(from) && !err)
                 written = ntfs_perform_write(file, from, iocb->ki_pos);
         current->backing_dev_info = NULL;
-        mutex_unlock(&vi->i_mutex);
+        inode_unlock(vi);
         if (likely(written > 0)) {
                 err = generic_write_sync(file, iocb->ki_pos, written);
                 if (err < 0)
@@ -1996,7 +1996,7 @@ static int ntfs_file_fsync(struct file *filp, loff_t start, loff_t end,
         err = filemap_write_and_wait_range(vi->i_mapping, start, end);
         if (err)
                 return err;
-        mutex_lock(&vi->i_mutex);
+        inode_lock(vi);
 
         BUG_ON(S_ISDIR(vi->i_mode));
         if (!datasync || !NInoNonResident(NTFS_I(vi)))
@@ -2015,7 +2015,7 @@ static int ntfs_file_fsync(struct file *filp, loff_t start, loff_t end,
         else
                 ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx.  Error "
                                 "%u.", datasync ? "data" : "", vi->i_ino, -ret);
-        mutex_unlock(&vi->i_mutex);
+        inode_unlock(vi);
         return ret;
 }
 
diff --git a/fs/ntfs/quota.c b/fs/ntfs/quota.c
index d80e3315cab0..9793e68ba1dd 100644
--- a/fs/ntfs/quota.c
+++ b/fs/ntfs/quota.c
@@ -48,7 +48,7 @@ bool ntfs_mark_quotas_out_of_date(ntfs_volume *vol)
                 ntfs_error(vol->sb, "Quota inodes are not open.");
                 return false;
         }
-        mutex_lock(&vol->quota_q_ino->i_mutex);
+        inode_lock(vol->quota_q_ino);
         ictx = ntfs_index_ctx_get(NTFS_I(vol->quota_q_ino));
         if (!ictx) {
                 ntfs_error(vol->sb, "Failed to get index context.");
@@ -98,7 +98,7 @@ bool ntfs_mark_quotas_out_of_date(ntfs_volume *vol)
         ntfs_index_entry_mark_dirty(ictx);
 set_done:
         ntfs_index_ctx_put(ictx);
-        mutex_unlock(&vol->quota_q_ino->i_mutex);
+        inode_unlock(vol->quota_q_ino);
         /*
          * We set the flag so we do not try to mark the quotas out of date
          * again on remount.
@@ -110,7 +110,7 @@ done:
 err_out:
         if (ictx)
                 ntfs_index_ctx_put(ictx);
-        mutex_unlock(&vol->quota_q_ino->i_mutex);
+        inode_unlock(vol->quota_q_ino);
         return false;
 }
 
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 2f77f8dfb861..1b38abdaa3ed 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -1284,10 +1284,10 @@ static int check_windows_hibernation_status(ntfs_volume *vol)
          * Find the inode number for the hibernation file by looking up the
          * filename hiberfil.sys in the root directory.
          */
-        mutex_lock(&vol->root_ino->i_mutex);
+        inode_lock(vol->root_ino);
         mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
                         &name);
-        mutex_unlock(&vol->root_ino->i_mutex);
+        inode_unlock(vol->root_ino);
         if (IS_ERR_MREF(mref)) {
                 ret = MREF_ERR(mref);
                 /* If the file does not exist, Windows is not hibernated. */
@@ -1377,10 +1377,10 @@ static bool load_and_init_quota(ntfs_volume *vol)
          * Find the inode number for the quota file by looking up the filename
          * $Quota in the extended system files directory $Extend.
          */
-        mutex_lock(&vol->extend_ino->i_mutex);
+        inode_lock(vol->extend_ino);
         mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
                         &name);
-        mutex_unlock(&vol->extend_ino->i_mutex);
+        inode_unlock(vol->extend_ino);
         if (IS_ERR_MREF(mref)) {
                 /*
                  * If the file does not exist, quotas are disabled and have
@@ -1460,10 +1460,10 @@ static bool load_and_init_usnjrnl(ntfs_volume *vol)
          * Find the inode number for the transaction log file by looking up the
          * filename $UsnJrnl in the extended system files directory $Extend.
          */
-        mutex_lock(&vol->extend_ino->i_mutex);
+        inode_lock(vol->extend_ino);
         mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
                         &name);
-        mutex_unlock(&vol->extend_ino->i_mutex);
+        inode_unlock(vol->extend_ino);
         if (IS_ERR_MREF(mref)) {
                 /*
                  * If the file does not exist, transaction logging is disabled,
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index a3ded88718c9..d002579c6f2b 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -5719,7 +5719,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
                 goto bail;
         }
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         if (ocfs2_truncate_log_needs_flush(osb)) {
                 ret = __ocfs2_flush_truncate_log(osb);
@@ -5776,7 +5776,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
 out_commit:
         ocfs2_commit_trans(osb, handle);
 out:
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 bail:
         if (meta_ac)
                 ocfs2_free_alloc_context(meta_ac);
@@ -5832,7 +5832,7 @@ int ocfs2_truncate_log_append(struct ocfs2_super *osb,
         struct ocfs2_dinode *di;
         struct ocfs2_truncate_log *tl;
 
-        BUG_ON(mutex_trylock(&tl_inode->i_mutex));
+        BUG_ON(inode_trylock(tl_inode));
 
         start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
 
@@ -5980,7 +5980,7 @@ int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
         struct ocfs2_dinode *di;
         struct ocfs2_truncate_log *tl;
 
-        BUG_ON(mutex_trylock(&tl_inode->i_mutex));
+        BUG_ON(inode_trylock(tl_inode));
 
         di = (struct ocfs2_dinode *) tl_bh->b_data;
 
@@ -6008,7 +6008,7 @@ int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
                 goto out;
         }
 
-        mutex_lock(&data_alloc_inode->i_mutex);
+        inode_lock(data_alloc_inode);
 
         status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
         if (status < 0) {
@@ -6035,7 +6035,7 @@ out_unlock:
         ocfs2_inode_unlock(data_alloc_inode, 1);
 
 out_mutex:
-        mutex_unlock(&data_alloc_inode->i_mutex);
+        inode_unlock(data_alloc_inode);
         iput(data_alloc_inode);
 
 out:
@@ -6047,9 +6047,9 @@ int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
         int status;
         struct inode *tl_inode = osb->osb_tl_inode;
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
         status = __ocfs2_flush_truncate_log(osb);
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         return status;
 }
@@ -6208,7 +6208,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
                 (unsigned long long)le64_to_cpu(tl_copy->i_blkno),
                 num_recs);
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
         for(i = 0; i < num_recs; i++) {
                 if (ocfs2_truncate_log_needs_flush(osb)) {
                         status = __ocfs2_flush_truncate_log(osb);
@@ -6239,7 +6239,7 @@ int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
         }
 
 bail_up:
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         return status;
 }
@@ -6346,7 +6346,7 @@ static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
                 goto out;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         ret = ocfs2_inode_lock(inode, &di_bh, 1);
         if (ret) {
@@ -6395,7 +6395,7 @@ out_unlock:
         ocfs2_inode_unlock(inode, 1);
         brelse(di_bh);
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         iput(inode);
 out:
         while(head) {
@@ -6439,7 +6439,7 @@ static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
         handle_t *handle;
         int ret = 0;
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         while (head) {
                 if (ocfs2_truncate_log_needs_flush(osb)) {
@@ -6471,7 +6471,7 @@ static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
                 }
         }
 
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         while (head) {
                 /* Premature exit may have left some dangling items. */
@@ -7355,7 +7355,7 @@ int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range)
                 goto out;
         }
 
-        mutex_lock(&main_bm_inode->i_mutex);
+        inode_lock(main_bm_inode);
 
         ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 0);
         if (ret < 0) {
@@ -7422,7 +7422,7 @@ out_unlock:
         ocfs2_inode_unlock(main_bm_inode, 0);
         brelse(main_bm_bh);
 out_mutex:
-        mutex_unlock(&main_bm_inode->i_mutex);
+        inode_unlock(main_bm_inode);
         iput(main_bm_inode);
 out:
         return ret;
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 7f604727f487..794fd1587f34 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -2046,9 +2046,9 @@ static int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb,
         int ret = 0;
         unsigned int truncated_clusters;
 
-        mutex_lock(&osb->osb_tl_inode->i_mutex);
+        inode_lock(osb->osb_tl_inode);
         truncated_clusters = osb->truncated_clusters;
-        mutex_unlock(&osb->osb_tl_inode->i_mutex);
+        inode_unlock(osb->osb_tl_inode);
 
         /*
          * Check whether we can succeed in allocating if we free
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index ffecf89c8c1c..e1adf285fc31 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -4361,7 +4361,7 @@ static int ocfs2_dx_dir_remove_index(struct inode *dir,
                 mlog_errno(ret);
                 goto out;
         }
-        mutex_lock(&dx_alloc_inode->i_mutex);
+        inode_lock(dx_alloc_inode);
 
         ret = ocfs2_inode_lock(dx_alloc_inode, &dx_alloc_bh, 1);
         if (ret) {
@@ -4410,7 +4410,7 @@ out_unlock:
         ocfs2_inode_unlock(dx_alloc_inode, 1);
 
 out_mutex:
-        mutex_unlock(&dx_alloc_inode->i_mutex);
+        inode_unlock(dx_alloc_inode);
         brelse(dx_alloc_bh);
 out:
         iput(dx_alloc_inode);
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index d63127932509..7cb38fdca229 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1872,7 +1872,7 @@ static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
                 return -EROFS;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * This prevents concurrent writes on other nodes
@@ -1991,7 +1991,7 @@ out_rw_unlock:
         ocfs2_rw_unlock(inode, 1);
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return ret;
 }
 
@@ -2299,7 +2299,7 @@ static ssize_t ocfs2_file_write_iter(struct kiocb *iocb,
         appending = iocb->ki_flags & IOCB_APPEND ? 1 : 0;
         direct_io = iocb->ki_flags & IOCB_DIRECT ? 1 : 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
 relock:
         /*
@@ -2435,7 +2435,7 @@ out:
                 ocfs2_rw_unlock(inode, rw_level);
 
 out_mutex:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (written)
                 ret = written;
@@ -2547,7 +2547,7 @@ static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence)
         struct inode *inode = file->f_mapping->host;
         int ret = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         switch (whence) {
         case SEEK_SET:
@@ -2585,7 +2585,7 @@ static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence)
         offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (ret)
                 return ret;
         return offset;
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 97a563bab9a8..36294446d960 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -630,10 +630,10 @@ static int ocfs2_remove_inode(struct inode *inode,
                 goto bail;
         }
 
-        mutex_lock(&inode_alloc_inode->i_mutex);
+        inode_lock(inode_alloc_inode);
         status = ocfs2_inode_lock(inode_alloc_inode, &inode_alloc_bh, 1);
         if (status < 0) {
-                mutex_unlock(&inode_alloc_inode->i_mutex);
+                inode_unlock(inode_alloc_inode);
 
                 mlog_errno(status);
                 goto bail;
@@ -680,7 +680,7 @@ bail_commit:
         ocfs2_commit_trans(osb, handle);
 bail_unlock:
         ocfs2_inode_unlock(inode_alloc_inode, 1);
-        mutex_unlock(&inode_alloc_inode->i_mutex);
+        inode_unlock(inode_alloc_inode);
         brelse(inode_alloc_bh);
 bail:
         iput(inode_alloc_inode);
@@ -751,10 +751,10 @@ static int ocfs2_wipe_inode(struct inode *inode,
                 /* Lock the orphan dir. The lock will be held for the entire
                  * delete_inode operation. We do this now to avoid races with
                  * recovery completion on other nodes. */
-                mutex_lock(&orphan_dir_inode->i_mutex);
+                inode_lock(orphan_dir_inode);
                 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
                 if (status < 0) {
-                        mutex_unlock(&orphan_dir_inode->i_mutex);
+                        inode_unlock(orphan_dir_inode);
 
                         mlog_errno(status);
                         goto bail;
@@ -803,7 +803,7 @@ bail_unlock_dir:
                 return status;
 
         ocfs2_inode_unlock(orphan_dir_inode, 1);
-        mutex_unlock(&orphan_dir_inode->i_mutex);
+        inode_unlock(orphan_dir_inode);
         brelse(orphan_dir_bh);
 bail:
         iput(orphan_dir_inode);
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index 16b0bb482ea7..4506ec5ec2ea 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -86,7 +86,7 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
         unsigned oldflags;
         int status;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         status = ocfs2_inode_lock(inode, &bh, 1);
         if (status < 0) {
@@ -135,7 +135,7 @@ static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
 bail_unlock:
         ocfs2_inode_unlock(inode, 1);
 bail:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         brelse(bh);
 
@@ -287,7 +287,7 @@ static int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
         struct ocfs2_dinode *dinode_alloc = NULL;
 
         if (inode_alloc)
-                mutex_lock(&inode_alloc->i_mutex);
+                inode_lock(inode_alloc);
 
         if (o2info_coherent(&fi->ifi_req)) {
                 status = ocfs2_inode_lock(inode_alloc, &bh, 0);
@@ -317,7 +317,7 @@ bail:
                 ocfs2_inode_unlock(inode_alloc, 0);
 
         if (inode_alloc)
-                mutex_unlock(&inode_alloc->i_mutex);
+                inode_unlock(inode_alloc);
 
         brelse(bh);
 
@@ -547,7 +547,7 @@ static int ocfs2_info_freefrag_scan_bitmap(struct ocfs2_super *osb,
         struct ocfs2_dinode *gb_dinode = NULL;
 
         if (gb_inode)
-                mutex_lock(&gb_inode->i_mutex);
+                inode_lock(gb_inode);
 
         if (o2info_coherent(&ffg->iff_req)) {
                 status = ocfs2_inode_lock(gb_inode, &bh, 0);
@@ -604,7 +604,7 @@ bail:
                 ocfs2_inode_unlock(gb_inode, 0);
 
         if (gb_inode)
-                mutex_unlock(&gb_inode->i_mutex);
+                inode_unlock(gb_inode);
 
         iput(gb_inode);
         brelse(bh);
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 3772a2dbb980..61b833b721d8 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -2088,7 +2088,7 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb,
                 return status;
         }
 
-        mutex_lock(&orphan_dir_inode->i_mutex);
+        inode_lock(orphan_dir_inode);
         status = ocfs2_inode_lock(orphan_dir_inode, NULL, 0);
         if (status < 0) {
                 mlog_errno(status);
@@ -2106,7 +2106,7 @@ static int ocfs2_queue_orphans(struct ocfs2_super *osb,
 out_cluster:
         ocfs2_inode_unlock(orphan_dir_inode, 0);
 out:
-        mutex_unlock(&orphan_dir_inode->i_mutex);
+        inode_unlock(orphan_dir_inode);
         iput(orphan_dir_inode);
         return status;
 }
@@ -2196,7 +2196,7 @@ static int ocfs2_recover_orphans(struct ocfs2_super *osb,
                 oi->ip_next_orphan = NULL;
 
                 if (oi->ip_flags & OCFS2_INODE_DIO_ORPHAN_ENTRY) {
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                         ret = ocfs2_rw_lock(inode, 1);
                         if (ret < 0) {
                                 mlog_errno(ret);
@@ -2235,7 +2235,7 @@ unlock_inode:
 unlock_rw:
                         ocfs2_rw_unlock(inode, 1);
 unlock_mutex:
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
 
                         /* clear dio flag in ocfs2_inode_info */
                         oi->ip_flags &= ~OCFS2_INODE_DIO_ORPHAN_ENTRY;
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index e9c99e35f5ea..7d62c43a2c3e 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -414,7 +414,7 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
                 goto out;
         }
 
-        mutex_lock(&main_bm_inode->i_mutex);
+        inode_lock(main_bm_inode);
 
         status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
         if (status < 0) {
@@ -468,7 +468,7 @@ out_unlock:
         ocfs2_inode_unlock(main_bm_inode, 1);
 
 out_mutex:
-        mutex_unlock(&main_bm_inode->i_mutex);
+        inode_unlock(main_bm_inode);
         iput(main_bm_inode);
 
 out:
@@ -506,7 +506,7 @@ int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
                 goto bail;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         status = ocfs2_read_inode_block_full(inode, &alloc_bh,
                                              OCFS2_BH_IGNORE_CACHE);
@@ -539,7 +539,7 @@ bail:
         brelse(alloc_bh);
 
         if (inode) {
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 iput(inode);
         }
 
@@ -571,7 +571,7 @@ int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
                 goto out;
         }
 
-        mutex_lock(&main_bm_inode->i_mutex);
+        inode_lock(main_bm_inode);
 
         status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
         if (status < 0) {
@@ -601,7 +601,7 @@ out_unlock:
         ocfs2_inode_unlock(main_bm_inode, 1);
 
 out_mutex:
-        mutex_unlock(&main_bm_inode->i_mutex);
+        inode_unlock(main_bm_inode);
 
         brelse(main_bm_bh);
 
@@ -643,7 +643,7 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
                 goto bail;
         }
 
-        mutex_lock(&local_alloc_inode->i_mutex);
+        inode_lock(local_alloc_inode);
 
         /*
          * We must double check state and allocator bits because
@@ -709,7 +709,7 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
         status = 0;
 bail:
         if (status < 0 && local_alloc_inode) {
-                mutex_unlock(&local_alloc_inode->i_mutex);
+                inode_unlock(local_alloc_inode);
                 iput(local_alloc_inode);
         }
 
diff --git a/fs/ocfs2/move_extents.c b/fs/ocfs2/move_extents.c
index 124471d26a73..e3d05d9901a3 100644
--- a/fs/ocfs2/move_extents.c
+++ b/fs/ocfs2/move_extents.c
@@ -276,7 +276,7 @@ static int ocfs2_defrag_extent(struct ocfs2_move_extents_context *context,
          *      context->data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
          */
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         if (ocfs2_truncate_log_needs_flush(osb)) {
                 ret = __ocfs2_flush_truncate_log(osb);
@@ -338,7 +338,7 @@ out_commit:
         ocfs2_commit_trans(osb, handle);
 
 out_unlock_mutex:
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         if (context->data_ac) {
                 ocfs2_free_alloc_context(context->data_ac);
@@ -632,7 +632,7 @@ static int ocfs2_move_extent(struct ocfs2_move_extents_context *context,
                 goto out;
         }
 
-        mutex_lock(&gb_inode->i_mutex);
+        inode_lock(gb_inode);
 
         ret = ocfs2_inode_lock(gb_inode, &gb_bh, 1);
         if (ret) {
@@ -640,7 +640,7 @@ static int ocfs2_move_extent(struct ocfs2_move_extents_context *context,
                 goto out_unlock_gb_mutex;
         }
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         handle = ocfs2_start_trans(osb, credits);
         if (IS_ERR(handle)) {
@@ -708,11 +708,11 @@ out_commit:
         brelse(gd_bh);
 
 out_unlock_tl_inode:
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         ocfs2_inode_unlock(gb_inode, 1);
 out_unlock_gb_mutex:
-        mutex_unlock(&gb_inode->i_mutex);
+        inode_unlock(gb_inode);
         brelse(gb_bh);
         iput(gb_inode);
 
@@ -905,7 +905,7 @@ static int ocfs2_move_extents(struct ocfs2_move_extents_context *context)
         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
                 return -EROFS;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /*
          * This prevents concurrent writes from other nodes
@@ -969,7 +969,7 @@ out_inode_unlock:
 out_rw_unlock:
         ocfs2_rw_unlock(inode, 1);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         return status;
 }
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index ab42c38031b1..6b3e87189a64 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -1045,7 +1045,7 @@ leave:
         if (orphan_dir) {
                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
                 ocfs2_inode_unlock(orphan_dir, 1);
-                mutex_unlock(&orphan_dir->i_mutex);
+                inode_unlock(orphan_dir);
                 iput(orphan_dir);
         }
 
@@ -1664,7 +1664,7 @@ bail:
         if (orphan_dir) {
                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
                 ocfs2_inode_unlock(orphan_dir, 1);
-                mutex_unlock(&orphan_dir->i_mutex);
+                inode_unlock(orphan_dir);
                 iput(orphan_dir);
         }
 
@@ -2121,11 +2121,11 @@ static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
                 return ret;
         }
 
-        mutex_lock(&orphan_dir_inode->i_mutex);
+        inode_lock(orphan_dir_inode);
 
         ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
         if (ret < 0) {
-                mutex_unlock(&orphan_dir_inode->i_mutex);
+                inode_unlock(orphan_dir_inode);
                 iput(orphan_dir_inode);
 
                 mlog_errno(ret);
@@ -2226,7 +2226,7 @@ out:
 
         if (ret) {
                 ocfs2_inode_unlock(orphan_dir_inode, 1);
-                mutex_unlock(&orphan_dir_inode->i_mutex);
+                inode_unlock(orphan_dir_inode);
                 iput(orphan_dir_inode);
         }
 
@@ -2495,7 +2495,7 @@ out:
                         ocfs2_free_alloc_context(inode_ac);
 
                 /* Unroll orphan dir locking */
-                mutex_unlock(&orphan_dir->i_mutex);
+                inode_unlock(orphan_dir);
                 ocfs2_inode_unlock(orphan_dir, 1);
                 iput(orphan_dir);
         }
@@ -2602,7 +2602,7 @@ leave:
         if (orphan_dir) {
                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
                 ocfs2_inode_unlock(orphan_dir, 1);
-                mutex_unlock(&orphan_dir->i_mutex);
+                inode_unlock(orphan_dir);
                 iput(orphan_dir);
         }
 
@@ -2689,7 +2689,7 @@ int ocfs2_add_inode_to_orphan(struct ocfs2_super *osb,
 
 bail_unlock_orphan:
         ocfs2_inode_unlock(orphan_dir_inode, 1);
-        mutex_unlock(&orphan_dir_inode->i_mutex);
+        inode_unlock(orphan_dir_inode);
         iput(orphan_dir_inode);
 
         ocfs2_free_dir_lookup_result(&orphan_insert);
@@ -2721,10 +2721,10 @@ int ocfs2_del_inode_from_orphan(struct ocfs2_super *osb,
                 goto bail;
         }
 
-        mutex_lock(&orphan_dir_inode->i_mutex);
+        inode_lock(orphan_dir_inode);
         status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
         if (status < 0) {
-                mutex_unlock(&orphan_dir_inode->i_mutex);
+                inode_unlock(orphan_dir_inode);
                 iput(orphan_dir_inode);
                 mlog_errno(status);
                 goto bail;
@@ -2770,7 +2770,7 @@ bail_commit:
 
 bail_unlock_orphan:
         ocfs2_inode_unlock(orphan_dir_inode, 1);
-        mutex_unlock(&orphan_dir_inode->i_mutex);
+        inode_unlock(orphan_dir_inode);
         brelse(orphan_dir_bh);
         iput(orphan_dir_inode);
 
@@ -2834,12 +2834,12 @@ int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
                 goto leave;
         }
 
-        mutex_lock(&orphan_dir_inode->i_mutex);
+        inode_lock(orphan_dir_inode);
 
         status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
         if (status < 0) {
                 mlog_errno(status);
-                mutex_unlock(&orphan_dir_inode->i_mutex);
+                inode_unlock(orphan_dir_inode);
                 iput(orphan_dir_inode);
                 goto leave;
         }
@@ -2901,7 +2901,7 @@ out_commit:
         ocfs2_commit_trans(osb, handle);
 orphan_unlock:
         ocfs2_inode_unlock(orphan_dir_inode, 1);
-        mutex_unlock(&orphan_dir_inode->i_mutex);
+        inode_unlock(orphan_dir_inode);
         iput(orphan_dir_inode);
 leave:
 
diff --git a/fs/ocfs2/quota_global.c b/fs/ocfs2/quota_global.c
index fde9ef18cff3..9c9dd30bc945 100644
--- a/fs/ocfs2/quota_global.c
+++ b/fs/ocfs2/quota_global.c
@@ -308,7 +308,7 @@ int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
                 WARN_ON(bh != oinfo->dqi_gqi_bh);
         spin_unlock(&dq_data_lock);
         if (ex) {
-                mutex_lock(&oinfo->dqi_gqinode->i_mutex);
+                inode_lock(oinfo->dqi_gqinode);
                 down_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
         } else {
                 down_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
@@ -320,7 +320,7 @@ void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
 {
         if (ex) {
                 up_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
-                mutex_unlock(&oinfo->dqi_gqinode->i_mutex);
+                inode_unlock(oinfo->dqi_gqinode);
         } else {
                 up_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
         }
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 252119860e6c..3eff031aaf26 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -807,7 +807,7 @@ int ocfs2_remove_refcount_tree(struct inode *inode, struct buffer_head *di_bh)
                         mlog_errno(ret);
                         goto out;
                 }
-                mutex_lock(&alloc_inode->i_mutex);
+                inode_lock(alloc_inode);
 
                 ret = ocfs2_inode_lock(alloc_inode, &alloc_bh, 1);
                 if (ret) {
@@ -867,7 +867,7 @@ out_unlock:
         }
 out_mutex:
         if (alloc_inode) {
-                mutex_unlock(&alloc_inode->i_mutex);
+                inode_unlock(alloc_inode);
                 iput(alloc_inode);
         }
 out:
@@ -4197,7 +4197,7 @@ static int __ocfs2_reflink(struct dentry *old_dentry,
                 goto out;
         }
 
-        mutex_lock_nested(&new_inode->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(new_inode, I_MUTEX_CHILD);
         ret = ocfs2_inode_lock_nested(new_inode, &new_bh, 1,
                                       OI_LS_REFLINK_TARGET);
         if (ret) {
@@ -4231,7 +4231,7 @@ inode_unlock:
         ocfs2_inode_unlock(new_inode, 1);
         brelse(new_bh);
 out_unlock:
-        mutex_unlock(&new_inode->i_mutex);
+        inode_unlock(new_inode);
 out:
         if (!ret) {
                 ret = filemap_fdatawait(inode->i_mapping);
@@ -4402,11 +4402,11 @@ static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir,
                         return error;
         }
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = dquot_initialize(dir);
         if (!error)
                 error = ocfs2_reflink(old_dentry, dir, new_dentry, preserve);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (!error)
                 fsnotify_create(dir, new_dentry);
         return error;
diff --git a/fs/ocfs2/resize.c b/fs/ocfs2/resize.c
index 79b8021302b3..576b9a04873f 100644
--- a/fs/ocfs2/resize.c
+++ b/fs/ocfs2/resize.c
@@ -301,7 +301,7 @@ int ocfs2_group_extend(struct inode * inode, int new_clusters)
                 goto out;
         }
 
-        mutex_lock(&main_bm_inode->i_mutex);
+        inode_lock(main_bm_inode);
 
         ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
         if (ret < 0) {
@@ -375,7 +375,7 @@ out_unlock:
         ocfs2_inode_unlock(main_bm_inode, 1);
 
 out_mutex:
-        mutex_unlock(&main_bm_inode->i_mutex);
+        inode_unlock(main_bm_inode);
         iput(main_bm_inode);
 
 out:
@@ -486,7 +486,7 @@ int ocfs2_group_add(struct inode *inode, struct ocfs2_new_group_input *input)
                 goto out;
         }
 
-        mutex_lock(&main_bm_inode->i_mutex);
+        inode_lock(main_bm_inode);
 
         ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
         if (ret < 0) {
@@ -590,7 +590,7 @@ out_unlock:
         ocfs2_inode_unlock(main_bm_inode, 1);
 
 out_mutex:
-        mutex_unlock(&main_bm_inode->i_mutex);
+        inode_unlock(main_bm_inode);
         iput(main_bm_inode);
 
 out:
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index fc6d25f6d444..2f19aeec5482 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -141,7 +141,7 @@ void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
                 if (ac->ac_which != OCFS2_AC_USE_LOCAL)
                         ocfs2_inode_unlock(inode, 1);
 
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
 
                 iput(inode);
                 ac->ac_inode = NULL;
@@ -797,11 +797,11 @@ static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
                 return -EINVAL;
         }
 
-        mutex_lock(&alloc_inode->i_mutex);
+        inode_lock(alloc_inode);
 
         status = ocfs2_inode_lock(alloc_inode, &bh, 1);
         if (status < 0) {
-                mutex_unlock(&alloc_inode->i_mutex);
+                inode_unlock(alloc_inode);
                 iput(alloc_inode);
 
                 mlog_errno(status);
@@ -2875,10 +2875,10 @@ int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
                 goto bail;
         }
 
-        mutex_lock(&inode_alloc_inode->i_mutex);
+        inode_lock(inode_alloc_inode);
         status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0);
         if (status < 0) {
-                mutex_unlock(&inode_alloc_inode->i_mutex);
+                inode_unlock(inode_alloc_inode);
                 iput(inode_alloc_inode);
                 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n",
                      (u32)suballoc_slot, status);
@@ -2891,7 +2891,7 @@ int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
                 mlog(ML_ERROR, "test suballoc bit failed %d\n", status);
 
         ocfs2_inode_unlock(inode_alloc_inode, 0);
-        mutex_unlock(&inode_alloc_inode->i_mutex);
+        inode_unlock(inode_alloc_inode);
 
         iput(inode_alloc_inode);
         brelse(alloc_bh);
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index f0e241ffd94f..7d3d979f57d9 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -2524,7 +2524,7 @@ static int ocfs2_xattr_free_block(struct inode *inode,
                 mlog_errno(ret);
                 goto out;
         }
-        mutex_lock(&xb_alloc_inode->i_mutex);
+        inode_lock(xb_alloc_inode);
 
         ret = ocfs2_inode_lock(xb_alloc_inode, &xb_alloc_bh, 1);
         if (ret < 0) {
@@ -2549,7 +2549,7 @@ out_unlock:
         ocfs2_inode_unlock(xb_alloc_inode, 1);
         brelse(xb_alloc_bh);
 out_mutex:
-        mutex_unlock(&xb_alloc_inode->i_mutex);
+        inode_unlock(xb_alloc_inode);
         iput(xb_alloc_inode);
 out:
         brelse(blk_bh);
@@ -3619,17 +3619,17 @@ int ocfs2_xattr_set(struct inode *inode,
                 }
         }
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         if (ocfs2_truncate_log_needs_flush(osb)) {
                 ret = __ocfs2_flush_truncate_log(osb);
                 if (ret < 0) {
-                        mutex_unlock(&tl_inode->i_mutex);
+                        inode_unlock(tl_inode);
                         mlog_errno(ret);
                         goto cleanup;
                 }
         }
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         ret = ocfs2_init_xattr_set_ctxt(inode, di, &xi, &xis,
                                         &xbs, &ctxt, ref_meta, &credits);
@@ -5460,7 +5460,7 @@ static int ocfs2_rm_xattr_cluster(struct inode *inode,
                 return ret;
         }
 
-        mutex_lock(&tl_inode->i_mutex);
+        inode_lock(tl_inode);
 
         if (ocfs2_truncate_log_needs_flush(osb)) {
                 ret = __ocfs2_flush_truncate_log(osb);
@@ -5504,7 +5504,7 @@ out_commit:
 out:
         ocfs2_schedule_truncate_log_flush(osb, 1);
 
-        mutex_unlock(&tl_inode->i_mutex);
+        inode_unlock(tl_inode);
 
         if (meta_ac)
                 ocfs2_free_alloc_context(meta_ac);
diff --git a/fs/open.c b/fs/open.c
index b25b1542c530..55bdc75e2172 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -58,10 +58,10 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
         if (ret)
                 newattrs.ia_valid |= ret | ATTR_FORCE;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        inode_lock(dentry->d_inode);
         /* Note any delegations or leases have already been broken: */
         ret = notify_change(dentry, &newattrs, NULL);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        inode_unlock(dentry->d_inode);
         return ret;
 }
 
@@ -510,7 +510,7 @@ static int chmod_common(struct path *path, umode_t mode)
         if (error)
                 return error;
 retry_deleg:
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = security_path_chmod(path, mode);
         if (error)
                 goto out_unlock;
@@ -518,7 +518,7 @@ retry_deleg:
         newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
         error = notify_change(path->dentry, &newattrs, &delegated_inode);
 out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (delegated_inode) {
                 error = break_deleg_wait(&delegated_inode);
                 if (!error)
@@ -593,11 +593,11 @@ retry_deleg:
         if (!S_ISDIR(inode->i_mode))
                 newattrs.ia_valid |=
                         ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = security_path_chown(path, uid, gid);
         if (!error)
                 error = notify_change(path->dentry, &newattrs, &delegated_inode);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (delegated_inode) {
                 error = break_deleg_wait(&delegated_inode);
                 if (!error)
diff --git a/fs/overlayfs/copy_up.c b/fs/overlayfs/copy_up.c
index eff6319d5037..d894e7cd9a86 100644
--- a/fs/overlayfs/copy_up.c
+++ b/fs/overlayfs/copy_up.c
@@ -248,9 +248,9 @@ static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir,
         if (err)
                 goto out_cleanup;
 
-        mutex_lock(&newdentry->d_inode->i_mutex);
+        inode_lock(newdentry->d_inode);
         err = ovl_set_attr(newdentry, stat);
-        mutex_unlock(&newdentry->d_inode->i_mutex);
+        inode_unlock(newdentry->d_inode);
         if (err)
                 goto out_cleanup;
 
diff --git a/fs/overlayfs/dir.c b/fs/overlayfs/dir.c
index 692ceda3bc21..ed95272d57a6 100644
--- a/fs/overlayfs/dir.c
+++ b/fs/overlayfs/dir.c
@@ -167,7 +167,7 @@ static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
         struct dentry *newdentry;
         int err;
 
-        mutex_lock_nested(&udir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(udir, I_MUTEX_PARENT);
         newdentry = lookup_one_len(dentry->d_name.name, upperdir,
                                    dentry->d_name.len);
         err = PTR_ERR(newdentry);
@@ -185,7 +185,7 @@ static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
 out_dput:
         dput(newdentry);
 out_unlock:
-        mutex_unlock(&udir->i_mutex);
+        inode_unlock(udir);
         return err;
 }
 
@@ -258,9 +258,9 @@ static struct dentry *ovl_clear_empty(struct dentry *dentry,
         if (err)
                 goto out_cleanup;
 
-        mutex_lock(&opaquedir->d_inode->i_mutex);
+        inode_lock(opaquedir->d_inode);
         err = ovl_set_attr(opaquedir, &stat);
-        mutex_unlock(&opaquedir->d_inode->i_mutex);
+        inode_unlock(opaquedir->d_inode);
         if (err)
                 goto out_cleanup;
 
@@ -599,7 +599,7 @@ static int ovl_remove_upper(struct dentry *dentry, bool is_dir)
         struct dentry *upper = ovl_dentry_upper(dentry);
         int err;
 
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         err = -ESTALE;
         if (upper->d_parent == upperdir) {
                 /* Don't let d_delete() think it can reset d_inode */
@@ -619,7 +619,7 @@ static int ovl_remove_upper(struct dentry *dentry, bool is_dir)
          * now.
          */
         d_drop(dentry);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
 
         return err;
 }
diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c
index bf996e574f3d..49e204560655 100644
--- a/fs/overlayfs/inode.c
+++ b/fs/overlayfs/inode.c
@@ -63,9 +63,9 @@ int ovl_setattr(struct dentry *dentry, struct iattr *attr)
         if (!err) {
                 upperdentry = ovl_dentry_upper(dentry);
 
-                mutex_lock(&upperdentry->d_inode->i_mutex);
+                inode_lock(upperdentry->d_inode);
                 err = notify_change(upperdentry, attr, NULL);
-                mutex_unlock(&upperdentry->d_inode->i_mutex);
+                inode_unlock(upperdentry->d_inode);
         }
         ovl_drop_write(dentry);
 out:
diff --git a/fs/overlayfs/readdir.c b/fs/overlayfs/readdir.c
index adcb1398c481..fdaf28f75e12 100644
--- a/fs/overlayfs/readdir.c
+++ b/fs/overlayfs/readdir.c
@@ -228,7 +228,7 @@ static int ovl_check_whiteouts(struct dentry *dir, struct ovl_readdir_data *rdd)
                                 dput(dentry);
                         }
                 }
-                mutex_unlock(&dir->d_inode->i_mutex);
+                inode_unlock(dir->d_inode);
         }
         revert_creds(old_cred);
         put_cred(override_cred);
@@ -399,7 +399,7 @@ static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
         loff_t res;
         struct ovl_dir_file *od = file->private_data;
 
-        mutex_lock(&file_inode(file)->i_mutex);
+        inode_lock(file_inode(file));
         if (!file->f_pos)
                 ovl_dir_reset(file);
 
@@ -429,7 +429,7 @@ static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
                 res = offset;
         }
 out_unlock:
-        mutex_unlock(&file_inode(file)->i_mutex);
+        inode_unlock(file_inode(file));
 
         return res;
 }
@@ -454,10 +454,10 @@ static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
                         ovl_path_upper(dentry, &upperpath);
                         realfile = ovl_path_open(&upperpath, O_RDONLY);
                         smp_mb__before_spinlock();
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                         if (!od->upperfile) {
                                 if (IS_ERR(realfile)) {
-                                        mutex_unlock(&inode->i_mutex);
+                                        inode_unlock(inode);
                                         return PTR_ERR(realfile);
                                 }
                                 od->upperfile = realfile;
@@ -467,7 +467,7 @@ static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
                                         fput(realfile);
                                 realfile = od->upperfile;
                         }
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                 }
         }
 
@@ -479,9 +479,9 @@ static int ovl_dir_release(struct inode *inode, struct file *file)
         struct ovl_dir_file *od = file->private_data;
 
         if (od->cache) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 ovl_cache_put(od, file->f_path.dentry);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         fput(od->realfile);
         if (od->upperfile)
@@ -557,7 +557,7 @@ void ovl_cleanup_whiteouts(struct dentry *upper, struct list_head *list)
 {
         struct ovl_cache_entry *p;
 
-        mutex_lock_nested(&upper->d_inode->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(upper->d_inode, I_MUTEX_CHILD);
         list_for_each_entry(p, list, l_node) {
                 struct dentry *dentry;
 
@@ -575,5 +575,5 @@ void ovl_cleanup_whiteouts(struct dentry *upper, struct list_head *list)
                         ovl_cleanup(upper->d_inode, dentry);
                 dput(dentry);
         }
-        mutex_unlock(&upper->d_inode->i_mutex);
+        inode_unlock(upper->d_inode);
 }
diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index d250604f985a..8d826bd56b26 100644
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -229,7 +229,7 @@ void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
 {
         struct ovl_entry *oe = dentry->d_fsdata;
 
-        WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex));
+        WARN_ON(!inode_is_locked(upperdentry->d_parent->d_inode));
         WARN_ON(oe->__upperdentry);
         BUG_ON(!upperdentry->d_inode);
         /*
@@ -244,7 +244,7 @@ void ovl_dentry_version_inc(struct dentry *dentry)
 {
         struct ovl_entry *oe = dentry->d_fsdata;
 
-        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
+        WARN_ON(!inode_is_locked(dentry->d_inode));
         oe->version++;
 }
 
@@ -252,7 +252,7 @@ u64 ovl_dentry_version_get(struct dentry *dentry)
 {
         struct ovl_entry *oe = dentry->d_fsdata;
 
-        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
+        WARN_ON(!inode_is_locked(dentry->d_inode));
         return oe->version;
 }
 
@@ -375,9 +375,9 @@ static inline struct dentry *ovl_lookup_real(struct dentry *dir,
 {
         struct dentry *dentry;
 
-        mutex_lock(&dir->d_inode->i_mutex);
+        inode_lock(dir->d_inode);
         dentry = lookup_one_len(name->name, dir, name->len);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        inode_unlock(dir->d_inode);
 
         if (IS_ERR(dentry)) {
                 if (PTR_ERR(dentry) == -ENOENT)
@@ -744,7 +744,7 @@ static struct dentry *ovl_workdir_create(struct vfsmount *mnt,
         if (err)
                 return ERR_PTR(err);
 
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
 retry:
         work = lookup_one_len(OVL_WORKDIR_NAME, dentry,
                               strlen(OVL_WORKDIR_NAME));
@@ -770,7 +770,7 @@ retry:
                         goto out_dput;
         }
 out_unlock:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         mnt_drop_write(mnt);
 
         return work;
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 92e6726f6e37..a939f5ed7f89 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -552,9 +552,9 @@ static int open_kcore(struct inode *inode, struct file *filp)
         if (kcore_need_update)
                 kcore_update_ram();
         if (i_size_read(inode) != proc_root_kcore->size) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 i_size_write(inode, proc_root_kcore->size);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         return 0;
 }
diff --git a/fs/proc/self.c b/fs/proc/self.c
index 67e8db442cf0..b6a8d3529fea 100644
--- a/fs/proc/self.c
+++ b/fs/proc/self.c
@@ -50,7 +50,7 @@ int proc_setup_self(struct super_block *s)
         struct pid_namespace *ns = s->s_fs_info;
         struct dentry *self;
         
-        mutex_lock(&root_inode->i_mutex);
+        inode_lock(root_inode);
         self = d_alloc_name(s->s_root, "self");
         if (self) {
                 struct inode *inode = new_inode_pseudo(s);
@@ -69,7 +69,7 @@ int proc_setup_self(struct super_block *s)
         } else {
                 self = ERR_PTR(-ENOMEM);
         }
-        mutex_unlock(&root_inode->i_mutex);
+        inode_unlock(root_inode);
         if (IS_ERR(self)) {
                 pr_err("proc_fill_super: can't allocate /proc/self\n");
                 return PTR_ERR(self);
diff --git a/fs/proc/thread_self.c b/fs/proc/thread_self.c
index 9eacd59e0360..e58a31e8fb2a 100644
--- a/fs/proc/thread_self.c
+++ b/fs/proc/thread_self.c
@@ -52,7 +52,7 @@ int proc_setup_thread_self(struct super_block *s)
         struct pid_namespace *ns = s->s_fs_info;
         struct dentry *thread_self;
 
-        mutex_lock(&root_inode->i_mutex);
+        inode_lock(root_inode);
         thread_self = d_alloc_name(s->s_root, "thread-self");
         if (thread_self) {
                 struct inode *inode = new_inode_pseudo(s);
@@ -71,7 +71,7 @@ int proc_setup_thread_self(struct super_block *s)
         } else {
                 thread_self = ERR_PTR(-ENOMEM);
         }
-        mutex_unlock(&root_inode->i_mutex);
+        inode_unlock(root_inode);
         if (IS_ERR(thread_self)) {
                 pr_err("proc_fill_super: can't allocate /proc/thread_self\n");
                 return PTR_ERR(thread_self);
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index d8c439d813ce..dc645b66cd79 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -377,7 +377,7 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
                 break;
         }
 
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
 
         dentry = d_alloc_name(root, name);
         if (!dentry)
@@ -397,12 +397,12 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
         list_add(&private->list, &allpstore);
         spin_unlock_irqrestore(&allpstore_lock, flags);
 
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
 
         return 0;
 
 fail_lockedalloc:
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         kfree(private);
 fail_alloc:
         iput(inode);
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index fbd70af98820..3c3b81bb6dfe 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -682,9 +682,9 @@ int dquot_quota_sync(struct super_block *sb, int type)
                         continue;
                 if (!sb_has_quota_active(sb, cnt))
                         continue;
-                mutex_lock(&dqopt->files[cnt]->i_mutex);
+                inode_lock(dqopt->files[cnt]);
                 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
-                mutex_unlock(&dqopt->files[cnt]->i_mutex);
+                inode_unlock(dqopt->files[cnt]);
         }
         mutex_unlock(&dqopt->dqonoff_mutex);
 
@@ -2162,12 +2162,12 @@ int dquot_disable(struct super_block *sb, int type, unsigned int flags)
                         /* If quota was reenabled in the meantime, we have
                          * nothing to do */
                         if (!sb_has_quota_loaded(sb, cnt)) {
-                                mutex_lock(&toputinode[cnt]->i_mutex);
+                                inode_lock(toputinode[cnt]);
                                 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
                                   S_NOATIME | S_NOQUOTA);
                                 truncate_inode_pages(&toputinode[cnt]->i_data,
                                                      0);
-                                mutex_unlock(&toputinode[cnt]->i_mutex);
+                                inode_unlock(toputinode[cnt]);
                                 mark_inode_dirty_sync(toputinode[cnt]);
                         }
                         mutex_unlock(&dqopt->dqonoff_mutex);
@@ -2258,11 +2258,11 @@ static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
                 /* We don't want quota and atime on quota files (deadlocks
                  * possible) Also nobody should write to the file - we use
                  * special IO operations which ignore the immutable bit. */
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
                                              S_NOQUOTA);
                 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 /*
                  * When S_NOQUOTA is set, remove dquot references as no more
                  * references can be added
@@ -2305,12 +2305,12 @@ out_file_init:
         iput(inode);
 out_lock:
         if (oldflags != -1) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 /* Set the flags back (in the case of accidental quotaon()
                  * on a wrong file we don't want to mess up the flags) */
                 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
                 inode->i_flags |= oldflags;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         mutex_unlock(&dqopt->dqonoff_mutex);
 out_fmt:
@@ -2430,9 +2430,9 @@ int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
         struct dentry *dentry;
         int error;
 
-        mutex_lock(&d_inode(sb->s_root)->i_mutex);
+        inode_lock(d_inode(sb->s_root));
         dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
-        mutex_unlock(&d_inode(sb->s_root)->i_mutex);
+        inode_unlock(d_inode(sb->s_root));
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
diff --git a/fs/read_write.c b/fs/read_write.c
index 06b07d5a08fe..fa05985f700e 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -238,7 +238,7 @@ loff_t default_llseek(struct file *file, loff_t offset, int whence)
         struct inode *inode = file_inode(file);
         loff_t retval;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         switch (whence) {
                 case SEEK_END:
                         offset += i_size_read(inode);
@@ -283,7 +283,7 @@ loff_t default_llseek(struct file *file, loff_t offset, int whence)
                 retval = offset;
         }
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return retval;
 }
 EXPORT_SYMBOL(default_llseek);
diff --git a/fs/readdir.c b/fs/readdir.c
index ced679179cac..e69ef3b79787 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -44,7 +44,7 @@ int iterate_dir(struct file *file, struct dir_context *ctx)
                 fsnotify_access(file);
                 file_accessed(file);
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out:
         return res;
 }
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 4a024e2ceb9f..3abd4004184b 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -38,11 +38,11 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
         if (err)
                 return err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         reiserfs_write_lock(inode->i_sb);
         err = reiserfs_commit_for_inode(inode);
         reiserfs_write_unlock(inode->i_sb);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (err < 0)
                 return err;
         return 0;
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 96a1bcf33db4..9424a4ba93a9 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -158,7 +158,7 @@ static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end,
         if (err)
                 return err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         BUG_ON(!S_ISREG(inode->i_mode));
         err = sync_mapping_buffers(inode->i_mapping);
         reiserfs_write_lock(inode->i_sb);
@@ -166,7 +166,7 @@ static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end,
         reiserfs_write_unlock(inode->i_sb);
         if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
                 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (barrier_done < 0)
                 return barrier_done;
         return (err < 0) ? -EIO : 0;
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index 6ec8a30a0911..036a1fc0a8c3 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -224,7 +224,7 @@ out_unlock:
         page_cache_release(page);
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         reiserfs_write_unlock(inode->i_sb);
         return retval;
 }
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index e5ddb4e5ea94..57e0b2310532 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -64,14 +64,14 @@
 #ifdef CONFIG_REISERFS_FS_XATTR
 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
 {
-        BUG_ON(!mutex_is_locked(&dir->i_mutex));
+        BUG_ON(!inode_is_locked(dir));
         return dir->i_op->create(dir, dentry, mode, true);
 }
 #endif
 
 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
-        BUG_ON(!mutex_is_locked(&dir->i_mutex));
+        BUG_ON(!inode_is_locked(dir));
         return dir->i_op->mkdir(dir, dentry, mode);
 }
 
@@ -85,11 +85,11 @@ static int xattr_unlink(struct inode *dir, struct dentry *dentry)
 {
         int error;
 
-        BUG_ON(!mutex_is_locked(&dir->i_mutex));
+        BUG_ON(!inode_is_locked(dir));
 
-        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
         error = dir->i_op->unlink(dir, dentry);
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
 
         if (!error)
                 d_delete(dentry);
@@ -100,13 +100,13 @@ static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
 {
         int error;
 
-        BUG_ON(!mutex_is_locked(&dir->i_mutex));
+        BUG_ON(!inode_is_locked(dir));
 
-        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
         error = dir->i_op->rmdir(dir, dentry);
         if (!error)
                 d_inode(dentry)->i_flags |= S_DEAD;
-        mutex_unlock(&d_inode(dentry)->i_mutex);
+        inode_unlock(d_inode(dentry));
         if (!error)
                 d_delete(dentry);
 
@@ -123,7 +123,7 @@ static struct dentry *open_xa_root(struct super_block *sb, int flags)
         if (d_really_is_negative(privroot))
                 return ERR_PTR(-ENODATA);
 
-        mutex_lock_nested(&d_inode(privroot)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(privroot), I_MUTEX_XATTR);
 
         xaroot = dget(REISERFS_SB(sb)->xattr_root);
         if (!xaroot)
@@ -139,7 +139,7 @@ static struct dentry *open_xa_root(struct super_block *sb, int flags)
                 }
         }
 
-        mutex_unlock(&d_inode(privroot)->i_mutex);
+        inode_unlock(d_inode(privroot));
         return xaroot;
 }
 
@@ -156,7 +156,7 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
                  le32_to_cpu(INODE_PKEY(inode)->k_objectid),
                  inode->i_generation);
 
-        mutex_lock_nested(&d_inode(xaroot)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(xaroot), I_MUTEX_XATTR);
 
         xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
         if (!IS_ERR(xadir) && d_really_is_negative(xadir)) {
@@ -170,7 +170,7 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
                 }
         }
 
-        mutex_unlock(&d_inode(xaroot)->i_mutex);
+        inode_unlock(d_inode(xaroot));
         dput(xaroot);
         return xadir;
 }
@@ -195,7 +195,7 @@ fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
                 container_of(ctx, struct reiserfs_dentry_buf, ctx);
         struct dentry *dentry;
 
-        WARN_ON_ONCE(!mutex_is_locked(&d_inode(dbuf->xadir)->i_mutex));
+        WARN_ON_ONCE(!inode_is_locked(d_inode(dbuf->xadir)));
 
         if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
                 return -ENOSPC;
@@ -254,7 +254,7 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                 goto out_dir;
         }
 
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
 
         buf.xadir = dir;
         while (1) {
@@ -276,7 +276,7 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                         break;
                 buf.count = 0;
         }
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 
         cleanup_dentry_buf(&buf);
 
@@ -298,13 +298,13 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                 if (!err) {
                         int jerror;
 
-                        mutex_lock_nested(&d_inode(dir->d_parent)->i_mutex,
+                        inode_lock_nested(d_inode(dir->d_parent),
                                           I_MUTEX_XATTR);
                         err = action(dir, data);
                         reiserfs_write_lock(inode->i_sb);
                         jerror = journal_end(&th);
                         reiserfs_write_unlock(inode->i_sb);
-                        mutex_unlock(&d_inode(dir->d_parent)->i_mutex);
+                        inode_unlock(d_inode(dir->d_parent));
                         err = jerror ?: err;
                 }
         }
@@ -384,7 +384,7 @@ static struct dentry *xattr_lookup(struct inode *inode, const char *name,
         if (IS_ERR(xadir))
                 return ERR_CAST(xadir);
 
-        mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
         xafile = lookup_one_len(name, xadir, strlen(name));
         if (IS_ERR(xafile)) {
                 err = PTR_ERR(xafile);
@@ -404,7 +404,7 @@ static struct dentry *xattr_lookup(struct inode *inode, const char *name,
         if (err)
                 dput(xafile);
 out:
-        mutex_unlock(&d_inode(xadir)->i_mutex);
+        inode_unlock(d_inode(xadir));
         dput(xadir);
         if (err)
                 return ERR_PTR(err);
@@ -469,7 +469,7 @@ static int lookup_and_delete_xattr(struct inode *inode, const char *name)
         if (IS_ERR(xadir))
                 return PTR_ERR(xadir);
 
-        mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
         dentry = lookup_one_len(name, xadir, strlen(name));
         if (IS_ERR(dentry)) {
                 err = PTR_ERR(dentry);
@@ -483,7 +483,7 @@ static int lookup_and_delete_xattr(struct inode *inode, const char *name)
 
         dput(dentry);
 out_dput:
-        mutex_unlock(&d_inode(xadir)->i_mutex);
+        inode_unlock(d_inode(xadir));
         dput(xadir);
         return err;
 }
@@ -580,11 +580,11 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                         .ia_valid = ATTR_SIZE | ATTR_CTIME,
                 };
 
-                mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_XATTR);
+                inode_lock_nested(d_inode(dentry), I_MUTEX_XATTR);
                 inode_dio_wait(d_inode(dentry));
 
                 err = reiserfs_setattr(dentry, &newattrs);
-                mutex_unlock(&d_inode(dentry)->i_mutex);
+                inode_unlock(d_inode(dentry));
         } else
                 update_ctime(inode);
 out_unlock:
@@ -888,9 +888,9 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                 goto out;
         }
 
-        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
+        inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
         err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
-        mutex_unlock(&d_inode(dir)->i_mutex);
+        inode_unlock(d_inode(dir));
 
         if (!err)
                 err = buf.pos;
@@ -905,7 +905,7 @@ static int create_privroot(struct dentry *dentry)
         int err;
         struct inode *inode = d_inode(dentry->d_parent);
 
-        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
+        WARN_ON_ONCE(!inode_is_locked(inode));
 
         err = xattr_mkdir(inode, dentry, 0700);
         if (err || d_really_is_negative(dentry)) {
@@ -995,7 +995,7 @@ int reiserfs_lookup_privroot(struct super_block *s)
         int err = 0;
 
         /* If we don't have the privroot located yet - go find it */
-        mutex_lock(&d_inode(s->s_root)->i_mutex);
+        inode_lock(d_inode(s->s_root));
         dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
                                 strlen(PRIVROOT_NAME));
         if (!IS_ERR(dentry)) {
@@ -1005,7 +1005,7 @@ int reiserfs_lookup_privroot(struct super_block *s)
                         d_inode(dentry)->i_flags |= S_PRIVATE;
         } else
                 err = PTR_ERR(dentry);
-        mutex_unlock(&d_inode(s->s_root)->i_mutex);
+        inode_unlock(d_inode(s->s_root));
 
         return err;
 }
@@ -1025,14 +1025,14 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                 goto error;
 
         if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) {
-                mutex_lock(&d_inode(s->s_root)->i_mutex);
+                inode_lock(d_inode(s->s_root));
                 err = create_privroot(REISERFS_SB(s)->priv_root);
-                mutex_unlock(&d_inode(s->s_root)->i_mutex);
+                inode_unlock(d_inode(s->s_root));
         }
 
         if (d_really_is_positive(privroot)) {
                 s->s_xattr = reiserfs_xattr_handlers;
-                mutex_lock(&d_inode(privroot)->i_mutex);
+                inode_lock(d_inode(privroot));
                 if (!REISERFS_SB(s)->xattr_root) {
                         struct dentry *dentry;
 
@@ -1043,7 +1043,7 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                         else
                                 err = PTR_ERR(dentry);
                 }
-                mutex_unlock(&d_inode(privroot)->i_mutex);
+                inode_unlock(d_inode(privroot));
         }
 
 error:
diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c
index c66f2423e1f5..4a0e48f92104 100644
--- a/fs/tracefs/inode.c
+++ b/fs/tracefs/inode.c
@@ -84,9 +84,9 @@ static int tracefs_syscall_mkdir(struct inode *inode, struct dentry *dentry, umo
          * the files within the tracefs system. It is up to the individual
          * mkdir routine to handle races.
          */
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         ret = tracefs_ops.mkdir(name);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         kfree(name);
 
@@ -109,13 +109,13 @@ static int tracefs_syscall_rmdir(struct inode *inode, struct dentry *dentry)
          * This time we need to unlock not only the parent (inode) but
          * also the directory that is being deleted.
          */
-        mutex_unlock(&inode->i_mutex);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        inode_unlock(inode);
+        inode_unlock(dentry->d_inode);
 
         ret = tracefs_ops.rmdir(name);
 
-        mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
-        mutex_lock(&dentry->d_inode->i_mutex);
+        inode_lock_nested(inode, I_MUTEX_PARENT);
+        inode_lock(dentry->d_inode);
 
         kfree(name);
 
@@ -334,7 +334,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
         if (!parent)
                 parent = tracefs_mount->mnt_root;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
         dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(dentry) && dentry->d_inode) {
                 dput(dentry);
@@ -342,7 +342,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
         }
 
         if (IS_ERR(dentry)) {
-                mutex_unlock(&parent->d_inode->i_mutex);
+                inode_unlock(parent->d_inode);
                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
         }
 
@@ -351,7 +351,7 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
 
 static struct dentry *failed_creating(struct dentry *dentry)
 {
-        mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+        inode_unlock(dentry->d_parent->d_inode);
         dput(dentry);
         simple_release_fs(&tracefs_mount, &tracefs_mount_count);
         return NULL;
@@ -359,7 +359,7 @@ static struct dentry *failed_creating(struct dentry *dentry)
 
 static struct dentry *end_creating(struct dentry *dentry)
 {
-        mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+        inode_unlock(dentry->d_parent->d_inode);
         return dentry;
 }
 
@@ -544,9 +544,9 @@ void tracefs_remove(struct dentry *dentry)
         if (!parent || !parent->d_inode)
                 return;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
         ret = __tracefs_remove(dentry, parent);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        inode_unlock(parent->d_inode);
         if (!ret)
                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
 }
@@ -572,7 +572,7 @@ void tracefs_remove_recursive(struct dentry *dentry)
 
         parent = dentry;
  down:
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
  loop:
         /*
          * The parent->d_subdirs is protected by the d_lock. Outside that
@@ -587,7 +587,7 @@ void tracefs_remove_recursive(struct dentry *dentry)
                 /* perhaps simple_empty(child) makes more sense */
                 if (!list_empty(&child->d_subdirs)) {
                         spin_unlock(&parent->d_lock);
-                        mutex_unlock(&parent->d_inode->i_mutex);
+                        inode_unlock(parent->d_inode);
                         parent = child;
                         goto down;
                 }
@@ -608,10 +608,10 @@ void tracefs_remove_recursive(struct dentry *dentry)
         }
         spin_unlock(&parent->d_lock);
 
-        mutex_unlock(&parent->d_inode->i_mutex);
+        inode_unlock(parent->d_inode);
         child = parent;
         parent = parent->d_parent;
-        mutex_lock(&parent->d_inode->i_mutex);
+        inode_lock(parent->d_inode);
 
         if (child != dentry)
                 /* go up */
@@ -619,7 +619,7 @@ void tracefs_remove_recursive(struct dentry *dentry)
 
         if (!__tracefs_remove(child, parent))
                 simple_release_fs(&tracefs_mount, &tracefs_mount_count);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        inode_unlock(parent->d_inode);
 }
 
 /**
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index e49bd2808bf3..795992a8321e 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -515,8 +515,8 @@ static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
         dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
                 dentry, inode->i_ino,
                 inode->i_nlink, dir->i_ino);
-        ubifs_assert(mutex_is_locked(&dir->i_mutex));
-        ubifs_assert(mutex_is_locked(&inode->i_mutex));
+        ubifs_assert(inode_is_locked(dir));
+        ubifs_assert(inode_is_locked(inode));
 
         err = dbg_check_synced_i_size(c, inode);
         if (err)
@@ -572,8 +572,8 @@ static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
         dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
                 dentry, inode->i_ino,
                 inode->i_nlink, dir->i_ino);
-        ubifs_assert(mutex_is_locked(&dir->i_mutex));
-        ubifs_assert(mutex_is_locked(&inode->i_mutex));
+        ubifs_assert(inode_is_locked(dir));
+        ubifs_assert(inode_is_locked(inode));
         err = dbg_check_synced_i_size(c, inode);
         if (err)
                 return err;
@@ -661,8 +661,8 @@ static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
 
         dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
                 inode->i_ino, dir->i_ino);
-        ubifs_assert(mutex_is_locked(&dir->i_mutex));
-        ubifs_assert(mutex_is_locked(&inode->i_mutex));
+        ubifs_assert(inode_is_locked(dir));
+        ubifs_assert(inode_is_locked(inode));
         err = check_dir_empty(c, d_inode(dentry));
         if (err)
                 return err;
@@ -996,10 +996,10 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
                 old_dentry, old_inode->i_ino, old_dir->i_ino,
                 new_dentry, new_dir->i_ino);
-        ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
-        ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
+        ubifs_assert(inode_is_locked(old_dir));
+        ubifs_assert(inode_is_locked(new_dir));
         if (unlink)
-                ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
+                ubifs_assert(inode_is_locked(new_inode));
 
 
         if (unlink && is_dir) {
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index eff62801acbf..065c88f8e4b8 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1317,7 +1317,7 @@ int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         err = filemap_write_and_wait_range(inode->i_mapping, start, end);
         if (err)
                 return err;
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         /* Synchronize the inode unless this is a 'datasync()' call. */
         if (!datasync || (inode->i_state & I_DIRTY_DATASYNC)) {
@@ -1332,7 +1332,7 @@ int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
          */
         err = ubifs_sync_wbufs_by_inode(c, inode);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err;
 }
 
diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c
index e53292d0c21b..c7f4d434d098 100644
--- a/fs/ubifs/xattr.c
+++ b/fs/ubifs/xattr.c
@@ -313,7 +313,7 @@ static int setxattr(struct inode *host, const char *name, const void *value,
         union ubifs_key key;
         int err, type;
 
-        ubifs_assert(mutex_is_locked(&host->i_mutex));
+        ubifs_assert(inode_is_locked(host));
 
         if (size > UBIFS_MAX_INO_DATA)
                 return -ERANGE;
@@ -550,7 +550,7 @@ int ubifs_removexattr(struct dentry *dentry, const char *name)
 
         dbg_gen("xattr '%s', ino %lu ('%pd')", name,
                 host->i_ino, dentry);
-        ubifs_assert(mutex_is_locked(&host->i_mutex));
+        ubifs_assert(inode_is_locked(host));
 
         err = check_namespace(&nm);
         if (err < 0)
diff --git a/fs/udf/file.c b/fs/udf/file.c
index bddf3d071dae..1af98963d860 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -122,7 +122,7 @@ static ssize_t udf_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         struct udf_inode_info *iinfo = UDF_I(inode);
         int err;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         retval = generic_write_checks(iocb, from);
         if (retval <= 0)
@@ -136,7 +136,7 @@ static ssize_t udf_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                                 (udf_file_entry_alloc_offset(inode) + end)) {
                         err = udf_expand_file_adinicb(inode);
                         if (err) {
-                                mutex_unlock(&inode->i_mutex);
+                                inode_unlock(inode);
                                 udf_debug("udf_expand_adinicb: err=%d\n", err);
                                 return err;
                         }
@@ -149,7 +149,7 @@ static ssize_t udf_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 
         retval = __generic_file_write_iter(iocb, from);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (retval > 0) {
                 mark_inode_dirty(inode);
@@ -223,12 +223,12 @@ static int udf_release_file(struct inode *inode, struct file *filp)
                  * Grab i_mutex to avoid races with writes changing i_size
                  * while we are running.
                  */
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 down_write(&UDF_I(inode)->i_data_sem);
                 udf_discard_prealloc(inode);
                 udf_truncate_tail_extent(inode);
                 up_write(&UDF_I(inode)->i_data_sem);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         return 0;
 }
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 87dc16d15572..166d3ed32c39 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -262,7 +262,7 @@ int udf_expand_file_adinicb(struct inode *inode)
                 .nr_to_write = 1,
         };
 
-        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
+        WARN_ON_ONCE(!inode_is_locked(inode));
         if (!iinfo->i_lenAlloc) {
                 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
                         iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
diff --git a/fs/utimes.c b/fs/utimes.c
index aa138d64560a..85c40f4f373d 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -103,9 +103,9 @@ static int utimes_common(struct path *path, struct timespec *times)
                 }
         }
 retry_deleg:
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = notify_change(path->dentry, &newattrs, &delegated_inode);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (delegated_inode) {
                 error = break_deleg_wait(&delegated_inode);
                 if (!error)
diff --git a/fs/xattr.c b/fs/xattr.c
index d5dd6c8b82a7..07d0e47f6a7f 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -129,7 +129,7 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
         if (error)
                 return error;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = security_inode_setxattr(dentry, name, value, size, flags);
         if (error)
                 goto out;
@@ -137,7 +137,7 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
         error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return error;
 }
 EXPORT_SYMBOL_GPL(vfs_setxattr);
@@ -277,7 +277,7 @@ vfs_removexattr(struct dentry *dentry, const char *name)
         if (error)
                 return error;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         error = security_inode_removexattr(dentry, name);
         if (error)
                 goto out;
@@ -290,7 +290,7 @@ vfs_removexattr(struct dentry *dentry, const char *name)
         }
 
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return error;
 }
 EXPORT_SYMBOL_GPL(vfs_removexattr);
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index ebe9b8290a70..bb2b8f354041 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -55,7 +55,7 @@ xfs_rw_ilock(
         int                     type)
 {
         if (type & XFS_IOLOCK_EXCL)
-                mutex_lock(&VFS_I(ip)->i_mutex);
+                inode_lock(VFS_I(ip));
         xfs_ilock(ip, type);
 }
 
@@ -66,7 +66,7 @@ xfs_rw_iunlock(
 {
         xfs_iunlock(ip, type);
         if (type & XFS_IOLOCK_EXCL)
-                mutex_unlock(&VFS_I(ip)->i_mutex);
+                inode_unlock(VFS_I(ip));
 }
 
 static inline void
@@ -76,7 +76,7 @@ xfs_rw_ilock_demote(
 {
         xfs_ilock_demote(ip, type);
         if (type & XFS_IOLOCK_EXCL)
-                mutex_unlock(&VFS_I(ip)->i_mutex);
+                inode_unlock(VFS_I(ip));
 }
 
 /*
diff --git a/fs/xfs/xfs_pnfs.c b/fs/xfs/xfs_pnfs.c
index dc6221942b85..ade236e90bb3 100644
--- a/fs/xfs/xfs_pnfs.c
+++ b/fs/xfs/xfs_pnfs.c
@@ -42,11 +42,11 @@ xfs_break_layouts(
         while ((error = break_layout(inode, false) == -EWOULDBLOCK)) {
                 xfs_iunlock(ip, *iolock);
                 if (with_imutex && (*iolock & XFS_IOLOCK_EXCL))
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                 error = break_layout(inode, true);
                 *iolock = XFS_IOLOCK_EXCL;
                 if (with_imutex)
-                        mutex_lock(&inode->i_mutex);
+                        inode_lock(inode);
                 xfs_ilock(ip, *iolock);
         }
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index eb73d74ed992..2df6c033c3f5 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -714,6 +714,31 @@ enum inode_i_mutex_lock_class
         I_MUTEX_PARENT2,
 };
 
+static inline void inode_lock(struct inode *inode)
+{
+        mutex_lock(&inode->i_mutex);
+}
+
+static inline void inode_unlock(struct inode *inode)
+{
+        mutex_unlock(&inode->i_mutex);
+}
+
+static inline int inode_trylock(struct inode *inode)
+{
+        return mutex_trylock(&inode->i_mutex);
+}
+
+static inline int inode_is_locked(struct inode *inode)
+{
+        return mutex_is_locked(&inode->i_mutex);
+}
+
+static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
+{
+        mutex_lock_nested(&inode->i_mutex, subclass);
+}
+
 void lock_two_nondirectories(struct inode *, struct inode*);
 void unlock_two_nondirectories(struct inode *, struct inode*);
 
@@ -3047,8 +3072,8 @@ static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
 }
 static inline bool dir_relax(struct inode *inode)
 {
-        mutex_unlock(&inode->i_mutex);
-        mutex_lock(&inode->i_mutex);
+        inode_unlock(inode);
+        inode_lock(inode);
         return !IS_DEADDIR(inode);
 }
 
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index f4617cf07069..781c1399c6a3 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -795,7 +795,7 @@ SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,
 
         ro = mnt_want_write(mnt);       /* we'll drop it in any case */
         error = 0;
-        mutex_lock(&d_inode(root)->i_mutex);
+        inode_lock(d_inode(root));
         path.dentry = lookup_one_len(name->name, root, strlen(name->name));
         if (IS_ERR(path.dentry)) {
                 error = PTR_ERR(path.dentry);
@@ -841,7 +841,7 @@ out_putfd:
                 put_unused_fd(fd);
                 fd = error;
         }
-        mutex_unlock(&d_inode(root)->i_mutex);
+        inode_unlock(d_inode(root));
         if (!ro)
                 mnt_drop_write(mnt);
 out_putname:
@@ -866,7 +866,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
         err = mnt_want_write(mnt);
         if (err)
                 goto out_name;
-        mutex_lock_nested(&d_inode(mnt->mnt_root)->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(d_inode(mnt->mnt_root), I_MUTEX_PARENT);
         dentry = lookup_one_len(name->name, mnt->mnt_root,
                                 strlen(name->name));
         if (IS_ERR(dentry)) {
@@ -884,7 +884,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
         dput(dentry);
 
 out_unlock:
-        mutex_unlock(&d_inode(mnt->mnt_root)->i_mutex);
+        inode_unlock(d_inode(mnt->mnt_root));
         if (inode)
                 iput(inode);
         mnt_drop_write(mnt);
diff --git a/kernel/audit_fsnotify.c b/kernel/audit_fsnotify.c
index 27c6046c2c3d..f84f8d06e1f6 100644
--- a/kernel/audit_fsnotify.c
+++ b/kernel/audit_fsnotify.c
@@ -95,7 +95,7 @@ struct audit_fsnotify_mark *audit_alloc_mark(struct audit_krule *krule, char *pa
         if (IS_ERR(dentry))
                 return (void *)dentry; /* returning an error */
         inode = path.dentry->d_inode;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         audit_mark = kzalloc(sizeof(*audit_mark), GFP_KERNEL);
         if (unlikely(!audit_mark)) {
diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
index 656c7e93ac0d..9f194aad0adc 100644
--- a/kernel/audit_watch.c
+++ b/kernel/audit_watch.c
@@ -364,7 +364,7 @@ static int audit_get_nd(struct audit_watch *watch, struct path *parent)
         struct dentry *d = kern_path_locked(watch->path, parent);
         if (IS_ERR(d))
                 return PTR_ERR(d);
-        mutex_unlock(&d_backing_inode(parent->dentry)->i_mutex);
+        inode_unlock(d_backing_inode(parent->dentry));
         if (d_is_positive(d)) {
                 /* update watch filter fields */
                 watch->dev = d_backing_inode(d)->i_sb->s_dev;
diff --git a/kernel/events/core.c b/kernel/events/core.c
index c0957416b32e..06ae52e99ac2 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -4872,9 +4872,9 @@ static int perf_fasync(int fd, struct file *filp, int on)
         struct perf_event *event = filp->private_data;
         int retval;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         retval = fasync_helper(fd, filp, on, &event->fasync);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (retval < 0)
                 return retval;
diff --git a/kernel/relay.c b/kernel/relay.c
index 0b4570cfacae..074994bcfa9b 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -1133,7 +1133,7 @@ static ssize_t relay_file_read_subbufs(struct file *filp, loff_t *ppos,
         if (!desc->count)
                 return 0;
 
-        mutex_lock(&file_inode(filp)->i_mutex);
+        inode_lock(file_inode(filp));
         do {
                 if (!relay_file_read_avail(buf, *ppos))
                         break;
@@ -1153,7 +1153,7 @@ static ssize_t relay_file_read_subbufs(struct file *filp, loff_t *ppos,
                         *ppos = relay_file_read_end_pos(buf, read_start, ret);
                 }
         } while (desc->count && ret);
-        mutex_unlock(&file_inode(filp)->i_mutex);
+        inode_unlock(file_inode(filp));
 
         return desc->written;
 }
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 44253adb3c36..63d3a24e081a 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -222,9 +222,9 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
 
         /* Ensure the static_key remains in a consistent state */
         inode = file_inode(filp);
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         i = sched_feat_set(cmp);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if (i == __SCHED_FEAT_NR)
                 return -EINVAL;
 
diff --git a/mm/filemap.c b/mm/filemap.c
index 847ee43c2806..30ab120b33db 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2684,11 +2684,11 @@ ssize_t generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
         struct inode *inode = file->f_mapping->host;
         ssize_t ret;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = generic_write_checks(iocb, from);
         if (ret > 0)
                 ret = __generic_file_write_iter(iocb, from);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 
         if (ret > 0) {
                 ssize_t err;
diff --git a/mm/shmem.c b/mm/shmem.c
index fa2ceb2d2655..38c5e72c7008 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -1902,7 +1902,7 @@ static loff_t shmem_file_llseek(struct file *file, loff_t offset, int whence)
         if (whence != SEEK_DATA && whence != SEEK_HOLE)
                 return generic_file_llseek_size(file, offset, whence,
                                         MAX_LFS_FILESIZE, i_size_read(inode));
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         /* We're holding i_mutex so we can access i_size directly */
 
         if (offset < 0)
@@ -1926,7 +1926,7 @@ static loff_t shmem_file_llseek(struct file *file, loff_t offset, int whence)
 
         if (offset >= 0)
                 offset = vfs_setpos(file, offset, MAX_LFS_FILESIZE);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return offset;
 }
 
@@ -2091,7 +2091,7 @@ int shmem_add_seals(struct file *file, unsigned int seals)
         if (seals & ~(unsigned int)F_ALL_SEALS)
                 return -EINVAL;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (info->seals & F_SEAL_SEAL) {
                 error = -EPERM;
@@ -2114,7 +2114,7 @@ int shmem_add_seals(struct file *file, unsigned int seals)
         error = 0;
 
 unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return error;
 }
 EXPORT_SYMBOL_GPL(shmem_add_seals);
@@ -2164,7 +2164,7 @@ static long shmem_fallocate(struct file *file, int mode, loff_t offset,
         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (mode & FALLOC_FL_PUNCH_HOLE) {
                 struct address_space *mapping = file->f_mapping;
@@ -2277,7 +2277,7 @@ undone:
         inode->i_private = NULL;
         spin_unlock(&inode->i_lock);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return error;
 }
 
diff --git a/mm/swapfile.c b/mm/swapfile.c
index c43f654a7b64..d2c37365e2d6 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1956,9 +1956,9 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
                 set_blocksize(bdev, old_block_size);
                 blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
         } else {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 inode->i_flags &= ~S_SWAPFILE;
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
         filp_close(swap_file, NULL);
 
@@ -2183,7 +2183,7 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)
                 p->flags |= SWP_BLKDEV;
         } else if (S_ISREG(inode->i_mode)) {
                 p->bdev = inode->i_sb->s_bdev;
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 if (IS_SWAPFILE(inode))
                         return -EBUSY;
         } else
@@ -2416,7 +2416,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
         mapping = swap_file->f_mapping;
         inode = mapping->host;
 
-        /* If S_ISREG(inode->i_mode) will do mutex_lock(&inode->i_mutex); */
+        /* If S_ISREG(inode->i_mode) will do inode_lock(inode); */
         error = claim_swapfile(p, inode);
         if (unlikely(error))
                 goto bad_swap;
@@ -2561,7 +2561,7 @@ bad_swap:
         vfree(cluster_info);
         if (swap_file) {
                 if (inode && S_ISREG(inode->i_mode)) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         inode = NULL;
                 }
                 filp_close(swap_file, NULL);
@@ -2574,7 +2574,7 @@ out:
         if (name)
                 putname(name);
         if (inode && S_ISREG(inode->i_mode))
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         return error;
 }
 
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 5e4f815c2b34..2b32fd602669 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -771,7 +771,7 @@ static ssize_t cache_read(struct file *filp, char __user *buf, size_t count,
         if (count == 0)
                 return 0;
 
-        mutex_lock(&inode->i_mutex); /* protect against multiple concurrent
+        inode_lock(inode); /* protect against multiple concurrent
                               * readers on this file */
  again:
         spin_lock(&queue_lock);
@@ -784,7 +784,7 @@ static ssize_t cache_read(struct file *filp, char __user *buf, size_t count,
         }
         if (rp->q.list.next == &cd->queue) {
                 spin_unlock(&queue_lock);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 WARN_ON_ONCE(rp->offset);
                 return 0;
         }
@@ -838,7 +838,7 @@ static ssize_t cache_read(struct file *filp, char __user *buf, size_t count,
         }
         if (err == -EAGAIN)
                 goto again;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return err ? err :  count;
 }
 
@@ -909,9 +909,9 @@ static ssize_t cache_write(struct file *filp, const char __user *buf,
         if (!cd->cache_parse)
                 goto out;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         ret = cache_downcall(mapping, buf, count, cd);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 out:
         return ret;
 }
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 14f45bf0410c..31789ef3e614 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -172,7 +172,7 @@ rpc_close_pipes(struct inode *inode)
         int need_release;
         LIST_HEAD(free_list);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         spin_lock(&pipe->lock);
         need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
         pipe->nreaders = 0;
@@ -188,7 +188,7 @@ rpc_close_pipes(struct inode *inode)
         cancel_delayed_work_sync(&pipe->queue_timeout);
         rpc_inode_setowner(inode, NULL);
         RPC_I(inode)->pipe = NULL;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 }
 
 static struct inode *
@@ -221,7 +221,7 @@ rpc_pipe_open(struct inode *inode, struct file *filp)
         int first_open;
         int res = -ENXIO;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         pipe = RPC_I(inode)->pipe;
         if (pipe == NULL)
                 goto out;
@@ -237,7 +237,7 @@ rpc_pipe_open(struct inode *inode, struct file *filp)
                 pipe->nwriters++;
         res = 0;
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return res;
 }
 
@@ -248,7 +248,7 @@ rpc_pipe_release(struct inode *inode, struct file *filp)
         struct rpc_pipe_msg *msg;
         int last_close;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         pipe = RPC_I(inode)->pipe;
         if (pipe == NULL)
                 goto out;
@@ -278,7 +278,7 @@ rpc_pipe_release(struct inode *inode, struct file *filp)
         if (last_close && pipe->ops->release_pipe)
                 pipe->ops->release_pipe(inode);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return 0;
 }
 
@@ -290,7 +290,7 @@ rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
         struct rpc_pipe_msg *msg;
         int res = 0;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         pipe = RPC_I(inode)->pipe;
         if (pipe == NULL) {
                 res = -EPIPE;
@@ -322,7 +322,7 @@ rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
                 pipe->ops->destroy_msg(msg);
         }
 out_unlock:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return res;
 }
 
@@ -332,11 +332,11 @@ rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *of
         struct inode *inode = file_inode(filp);
         int res;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         res = -EPIPE;
         if (RPC_I(inode)->pipe != NULL)
                 res = RPC_I(inode)->pipe->ops->downcall(filp, buf, len);
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return res;
 }
 
@@ -349,12 +349,12 @@ rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
 
         poll_wait(filp, &rpci->waitq, wait);
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         if (rpci->pipe == NULL)
                 mask |= POLLERR | POLLHUP;
         else if (filp->private_data || !list_empty(&rpci->pipe->pipe))
                 mask |= POLLIN | POLLRDNORM;
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         return mask;
 }
 
@@ -367,10 +367,10 @@ rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
         switch (cmd) {
         case FIONREAD:
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 pipe = RPC_I(inode)->pipe;
                 if (pipe == NULL) {
-                        mutex_unlock(&inode->i_mutex);
+                        inode_unlock(inode);
                         return -EPIPE;
                 }
                 spin_lock(&pipe->lock);
@@ -381,7 +381,7 @@ rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                         len += msg->len - msg->copied;
                 }
                 spin_unlock(&pipe->lock);
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
                 return put_user(len, (int __user *)arg);
         default:
                 return -EINVAL;
@@ -617,9 +617,9 @@ int rpc_rmdir(struct dentry *dentry)
 
         parent = dget_parent(dentry);
         dir = d_inode(parent);
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         error = __rpc_rmdir(dir, dentry);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         dput(parent);
         return error;
 }
@@ -701,9 +701,9 @@ static void rpc_depopulate(struct dentry *parent,
 {
         struct inode *dir = d_inode(parent);
 
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
+        inode_lock_nested(dir, I_MUTEX_CHILD);
         __rpc_depopulate(parent, files, start, eof);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
 }
 
 static int rpc_populate(struct dentry *parent,
@@ -715,7 +715,7 @@ static int rpc_populate(struct dentry *parent,
         struct dentry *dentry;
         int i, err;
 
-        mutex_lock(&dir->i_mutex);
+        inode_lock(dir);
         for (i = start; i < eof; i++) {
                 dentry = __rpc_lookup_create_exclusive(parent, files[i].name);
                 err = PTR_ERR(dentry);
@@ -739,11 +739,11 @@ static int rpc_populate(struct dentry *parent,
                 if (err != 0)
                         goto out_bad;
         }
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         return 0;
 out_bad:
         __rpc_depopulate(parent, files, start, eof);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         printk(KERN_WARNING "%s: %s failed to populate directory %pd\n",
                         __FILE__, __func__, parent);
         return err;
@@ -757,7 +757,7 @@ static struct dentry *rpc_mkdir_populate(struct dentry *parent,
         struct inode *dir = d_inode(parent);
         int error;
 
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         dentry = __rpc_lookup_create_exclusive(parent, name);
         if (IS_ERR(dentry))
                 goto out;
@@ -770,7 +770,7 @@ static struct dentry *rpc_mkdir_populate(struct dentry *parent,
                         goto err_rmdir;
         }
 out:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         return dentry;
 err_rmdir:
         __rpc_rmdir(dir, dentry);
@@ -788,11 +788,11 @@ static int rpc_rmdir_depopulate(struct dentry *dentry,
 
         parent = dget_parent(dentry);
         dir = d_inode(parent);
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         if (depopulate != NULL)
                 depopulate(dentry);
         error = __rpc_rmdir(dir, dentry);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         dput(parent);
         return error;
 }
@@ -828,7 +828,7 @@ struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
         if (pipe->ops->downcall == NULL)
                 umode &= ~S_IWUGO;
 
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         dentry = __rpc_lookup_create_exclusive(parent, name);
         if (IS_ERR(dentry))
                 goto out;
@@ -837,7 +837,7 @@ struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
         if (err)
                 goto out_err;
 out:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         return dentry;
 out_err:
         dentry = ERR_PTR(err);
@@ -865,9 +865,9 @@ rpc_unlink(struct dentry *dentry)
 
         parent = dget_parent(dentry);
         dir = d_inode(parent);
-        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+        inode_lock_nested(dir, I_MUTEX_PARENT);
         error = __rpc_rmpipe(dir, dentry);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         dput(parent);
         return error;
 }
diff --git a/security/inode.c b/security/inode.c
index 16622aef9bde..28414b0207ce 100644
--- a/security/inode.c
+++ b/security/inode.c
@@ -99,7 +99,7 @@ struct dentry *securityfs_create_file(const char *name, umode_t mode,
 
         dir = d_inode(parent);
 
-        mutex_lock(&dir->i_mutex);
+        inode_lock(dir);
         dentry = lookup_one_len(name, parent, strlen(name));
         if (IS_ERR(dentry))
                 goto out;
@@ -129,14 +129,14 @@ struct dentry *securityfs_create_file(const char *name, umode_t mode,
         }
         d_instantiate(dentry, inode);
         dget(dentry);
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         return dentry;
 
 out1:
         dput(dentry);
         dentry = ERR_PTR(error);
 out:
-        mutex_unlock(&dir->i_mutex);
+        inode_unlock(dir);
         simple_release_fs(&mount, &mount_count);
         return dentry;
 }
@@ -195,7 +195,7 @@ void securityfs_remove(struct dentry *dentry)
         if (!parent || d_really_is_negative(parent))
                 return;
 
-        mutex_lock(&d_inode(parent)->i_mutex);
+        inode_lock(d_inode(parent));
         if (simple_positive(dentry)) {
                 if (d_is_dir(dentry))
                         simple_rmdir(d_inode(parent), dentry);
@@ -203,7 +203,7 @@ void securityfs_remove(struct dentry *dentry)
                         simple_unlink(d_inode(parent), dentry);
                 dput(dentry);
         }
-        mutex_unlock(&d_inode(parent)->i_mutex);
+        inode_unlock(d_inode(parent));
         simple_release_fs(&mount, &mount_count);
 }
 EXPORT_SYMBOL_GPL(securityfs_remove);
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index c21f09bf8b99..9d96551d0196 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -121,7 +121,7 @@ static void ima_check_last_writer(struct integrity_iint_cache *iint,
         if (!(mode & FMODE_WRITE))
                 return;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
         if (atomic_read(&inode->i_writecount) == 1) {
                 if ((iint->version != inode->i_version) ||
                     (iint->flags & IMA_NEW_FILE)) {
@@ -130,7 +130,7 @@ static void ima_check_last_writer(struct integrity_iint_cache *iint,
                                 ima_update_xattr(iint, file);
                 }
         }
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
 }
 
 /**
@@ -186,7 +186,7 @@ static int process_measurement(struct file *file, int mask, int function,
         if (action & IMA_FILE_APPRAISE)
                 function = FILE_CHECK;
 
-        mutex_lock(&inode->i_mutex);
+        inode_lock(inode);
 
         if (action) {
                 iint = integrity_inode_get(inode);
@@ -250,7 +250,7 @@ out_free:
         if (pathbuf)
                 __putname(pathbuf);
 out:
-        mutex_unlock(&inode->i_mutex);
+        inode_unlock(inode);
         if ((rc && must_appraise) && (ima_appraise & IMA_APPRAISE_ENFORCE))
                 return -EACCES;
         return 0;
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 732c1c77dccd..1b1fd27de632 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -380,9 +380,9 @@ static int sel_open_policy(struct inode *inode, struct file *filp)
                 goto err;
 
         if (i_size_read(inode) != security_policydb_len()) {
-                mutex_lock(&inode->i_mutex);
+                inode_lock(inode);
                 i_size_write(inode, security_policydb_len());
-                mutex_unlock(&inode->i_mutex);
+                inode_unlock(inode);
         }
 
         rc = security_read_policy(&plm->data, &plm->len);