1 files changed, 116 insertions, 107 deletions

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 0b16fb4c06d3..e5d3eadf47b1 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2306,16 +2306,16 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                 ext4_lblk_t block)
 {
         int depth = ext_depth(inode);
-        unsigned long len = 0;
-        ext4_lblk_t lblock = 0;
+        ext4_lblk_t len;
+        ext4_lblk_t lblock;
         struct ext4_extent *ex;
+        struct extent_status es;
 
         ex = path[depth].p_ext;
         if (ex == NULL) {
-                /*
-                 * there is no extent yet, so gap is [0;-] and we
-                 * don't cache it
-                 */
+                /* there is no extent yet, so gap is [0;-] */
+                lblock = 0;
+                len = EXT_MAX_BLOCKS;
                 ext_debug("cache gap(whole file):");
         } else if (block < le32_to_cpu(ex->ee_block)) {
                 lblock = block;
@@ -2324,9 +2324,6 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                 block,
                                 le32_to_cpu(ex->ee_block),
                                  ext4_ext_get_actual_len(ex));
-                if (!ext4_find_delalloc_range(inode, lblock, lblock + len - 1))
-                        ext4_es_insert_extent(inode, lblock, len, ~0,
-                                              EXTENT_STATUS_HOLE);
         } else if (block >= le32_to_cpu(ex->ee_block)
                         + ext4_ext_get_actual_len(ex)) {
                 ext4_lblk_t next;
@@ -2340,14 +2337,19 @@ ext4_ext_put_gap_in_cache(struct inode *inode, struct ext4_ext_path *path,
                                 block);
                 BUG_ON(next == lblock);
                 len = next - lblock;
-                if (!ext4_find_delalloc_range(inode, lblock, lblock + len - 1))
-                        ext4_es_insert_extent(inode, lblock, len, ~0,
-                                              EXTENT_STATUS_HOLE);
         } else {
                 BUG();
         }
 
-        ext_debug(" -> %u:%lu\n", lblock, len);
+        ext4_es_find_delayed_extent_range(inode, lblock, lblock + len - 1, &es);
+        if (es.es_len) {
+                /* There's delayed extent containing lblock? */
+                if (es.es_lblk <= lblock)
+                        return;
+                len = min(es.es_lblk - lblock, len);
+        }
+        ext_debug(" -> %u:%u\n", lblock, len);
+        ext4_es_insert_extent(inode, lblock, len, ~0, EXTENT_STATUS_HOLE);
 }
 
 /*
@@ -2481,7 +2483,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
                               ext4_lblk_t from, ext4_lblk_t to)
 {
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
-        unsigned short ee_len =  ext4_ext_get_actual_len(ex);
+        unsigned short ee_len = ext4_ext_get_actual_len(ex);
         ext4_fsblk_t pblk;
         int flags = get_default_free_blocks_flags(inode);
 
@@ -2490,7 +2492,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
          * at the beginning of the extent.  Instead, we make a note
          * that we tried freeing the cluster, and check to see if we
          * need to free it on a subsequent call to ext4_remove_blocks,
-         * or at the end of the ext4_truncate() operation.
+         * or at the end of ext4_ext_rm_leaf or ext4_ext_remove_space.
          */
         flags |= EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER;
 
@@ -2501,8 +2503,8 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
          * partial cluster here.
          */
         pblk = ext4_ext_pblock(ex) + ee_len - 1;
