Btrfs: fix deadlock in run_delalloc_nocow

[sfrench/cifs-2.6.git] / fs / btrfs / inode.c

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 633b83b709a1dd9319346adf698839d578d1c67a..a68a4acd16e51aac6e3633f7753ee66884b86069 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1334,8 +1334,11 @@ next_slot:
                leaf = path->nodes[0];
                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
                        ret = btrfs_next_leaf(root, path);
-                       if (ret < 0)
+                       if (ret < 0) {
+                               if (cow_start != (u64)-1)
+                                       cur_offset = cow_start;
                                goto error;
+                       }
                        if (ret > 0)
                                break;
                        leaf = path->nodes[0];
@@ -4769,8 +4772,8 @@ int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
        u64 block_start;
        u64 block_end;
 
-       if ((offset & (blocksize - 1)) == 0 &&
-           (!len || ((len & (blocksize - 1)) == 0)))
+       if (IS_ALIGNED(offset, blocksize) &&
+           (!len || IS_ALIGNED(len, blocksize)))
                goto out;
 
        block_start = round_down(from, blocksize);
@@ -6817,68 +6820,6 @@ out_fail_inode:
        goto out_fail;
 }
 
-/* Find next extent map of a given extent map, caller needs to ensure locks */
-static struct extent_map *next_extent_map(struct extent_map *em)
-{
-       struct rb_node *next;
-
-       next = rb_next(&em->rb_node);
-       if (!next)
-               return NULL;
-       return container_of(next, struct extent_map, rb_node);
-}
-
-static struct extent_map *prev_extent_map(struct extent_map *em)
-{
-       struct rb_node *prev;
-
-       prev = rb_prev(&em->rb_node);
-       if (!prev)
-               return NULL;
-       return container_of(prev, struct extent_map, rb_node);
-}
-
-/* helper for btfs_get_extent.  Given an existing extent in the tree,
- * the existing extent is the nearest extent to map_start,
- * and an extent that you want to insert, deal with overlap and insert
- * the best fitted new extent into the tree.
- */
-static int merge_extent_mapping(struct extent_map_tree *em_tree,
-                               struct extent_map *existing,
-                               struct extent_map *em,
-                               u64 map_start)
-{
-       struct extent_map *prev;
-       struct extent_map *next;
-       u64 start;
-       u64 end;
-       u64 start_diff;
-
-       BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
-
-       if (existing->start > map_start) {
-               next = existing;
-               prev = prev_extent_map(next);
-       } else {
-               prev = existing;
-               next = next_extent_map(prev);
-       }
-
-       start = prev ? extent_map_end(prev) : em->start;
-       start = max_t(u64, start, em->start);
-       end = next ? next->start : extent_map_end(em);
-       end = min_t(u64, end, extent_map_end(em));
-       start_diff = start - em->start;
-       em->start = start;
-       em->len = end - start;
-       if (em->block_start < EXTENT_MAP_LAST_BYTE &&
-           !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
-               em->block_start += start_diff;
-               em->block_len -= start_diff;
-       }
-       return add_extent_mapping(em_tree, em, 0);
-}
-
 static noinline int uncompress_inline(struct btrfs_path *path,
                                      struct page *page,
                                      size_t pg_offset, u64 extent_offset,
@@ -7138,51 +7079,7 @@ insert:
 
        err = 0;
        write_lock(&em_tree->lock);
-       ret = add_extent_mapping(em_tree, em, 0);
-       /* it is possible that someone inserted the extent into the tree
-        * while we had the lock dropped.  It is also possible that
-        * an overlapping map exists in the tree
-        */
-       if (ret == -EEXIST) {
-               struct extent_map *existing;
-
-               ret = 0;
-
-               existing = search_extent_mapping(em_tree, start, len);
-               /*
-                * existing will always be non-NULL, since there must be
-                * extent causing the -EEXIST.
-                */
-               if (existing->start == em->start &&
-                   extent_map_end(existing) >= extent_map_end(em) &&
-                   em->block_start == existing->block_start) {
-                       /*
-                        * The existing extent map already encompasses the
-                        * entire extent map we tried to add.
-                        */
-                       free_extent_map(em);
-                       em = existing;
-                       err = 0;
-
-               } else if (start >= extent_map_end(existing) ||
-                   start <= existing->start) {
-                       /*
-                        * The existing extent map is the one nearest to
-                        * the [start, start + len) range which overlaps
-                        */
-                       err = merge_extent_mapping(em_tree, existing,
-                                                  em, start);
-                       free_extent_map(existing);
-                       if (err) {
-                               free_extent_map(em);
-                               em = NULL;
-                       }
-               } else {
-                       free_extent_map(em);
-                       em = existing;
-                       err = 0;
-               }
-       }
+       err = btrfs_add_extent_mapping(em_tree, &em, start, len);
        write_unlock(&em_tree->lock);
 out: