1 files changed, 83 insertions, 70 deletions

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 551353b1b17a..b52fea3b7219 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3119,19 +3119,11 @@ static int ext4_ext_zeroout(struct inode *inode, struct ext4_extent *ex)
 {
         ext4_fsblk_t ee_pblock;
         unsigned int ee_len;
-        int ret;
 
         ee_len    = ext4_ext_get_actual_len(ex);
         ee_pblock = ext4_ext_pblock(ex);
-
-        if (ext4_encrypted_inode(inode))
-                return ext4_encrypted_zeroout(inode, ex);
-
-        ret = sb_issue_zeroout(inode->i_sb, ee_pblock, ee_len, GFP_NOFS);
-        if (ret > 0)
-                ret = 0;
-
-        return ret;
+        return ext4_issue_zeroout(inode, le32_to_cpu(ex->ee_block), ee_pblock,
+                                  ee_len);
 }
 
 /*
@@ -4052,6 +4044,14 @@ ext4_ext_handle_unwritten_extents(handle_t *handle, struct inode *inode,
         }
         /* IO end_io complete, convert the filled extent to written */
         if (flags & EXT4_GET_BLOCKS_CONVERT) {
+                if (flags & EXT4_GET_BLOCKS_ZERO) {
+                        if (allocated > map->m_len)
+                                allocated = map->m_len;
+                        err = ext4_issue_zeroout(inode, map->m_lblk, newblock,
+                                                 allocated);
+                        if (err < 0)
+                                goto out2;
+                }
                 ret = ext4_convert_unwritten_extents_endio(handle, inode, map,
                                                            ppath);
                 if (ret >= 0) {
@@ -4685,10 +4685,6 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset,
         if (len <= EXT_UNWRITTEN_MAX_LEN)
                 flags |= EXT4_GET_BLOCKS_NO_NORMALIZE;
 
-        /* Wait all existing dio workers, newcomers will block on i_mutex */
-        ext4_inode_block_unlocked_dio(inode);
-        inode_dio_wait(inode);
-
         /*
          * credits to insert 1 extent into extent tree
          */
@@ -4752,8 +4748,6 @@ retry:
                 goto retry;
         }
 
-        ext4_inode_resume_unlocked_dio(inode);
-
         return ret > 0 ? ret2 : ret;
 }
 
@@ -4770,7 +4764,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
         int partial_begin, partial_end;
         loff_t start, end;
         ext4_lblk_t lblk;
-        struct address_space *mapping = inode->i_mapping;
         unsigned int blkbits = inode->i_blkbits;
 
         trace_ext4_zero_range(inode, offset, len, mode);
@@ -4786,17 +4779,6 @@ static long ext4_zero_range(struct file *file, loff_t offset,
         }
 
         /*
-         * Write out all dirty pages to avoid race conditions
-         * Then release them.
-         */
-        if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
-                ret = filemap_write_and_wait_range(mapping, offset,
-                                                   offset + len - 1);
-                if (ret)
-                        return ret;
-        }
-
-        /*
          * Round up offset. This is not fallocate, we neet to zero out
          * blocks, so convert interior block aligned part of the range to
          * unwritten and possibly manually zero out unaligned parts of the
@@ -4839,6 +4821,10 @@ static long ext4_zero_range(struct file *file, loff_t offset,
         if (mode & FALLOC_FL_KEEP_SIZE)
                 flags |= EXT4_GET_BLOCKS_KEEP_SIZE;
 
+        /* Wait all existing dio workers, newcomers will block on i_mutex */
+        ext4_inode_block_unlocked_dio(inode);
+        inode_dio_wait(inode);
+
         /* Preallocate the range including the unaligned edges */
         if (partial_begin || partial_end) {
                 ret = ext4_alloc_file_blocks(file,
@@ -4847,7 +4833,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
                                  round_down(offset, 1 << blkbits)) >> blkbits,
                                 new_size, flags, mode);
                 if (ret)
-                        goto out_mutex;
+                        goto out_dio;
 
         }
 
@@ -4856,16 +4842,23 @@ static long ext4_zero_range(struct file *file, loff_t offset,
                 flags |= (EXT4_GET_BLOCKS_CONVERT_UNWRITTEN |
                           EXT4_EX_NOCACHE);
 
-                /* Now release the pages and zero block aligned part of pages*/
+                /*
+                 * Prevent page faults from reinstantiating pages we have
+                 * released from page cache.
+                 */
+                down_write(&EXT4_I(inode)->i_mmap_sem);
+                ret = ext4_update_disksize_before_punch(inode, offset, len);
+                if (ret) {
+                        up_write(&EXT4_I(inode)->i_mmap_sem);
+                        goto out_dio;
+                }
+                /* Now release the pages and zero block aligned part of pages */
                 truncate_pagecache_range(inode, start, end - 1);
                 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
 
-                /* Wait all existing dio workers, newcomers will block on i_mutex */
-                ext4_inode_block_unlocked_dio(inode);
-                inode_dio_wait(inode);
-
                 ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
                                              flags, mode);