-        if ((*partial_cluster > 0) &&
-            (EXT4_B2C(sbi, pblk) != *partial_cluster)) {
+        if (*partial_cluster > 0 &&
+            *partial_cluster != (long long) EXT4_B2C(sbi, pblk)) {
                 ext4_free_blocks(handle, inode, NULL,
                                  EXT4_C2B(sbi, *partial_cluster),
                                  sbi->s_cluster_ratio, flags);
@@ -2528,7 +2530,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
             && to == le32_to_cpu(ex->ee_block) + ee_len - 1) {
                 /* tail removal */
                 ext4_lblk_t num;
-                unsigned int unaligned;
+                long long first_cluster;
 
                 num = le32_to_cpu(ex->ee_block) + ee_len - from;
                 pblk = ext4_ext_pblock(ex) + ee_len - num;
@@ -2538,7 +2540,7 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
                  * used by any other extent (partial_cluster is negative).
                  */
                 if (*partial_cluster < 0 &&
-                    -(*partial_cluster) == EXT4_B2C(sbi, pblk + num - 1))
+                    *partial_cluster == -(long long) EXT4_B2C(sbi, pblk+num-1))
                         flags |= EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER;
 
                 ext_debug("free last %u blocks starting %llu partial %lld\n",
@@ -2549,21 +2551,24 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
                  * beginning of a cluster, and we removed the entire
                  * extent and the cluster is not used by any other extent,
                  * save the partial cluster here, since we might need to
-                 * delete if we determine that the truncate operation has
-                 * removed all of the blocks in the cluster.
+                 * delete if we determine that the truncate or punch hole
+                 * operation has removed all of the blocks in the cluster.
+                 * If that cluster is used by another extent, preserve its
+                 * negative value so it isn't freed later on.
                  *
-                 * On the other hand, if we did not manage to free the whole
-                 * extent, we have to mark the cluster as used (store negative
-                 * cluster number in partial_cluster).
+                 * If the whole extent wasn't freed, we've reached the
+                 * start of the truncated/punched region and have finished
+                 * removing blocks.  If there's a partial cluster here it's
+                 * shared with the remainder of the extent and is no longer
+                 * a candidate for removal.
                  */
-                unaligned = EXT4_PBLK_COFF(sbi, pblk);
-                if (unaligned && (ee_len == num) &&
-                    (*partial_cluster != -((long long)EXT4_B2C(sbi, pblk))))
-                        *partial_cluster = EXT4_B2C(sbi, pblk);
-                else if (unaligned)
-                        *partial_cluster = -((long long)EXT4_B2C(sbi, pblk));
-                else if (*partial_cluster > 0)
+                if (EXT4_PBLK_COFF(sbi, pblk) && ee_len == num) {
+                        first_cluster = (long long) EXT4_B2C(sbi, pblk);
+                        if (first_cluster != -*partial_cluster)
+                                *partial_cluster = first_cluster;
+                } else {
                         *partial_cluster = 0;
+                }
         } else
                 ext4_error(sbi->s_sb, "strange request: removal(2) "
                            "%u-%u from %u:%u\n",
@@ -2574,15 +2579,16 @@ static int ext4_remove_blocks(handle_t *handle, struct inode *inode,
 
 /*
  * ext4_ext_rm_leaf() Removes the extents associated with the
- * blocks appearing between "start" and "end", and splits the extents
- * if "start" and "end" appear in the same extent
+ * blocks appearing between "start" and "end".  Both "start"
+ * and "end" must appear in the same extent or EIO is returned.
  *
  * @handle: The journal handle
  * @inode:  The files inode
  * @path:   The path to the leaf
  * @partial_cluster: The cluster which we'll have to free if all extents
- *                   has been released from it. It gets negative in case
- *                   that the cluster is still used.
+ *                   has been released from it.  However, if this value is
+ *                   negative, it's a cluster just to the right of the
+ *                   punched region and it must not be freed.
  * @start:  The first block to remove
  * @end:   The last block to remove
  */
@@ -2621,27 +2627,6 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
         ex_ee_block = le32_to_cpu(ex->ee_block);
         ex_ee_len = ext4_ext_get_actual_len(ex);
 
-        /*
-         * If we're starting with an extent other than the last one in the
-         * node, we need to see if it shares a cluster with the extent to
-         * the right (towards the end of the file). If its leftmost cluster
-         * is this extent's rightmost cluster and it is not cluster aligned,
-         * we'll mark it as a partial that is not to be deallocated.
-         */
-
-        if (ex != EXT_LAST_EXTENT(eh)) {
-                ext4_fsblk_t current_pblk, right_pblk;
-                long long current_cluster, right_cluster;
-
-                current_pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;
-                current_cluster = (long long)EXT4_B2C(sbi, current_pblk);
-                right_pblk = ext4_ext_pblock(ex + 1);
-                right_cluster = (long long)EXT4_B2C(sbi, right_pblk);
-                if (current_cluster == right_cluster &&
-                        EXT4_PBLK_COFF(sbi, right_pblk))
-                        *partial_cluster = -right_cluster;
-        }
-
         trace_ext4_ext_rm_leaf(inode, start, ex, *partial_cluster);
 
         while (ex >= EXT_FIRST_EXTENT(eh) &&
@@ -2666,14 +2651,16 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
                 if (end < ex_ee_block) {
                         /*
                          * We're going to skip this extent and move to another,
-                         * so if this extent is not cluster aligned we have
-                         * to mark the current cluster as used to avoid
-                         * accidentally freeing it later on
+                         * so note that its first cluster is in use to avoid
+                         * freeing it when removing blocks.  Eventually, the
+                         * right edge of the truncated/punched region will
+                         * be just to the left.
                          */
-                        pblk = ext4_ext_pblock(ex);
-                        if (EXT4_PBLK_COFF(sbi, pblk))
+                        if (sbi->s_cluster_ratio > 1) {
+                                pblk = ext4_ext_pblock(ex);
                                 *partial_cluster =
-                                        -((long long)EXT4_B2C(sbi, pblk));
+                                        -(long long) EXT4_B2C(sbi, pblk);
+                        }
                         ex--;
                         ex_ee_block = le32_to_cpu(ex->ee_block);
                         ex_ee_len = ext4_ext_get_actual_len(ex);
@@ -2749,8 +2736,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
                                         sizeof(struct ext4_extent));
                         }
                         le16_add_cpu(&eh->eh_entries, -1);
-                } else if (*partial_cluster > 0)
-                        *partial_cluster = 0;
+                }
 
                 err = ext4_ext_dirty(handle, inode, path + depth);
                 if (err)
@@ -2769,20 +2755,18 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
         /*
          * If there's a partial cluster and at least one extent remains in
          * the leaf, free the partial cluster if it isn't shared with the
-         * current extent.  If there's a partial cluster and no extents
-         * remain in the leaf, it can't be freed here.  It can only be
-         * freed when it's possible to determine if it's not shared with
-         * any other extent - when the next leaf is processed or when space
-         * removal is complete.
+         * current extent.  If it is shared with the current extent
+         * we zero partial_cluster because we've reached the start of the
+         * truncated/punched region and we're done removing blocks.
          */
-        if (*partial_cluster > 0 && eh->eh_entries &&
-            (EXT4_B2C(sbi, ext4_ext_pblock(ex) + ex_ee_len - 1) !=
-             *partial_cluster)) {
-                int flags = get_default_free_blocks_flags(inode);
-
-                ext4_free_blocks(handle, inode, NULL,
-                                 EXT4_C2B(sbi, *partial_cluster),
-                                 sbi->s_cluster_ratio, flags);
+        if (*partial_cluster > 0 && ex >= EXT_FIRST_EXTENT(eh)) {
+                pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;
+                if (*partial_cluster != (long long) EXT4_B2C(sbi, pblk)) {
+                        ext4_free_blocks(handle, inode, NULL,
+                                         EXT4_C2B(sbi, *partial_cluster),
+                                         sbi->s_cluster_ratio,
+                                         get_default_free_blocks_flags(inode));
+                }
                 *partial_cluster = 0;
         }
 
@@ -2819,7 +2803,7 @@ ext4_ext_more_to_rm(struct ext4_ext_path *path)
 int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
                           ext4_lblk_t end)
 {
-        struct super_block *sb = inode->i_sb;
+        struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         int depth = ext_depth(inode);
         struct ext4_ext_path *path = NULL;
         long long partial_cluster = 0;
@@ -2845,9 +2829,10 @@ again:
          */
         if (end < EXT_MAX_BLOCKS - 1) {
                 struct ext4_extent *ex;
-                ext4_lblk_t ee_block;
+                ext4_lblk_t ee_block, ex_end, lblk;
+                ext4_fsblk_t pblk;
 
-                /* find extent for this block */
+                /* find extent for or closest extent to this block */
                 path = ext4_find_extent(inode, end, NULL, EXT4_EX_NOCACHE);
                 if (IS_ERR(path)) {
                         ext4_journal_stop(handle);
@@ -2867,6 +2852,7 @@ again:
                 }
 
                 ee_block = le32_to_cpu(ex->ee_block);
+                ex_end = ee_block + ext4_ext_get_actual_len(ex) - 1;
 
                 /*
                  * See if the last block is inside the extent, if so split
@@ -2874,8 +2860,19 @@ again:
                  * tail of the first part of the split extent in
                  * ext4_ext_rm_leaf().
                  */
-                if (end >= ee_block &&
-                    end < ee_block + ext4_ext_get_actual_len(ex) - 1) {
+                if (end >= ee_block && end < ex_end) {
+
+                        /*
+                         * If we're going to split the extent, note that
+                         * the cluster containing the block after 'end' is
+                         * in use to avoid freeing it when removing blocks.
+                         */
+                        if (sbi->s_cluster_ratio > 1) {
+                                pblk = ext4_ext_pblock(ex) + end - ee_block + 2;
+                                partial_cluster =
+                                        -(long long) EXT4_B2C(sbi, pblk);
+                        }
+
                         /*
                          * Split the extent in two so that 'end' is the last
                          * block in the first new extent. Also we should not
@@ -2886,6 +2883,24 @@ again:
                                                          end + 1, 1);
                         if (err < 0)
                                 goto out;
+
+                } else if (sbi->s_cluster_ratio > 1 && end >= ex_end) {
+                        /*
+                         * If there's an extent to the right its first cluster
+                         * contains the immediate right boundary of the
+                         * truncated/punched region.  Set partial_cluster to
+                         * its negative value so it won't be freed if shared
+                         * with the current extent.  The end < ee_block case
+                         * is handled in ext4_ext_rm_leaf().
+                         */
+                        lblk = ex_end + 1;
+                        err = ext4_ext_search_right(inode, path, &lblk, &pblk,
+                                                    &ex);
+                        if (err)
+                                goto out;
+                        if (pblk)
+                                partial_cluster =
+                                        -(long long) EXT4_B2C(sbi, pblk);
                 }
         }
         /*
@@ -2996,16 +3011,18 @@ again:
         trace_ext4_ext_remove_space_done(inode, start, end, depth,
                         partial_cluster, path->p_hdr->eh_entries);
 
-        /* If we still have something in the partial cluster and we have removed
+        /*
+         * If we still have something in the partial cluster and we have removed
          * even the first extent, then we should free the blocks in the partial
-         * cluster as well. */
-        if (partial_cluster > 0 && path->p_hdr->eh_entries == 0) {
-                int flags = get_default_free_blocks_flags(inode);
-
+         * cluster as well.  (This code will only run when there are no leaves
+         * to the immediate left of the truncated/punched region.)
+         */
+        if (partial_cluster > 0 && err == 0) {
+                /* don't zero partial_cluster since it's not used afterwards */
                 ext4_free_blocks(handle, inode, NULL,
-                                 EXT4_C2B(EXT4_SB(sb), partial_cluster),
-                                 EXT4_SB(sb)->s_cluster_ratio, flags);
-                partial_cluster = 0;
+                                 EXT4_C2B(sbi, partial_cluster),
+                                 sbi->s_cluster_ratio,
+                                 get_default_free_blocks_flags(inode));
         }
 
         /* TODO: flexible tree reduction should be here */
@@ -4267,6 +4284,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
         ext4_io_end_t *io = ext4_inode_aio(inode);
         ext4_lblk_t cluster_offset;
         int set_unwritten = 0;
+        bool map_from_cluster = false;
 
         ext_debug("blocks %u/%u requested for inode %lu\n",
                   map->m_lblk, map->m_len, inode->i_ino);
@@ -4343,10 +4361,6 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
                 }
         }
 
-        if ((sbi->s_cluster_ratio > 1) &&
-            ext4_find_delalloc_cluster(inode, map->m_lblk))
-                map->m_flags |= EXT4_MAP_FROM_CLUSTER;
-
         /*
          * requested block isn't allocated yet;
          * we couldn't try to create block if create flag is zero
@@ -4356,15 +4370,13 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
                  * put just found gap into cache to speed up
                  * subsequent requests
                  */
-                if ((flags & EXT4_GET_BLOCKS_NO_PUT_HOLE) == 0)
-                        ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
+                ext4_ext_put_gap_in_cache(inode, path, map->m_lblk);
                 goto out2;
         }
 
         /*
          * Okay, we need to do block allocation.
          */
