direct_IO: use iov_iter_rw() instead of rw everywhere

The rw parameter to direct_IO is redundant with iov_iter->type, and
treated slightly differently just about everywhere it's used: some users
do rw & WRITE, and others do rw == WRITE where they should be doing a
bitwise check. Simplify this with the new iov_iter_rw() helper, which
always returns either READ or WRITE.

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

3 files changed, 17 insertions, 17 deletions

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index f63c3d5805c4..2031c994024e 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2152,8 +2152,8 @@ extern void ext4_da_update_reserve_space(struct inode *inode,
 /* indirect.c */
 extern int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
                                 struct ext4_map_blocks *map, int flags);
-extern ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
-                                struct iov_iter *iter, loff_t offset);
+extern ssize_t ext4_ind_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
+                                  loff_t offset);
 extern int ext4_ind_calc_metadata_amount(struct inode *inode, sector_t lblock);
 extern int ext4_ind_trans_blocks(struct inode *inode, int nrblocks);
 extern void ext4_ind_truncate(handle_t *, struct inode *inode);
diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
index cd81d01da0b0..3580629e42d3 100644
--- a/fs/ext4/indirect.c
+++ b/fs/ext4/indirect.c
@@ -642,8 +642,8 @@ out:
  * crashes then stale disk data _may_ be exposed inside the file. But current
  * VFS code falls back into buffered path in that case so we are safe.
  */
-ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
-                           struct iov_iter *iter, loff_t offset)
+ssize_t ext4_ind_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
+                           loff_t offset)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file->f_mapping->host;
@@ -654,7 +654,7 @@ ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
         size_t count = iov_iter_count(iter);
         int retries = 0;
 
-        if (rw == WRITE) {
+        if (iov_iter_rw(iter) == WRITE) {
                 loff_t final_size = offset + count;
 
                 if (final_size > inode->i_size) {
@@ -676,7 +676,7 @@ ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
         }
 
 retry:
-        if (rw == READ && ext4_should_dioread_nolock(inode)) {
+        if (iov_iter_rw(iter) == READ && ext4_should_dioread_nolock(inode)) {
                 /*
                  * Nolock dioread optimization may be dynamically disabled
                  * via ext4_inode_block_unlocked_dio(). Check inode's state
@@ -707,7 +707,7 @@ locked:
                         ret = blockdev_direct_IO(iocb, inode, iter, offset,
                                                  ext4_get_block);
 
-                if (unlikely((rw & WRITE) && ret < 0)) {
+                if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {
                         loff_t isize = i_size_read(inode);
                         loff_t end = offset + count;
 
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 76b8cba5d041..cf6ba6536035 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2952,8 +2952,8 @@ static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
  * if the machine crashes during the write.
  *
  */
-static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
-                              struct iov_iter *iter, loff_t offset)
+static ssize_t ext4_ext_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
+                                  loff_t offset)
 {
         struct file *file = iocb->ki_filp;
         struct inode *inode = file->f_mapping->host;
@@ -2966,8 +2966,8 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
         ext4_io_end_t *io_end = NULL;
 
         /* Use the old path for reads and writes beyond i_size. */
-        if (rw != WRITE || final_size > inode->i_size)
-                return ext4_ind_direct_IO(rw, iocb, iter, offset);
+        if (iov_iter_rw(iter) != WRITE || final_size > inode->i_size)
+                return ext4_ind_direct_IO(iocb, iter, offset);
 
         BUG_ON(iocb->private == NULL);
 
@@ -2976,7 +2976,7 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
          * conversion. This also disallows race between truncate() and
          * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
          */
-        if (rw == WRITE)
+        if (iov_iter_rw(iter) == WRITE)
                 atomic_inc(&inode->i_dio_count);
 
         /* If we do a overwrite dio, i_mutex locking can be released */
@@ -3078,7 +3078,7 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
         }
 
 retake_lock:
-        if (rw == WRITE)
+        if (iov_iter_rw(iter) == WRITE)
                 inode_dio_done(inode);
         /* take i_mutex locking again if we do a ovewrite dio */
         if (overwrite) {
@@ -3107,12 +3107,12 @@ static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
         if (ext4_has_inline_data(inode))
                 return 0;
 
-        trace_ext4_direct_IO_enter(inode, offset, count, rw);
+        trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
-                ret = ext4_ext_direct_IO(rw, iocb, iter, offset);
+                ret = ext4_ext_direct_IO(iocb, iter, offset);
         else
-                ret = ext4_ind_direct_IO(rw, iocb, iter, offset);
-        trace_ext4_direct_IO_exit(inode, offset, count, rw, ret);
+                ret = ext4_ind_direct_IO(iocb, iter, offset);
+        trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret);
         return ret;
 }