+                up_write(&EXT4_I(inode)->i_mmap_sem);
                 if (ret)
                         goto out_dio;
         }
@@ -4998,8 +4991,13 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
                         goto out;
         }
 
+        /* Wait all existing dio workers, newcomers will block on i_mutex */
+        ext4_inode_block_unlocked_dio(inode);
+        inode_dio_wait(inode);
+
         ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
                                      flags, mode);
+        ext4_inode_resume_unlocked_dio(inode);
         if (ret)
                 goto out;
 
@@ -5494,21 +5492,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
                         return ret;
         }
 
-        /*
-         * Need to round down offset to be aligned with page size boundary
-         * for page size > block size.
-         */
-        ioffset = round_down(offset, PAGE_SIZE);
-
-        /* Write out all dirty pages */
-        ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
-                                           LLONG_MAX);
-        if (ret)
-                return ret;
-
-        /* Take mutex lock */
         mutex_lock(&inode->i_mutex);
-
         /*
          * There is no need to overlap collapse range with EOF, in which case
          * it is effectively a truncate operation
@@ -5524,17 +5508,43 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
                 goto out_mutex;
         }
 
-        truncate_pagecache(inode, ioffset);
-
         /* Wait for existing dio to complete */
         ext4_inode_block_unlocked_dio(inode);
         inode_dio_wait(inode);
 
+        /*
+         * Prevent page faults from reinstantiating pages we have released from
+         * page cache.
+         */
+        down_write(&EXT4_I(inode)->i_mmap_sem);
+        /*
+         * Need to round down offset to be aligned with page size boundary
+         * for page size > block size.
+         */
+        ioffset = round_down(offset, PAGE_SIZE);
+        /*
+         * Write tail of the last page before removed range since it will get
+         * removed from the page cache below.
+         */
+        ret = filemap_write_and_wait_range(inode->i_mapping, ioffset, offset);
+        if (ret)
+                goto out_mmap;
+        /*
+         * Write data that will be shifted to preserve them when discarding
+         * page cache below. We are also protected from pages becoming dirty
+         * by i_mmap_sem.
+         */
+        ret = filemap_write_and_wait_range(inode->i_mapping, offset + len,
+                                           LLONG_MAX);
+        if (ret)
+                goto out_mmap;
+        truncate_pagecache(inode, ioffset);
+
         credits = ext4_writepage_trans_blocks(inode);
         handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
-                goto out_dio;
+                goto out_mmap;
         }
 
         down_write(&EXT4_I(inode)->i_data_sem);
@@ -5573,7 +5583,8 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
 
 out_stop:
         ext4_journal_stop(handle);
-out_dio:
+out_mmap:
+        up_write(&EXT4_I(inode)->i_mmap_sem);
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
         mutex_unlock(&inode->i_mutex);
@@ -5627,21 +5638,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
                         return ret;
         }
 
-        /*
-         * Need to round down to align start offset to page size boundary
-         * for page size > block size.
-         */
-        ioffset = round_down(offset, PAGE_SIZE);
-
-        /* Write out all dirty pages */
-        ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
-                        LLONG_MAX);
-        if (ret)
-                return ret;
-
-        /* Take mutex lock */
         mutex_lock(&inode->i_mutex);
-
         /* Currently just for extent based files */
         if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
                 ret = -EOPNOTSUPP;
@@ -5660,17 +5657,32 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
                 goto out_mutex;
         }
 
-        truncate_pagecache(inode, ioffset);
-
         /* Wait for existing dio to complete */
         ext4_inode_block_unlocked_dio(inode);
         inode_dio_wait(inode);
 
+        /*
+         * Prevent page faults from reinstantiating pages we have released from
+         * page cache.
+         */
+        down_write(&EXT4_I(inode)->i_mmap_sem);
+        /*
+         * Need to round down to align start offset to page size boundary
+         * for page size > block size.
+         */
+        ioffset = round_down(offset, PAGE_SIZE);
+        /* Write out all dirty pages */
+        ret = filemap_write_and_wait_range(inode->i_mapping, ioffset,
+                        LLONG_MAX);
+        if (ret)
+                goto out_mmap;
+        truncate_pagecache(inode, ioffset);
+
         credits = ext4_writepage_trans_blocks(inode);
         handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
-                goto out_dio;
+                goto out_mmap;
         }
 
         /* Expand file to avoid data loss if there is error while shifting */
@@ -5741,7 +5753,8 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
 
 out_stop:
         ext4_journal_stop(handle);
-out_dio:
+out_mmap:
+        up_write(&EXT4_I(inode)->i_mmap_sem);
         ext4_inode_resume_unlocked_dio(inode);
 out_mutex:
         mutex_unlock(&inode->i_mutex);