-        map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;
         newex.ee_block = cpu_to_le32(map->m_lblk);
         cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk);
 
@@ -4376,7 +4388,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
             get_implied_cluster_alloc(inode->i_sb, map, ex, path)) {
                 ar.len = allocated = map->m_len;
                 newblock = map->m_pblk;
-                map->m_flags |= EXT4_MAP_FROM_CLUSTER;
+                map_from_cluster = true;
                 goto got_allocated_blocks;
         }
 
@@ -4397,7 +4409,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
             get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) {
                 ar.len = allocated = map->m_len;
                 newblock = map->m_pblk;
-                map->m_flags |= EXT4_MAP_FROM_CLUSTER;
+                map_from_cluster = true;
                 goto got_allocated_blocks;
         }
 
@@ -4523,7 +4535,7 @@ got_allocated_blocks:
                  */
                 reserved_clusters = get_reserved_cluster_alloc(inode,
                                                 map->m_lblk, allocated);
-                if (map->m_flags & EXT4_MAP_FROM_CLUSTER) {
+                if (map_from_cluster) {
                         if (reserved_clusters) {
                                 /*
                                  * We have clusters reserved for this range.
@@ -4620,7 +4632,6 @@ out2:
 
         trace_ext4_ext_map_blocks_exit(inode, flags, map,
                                        err ? err : allocated);
-        ext4_es_lru_add(inode);
         return err ? err : allocated;
 }
 
@@ -5140,7 +5151,8 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
         if (ext4_has_inline_data(inode)) {
                 int has_inline = 1;
 
-                error = ext4_inline_data_fiemap(inode, fieinfo, &has_inline);
+                error = ext4_inline_data_fiemap(inode, fieinfo, &has_inline,
+                                                start, len);
 
                 if (has_inline)
                         return error;
@@ -5154,8 +5166,8 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 
         /* fallback to generic here if not in extents fmt */
         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
-                return generic_block_fiemap(inode, fieinfo, start, len,
-                        ext4_get_block);
+                return __generic_block_fiemap(inode, fieinfo, start, len,
+                                              ext4_get_block);
 
         if (fiemap_check_flags(fieinfo, EXT4_FIEMAP_FLAGS))
                 return -EBADR;
@@ -5179,7 +5191,6 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                 error = ext4_fill_fiemap_extents(inode, start_blk,
                                                  len_blks, fieinfo);
         }
-        ext4_es_lru_add(inode);
         return error;
 }
 
@@ -5239,8 +5250,6 @@ ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift,
                                 return -EIO;
 
                         ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
-                        if (!ex_last)
-                                return -EIO;
 
                         err = ext4_access_path(handle, inode, path + depth);
                         if (err)