wrappers for ->i_mutex access

parallel to mutex_{lock,unlock,trylock,is_locked,lock_nested},
inode_foo(inode) being mutex_foo(&inode->i_mutex).

Please, use those for access to ->i_mutex; over the coming cycle
->i_mutex will become rwsem, with ->lookup() done with it held
only shared.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

7 files changed, 40 insertions, 40 deletions

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))