ext4: don't take the i_mutex lock when doing DIO overwrites

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

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 02bc8cbe7281b3d47c3449a1c4b8e4220685ba52..bed574dd4c22c9998fb8644656e73a05bf451835 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -544,7 +544,8 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
         * Try to see if we can get the block without requesting a new
         * file system block.
         */
-       down_read((&EXT4_I(inode)->i_data_sem));
+       if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
+               down_read((&EXT4_I(inode)->i_data_sem));
        if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
                retval = ext4_ext_map_blocks(handle, inode, map, flags &
                                             EXT4_GET_BLOCKS_KEEP_SIZE);
@@ -552,7 +553,8 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                retval = ext4_ind_map_blocks(handle, inode, map, flags &
                                             EXT4_GET_BLOCKS_KEEP_SIZE);
        }
-       up_read((&EXT4_I(inode)->i_data_sem));
+       if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
+               up_read((&EXT4_I(inode)->i_data_sem));
 
        if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
                int ret = check_block_validity(inode, map);
@@ -2818,6 +2820,32 @@ static int ext4_get_block_write(struct inode *inode, sector_t iblock,
                               EXT4_GET_BLOCKS_IO_CREATE_EXT);
 }
 
+static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
+                  struct buffer_head *bh_result, int flags)
+{
+       handle_t *handle = ext4_journal_current_handle();
+       struct ext4_map_blocks map;
+       int ret = 0;
+
+       ext4_debug("ext4_get_block_write_nolock: inode %lu, flag %d\n",
+                  inode->i_ino, flags);
+
+       flags = EXT4_GET_BLOCKS_NO_LOCK;
+
+       map.m_lblk = iblock;
+       map.m_len = bh_result->b_size >> inode->i_blkbits;
+
+       ret = ext4_map_blocks(handle, inode, &map, flags);
+       if (ret > 0) {
+               map_bh(bh_result, inode->i_sb, map.m_pblk);
+               bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) |
+                                       map.m_flags;
+               bh_result->b_size = inode->i_sb->s_blocksize * map.m_len;
+               ret = 0;
+       }
+       return ret;
+}
+
 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
                            ssize_t size, void *private, int ret,
                            bool is_async)
@@ -2966,6 +2994,18 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
 
        loff_t final_size = offset + count;
        if (rw == WRITE && final_size <= inode->i_size) {
+               int overwrite = 0;
+
+               BUG_ON(iocb->private == NULL);
+
+               /* If we do a overwrite dio, i_mutex locking can be released */
+               overwrite = *((int *)iocb->private);
+
+               if (overwrite) {
+                       down_read(&EXT4_I(inode)->i_data_sem);
+                       mutex_unlock(&inode->i_mutex);
+               }
+
                /*
                 * We could direct write to holes and fallocate.
                 *
@@ -2991,8 +3031,10 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                if (!is_sync_kiocb(iocb)) {
                        ext4_io_end_t *io_end =
                                ext4_init_io_end(inode, GFP_NOFS);
-                       if (!io_end)
-                               return -ENOMEM;
+                       if (!io_end) {
+                               ret = -ENOMEM;
+                               goto retake_lock;
+                       }
                        io_end->flag |= EXT4_IO_END_DIRECT;
                        iocb->private = io_end;
                        /*
@@ -3005,13 +3047,22 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                        EXT4_I(inode)->cur_aio_dio = iocb->private;
                }
 
-               ret = __blockdev_direct_IO(rw, iocb, inode,
-                                        inode->i_sb->s_bdev, iov,
-                                        offset, nr_segs,
-                                        ext4_get_block_write,
-                                        ext4_end_io_dio,
-                                        NULL,
-                                        DIO_LOCKING);
+               if (overwrite)
+                       ret = __blockdev_direct_IO(rw, iocb, inode,
+                                                inode->i_sb->s_bdev, iov,
+                                                offset, nr_segs,
+                                                ext4_get_block_write_nolock,
+                                                ext4_end_io_dio,
+                                                NULL,
+                                                0);
+               else
+                       ret = __blockdev_direct_IO(rw, iocb, inode,
+                                                inode->i_sb->s_bdev, iov,
+                                                offset, nr_segs,
+                                                ext4_get_block_write,
+                                                ext4_end_io_dio,
+                                                NULL,
+                                                DIO_LOCKING);
                if (iocb->private)
                        EXT4_I(inode)->cur_aio_dio = NULL;
                /*
@@ -3031,7 +3082,7 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
                        ext4_free_io_end(iocb->private);
                        iocb->private = NULL;
-               } else if (ret > 0 && ext4_test_inode_state(inode,
+               } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
                                                EXT4_STATE_DIO_UNWRITTEN)) {
                        int err;
                        /*
@@ -3044,6 +3095,14 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                                ret = err;
                        ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
                }
+
+       retake_lock:
+               /* take i_mutex locking again if we do a ovewrite dio */
+               if (overwrite) {
+                       up_read(&EXT4_I(inode)->i_data_sem);
+                       mutex_lock(&inode->i_mutex);
+               }
+
                return ret;
        }