1 files changed, 99 insertions, 61 deletions

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 0165b8672f09..e1ffb1e22898 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -591,7 +591,6 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
                 clear_bit(EXTENT_FLAG_LOGGING, &flags);
                 modified = !list_empty(&em->list);
-                remove_extent_mapping(em_tree, em);
                 if (no_splits)
                         goto next;
 
@@ -622,8 +621,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
-                        ret = add_extent_mapping(em_tree, split, modified);
-                        BUG_ON(ret); /* Logic error */
+                        replace_extent_mapping(em_tree, em, split, modified);
                         free_extent_map(split);
                         split = split2;
                         split2 = NULL;
@@ -661,12 +659,20 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                                 split->orig_block_len = 0;
                         }
 
-                        ret = add_extent_mapping(em_tree, split, modified);
-                        BUG_ON(ret); /* Logic error */
+                        if (extent_map_in_tree(em)) {
+                                replace_extent_mapping(em_tree, em, split,
+                                                       modified);
+                        } else {
+                                ret = add_extent_mapping(em_tree, split,
+                                                         modified);
+                                ASSERT(ret == 0); /* Logic error */
+                        }
                         free_extent_map(split);
                         split = NULL;
                 }
 next:
+                if (extent_map_in_tree(em))
+                        remove_extent_mapping(em_tree, em);
                 write_unlock(&em_tree->lock);
 
                 /* once for us */
@@ -720,7 +726,7 @@ int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
         if (drop_cache)
                 btrfs_drop_extent_cache(inode, start, end - 1, 0);
 
-        if (start >= BTRFS_I(inode)->disk_i_size)
+        if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)
                 modify_tree = 0;
 
         while (1) {
@@ -798,7 +804,10 @@ next_slot:
                  */
                 if (start > key.offset && end < extent_end) {
                         BUG_ON(del_nr > 0);
-                        BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE);
+                        if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                                ret = -EINVAL;
+                                break;
+                        }
 
                         memcpy(&new_key, &key, sizeof(new_key));
                         new_key.offset = start;
@@ -841,7 +850,10 @@ next_slot:
                  *      | -------- extent -------- |
                  */
                 if (start <= key.offset && end < extent_end) {
-                        BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE);
+                        if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                                ret = -EINVAL;
+                                break;
+                        }
 
                         memcpy(&new_key, &key, sizeof(new_key));
                         new_key.offset = end;
@@ -864,7 +876,10 @@ next_slot:
                  */
                 if (start > key.offset && end >= extent_end) {
                         BUG_ON(del_nr > 0);
-                        BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE);
+                        if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                                ret = -EINVAL;
+                                break;
+                        }
 
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         start - key.offset);
@@ -938,34 +953,42 @@ next_slot:
                  * Set path->slots[0] to first slot, so that after the delete
                  * if items are move off from our leaf to its immediate left or
                  * right neighbor leafs, we end up with a correct and adjusted
-                 * path->slots[0] for our insertion.
+                 * path->slots[0] for our insertion (if replace_extent != 0).
                  */
                 path->slots[0] = del_slot;
                 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
                 if (ret)
                         btrfs_abort_transaction(trans, root, ret);
+        }
 
-                leaf = path->nodes[0];
-                /*
-                 * leaf eb has flag EXTENT_BUFFER_STALE if it was deleted (that
-                 * is, its contents got pushed to its neighbors), in which case
-                 * it means path->locks[0] == 0
-                 */
-                if (!ret && replace_extent && leafs_visited == 1 &&
-                    path->locks[0] &&
-                    btrfs_leaf_free_space(root, leaf) >=
-                    sizeof(struct btrfs_item) + extent_item_size) {
-
-                        key.objectid = ino;
-                        key.type = BTRFS_EXTENT_DATA_KEY;
-                        key.offset = start;
-                        setup_items_for_insert(root, path, &key,
-                                               &extent_item_size,
-                                               extent_item_size,
-                                               sizeof(struct btrfs_item) +
-                                               extent_item_size, 1);
-                        *key_inserted = 1;
+        leaf = path->nodes[0];
+        /*
+         * If btrfs_del_items() was called, it might have deleted a leaf, in
+         * which case it unlocked our path, so check path->locks[0] matches a
+         * write lock.
+         */
+        if (!ret && replace_extent && leafs_visited == 1 &&
+            (path->locks[0] == BTRFS_WRITE_LOCK_BLOCKING ||
+             path->locks[0] == BTRFS_WRITE_LOCK) &&
+            btrfs_leaf_free_space(root, leaf) >=
+            sizeof(struct btrfs_item) + extent_item_size) {
+
+                key.objectid = ino;
+                key.type = BTRFS_EXTENT_DATA_KEY;
+                key.offset = start;
+                if (!del_nr && path->slots[0] < btrfs_header_nritems(leaf)) {
+                        struct btrfs_key slot_key;
+
+                        btrfs_item_key_to_cpu(leaf, &slot_key, path->slots[0]);
+                        if (btrfs_comp_cpu_keys(&key, &slot_key) > 0)
+                                path->slots[0]++;
                 }
+                setup_items_for_insert(root, path, &key,
+                                       &extent_item_size,
+                                       extent_item_size,
+                                       sizeof(struct btrfs_item) +
+                                       extent_item_size, 1);
+                *key_inserted = 1;
         }
 
         if (!replace_extent || !(*key_inserted))
@@ -1346,11 +1369,11 @@ lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
                 struct btrfs_ordered_extent *ordered;
                 lock_extent_bits(&BTRFS_I(inode)->io_tree,
                                  start_pos, last_pos, 0, cached_state);
-                ordered = btrfs_lookup_first_ordered_extent(inode, last_pos);
+                ordered = btrfs_lookup_ordered_range(inode, start_pos,
+                                                     last_pos - start_pos + 1);
                 if (ordered &&
                     ordered->file_offset + ordered->len > start_pos &&
                     ordered->file_offset <= last_pos) {
-                        btrfs_put_ordered_extent(ordered);
                         unlock_extent_cached(&BTRFS_I(inode)->io_tree,
                                              start_pos, last_pos,
                                              cached_state, GFP_NOFS);
@@ -1358,12 +1381,9 @@ lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
                                 unlock_page(pages[i]);
                                 page_cache_release(pages[i]);
                         }
-                        ret = btrfs_wait_ordered_range(inode, start_pos,
-                                                last_pos - start_pos + 1);
-                        if (ret)
-                                return ret;
-                        else
-                                return -EAGAIN;
+                        btrfs_start_ordered_extent(inode, ordered, 1);
+                        btrfs_put_ordered_extent(ordered);
+                        return -EAGAIN;
                 }
                 if (ordered)
                         btrfs_put_ordered_extent(ordered);
@@ -1396,8 +1416,12 @@ static noinline int check_can_nocow(struct inode *inode, loff_t pos,
         u64 num_bytes;
         int ret;
 
+        ret = btrfs_start_nocow_write(root);
+        if (!ret)
+                return -ENOSPC;
+
         lockstart = round_down(pos, root->sectorsize);
-        lockend = lockstart + round_up(*write_bytes, root->sectorsize) - 1;
+        lockend = round_up(pos + *write_bytes, root->sectorsize) - 1;
 
         while (1) {
                 lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
@@ -1415,12 +1439,10 @@ static noinline int check_can_nocow(struct inode *inode, loff_t pos,
         ret = can_nocow_extent(inode, lockstart, &num_bytes, NULL, NULL, NULL);
         if (ret <= 0) {
                 ret = 0;
+                btrfs_end_nocow_write(root);
         } else {
-                clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
-                                 EXTENT_DIRTY | EXTENT_DELALLOC |
-                                 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
-                                 NULL, GFP_NOFS);
-                *write_bytes = min_t(size_t, *write_bytes, num_bytes);
+                *write_bytes = min_t(size_t, *write_bytes ,
+                                     num_bytes - pos + lockstart);
         }
 
         unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
@@ -1510,6 +1532,8 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                         if (!only_release_metadata)
                                 btrfs_free_reserved_data_space(inode,
                                                                reserve_bytes);
+                        else
+                                btrfs_end_nocow_write(root);
                         break;
                 }
 
@@ -1598,6 +1622,9 @@ again:
                 }
 
                 release_bytes = 0;
+                if (only_release_metadata)
+                        btrfs_end_nocow_write(root);
+
                 if (only_release_metadata && copied > 0) {
                         u64 lockstart = round_down(pos, root->sectorsize);
                         u64 lockend = lockstart +
@@ -1624,10 +1651,12 @@ again:
         kfree(pages);
 
         if (release_bytes) {
-                if (only_release_metadata)
+                if (only_release_metadata) {
+                        btrfs_end_nocow_write(root);
                         btrfs_delalloc_release_metadata(inode, release_bytes);
-                else
+                } else {
                         btrfs_delalloc_release_space(inode, release_bytes);
+                }
         }
 
         return num_written ? num_written : ret;
@@ -1797,7 +1826,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
         BTRFS_I(inode)->last_sub_trans = root->log_transid;
         if (num_written > 0) {
                 err = generic_write_sync(file, pos, num_written);
-                if (err < 0 && num_written > 0)
+                if (err < 0)
                         num_written = err;
         }
 
@@ -1856,8 +1885,9 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        int ret = 0;
         struct btrfs_trans_handle *trans;
+        struct btrfs_log_ctx ctx;
+        int ret = 0;
         bool full_sync = 0;
 
         trace_btrfs_sync_file(file, datasync);
@@ -1951,7 +1981,9 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         }
         trans->sync = true;
 
-        ret = btrfs_log_dentry_safe(trans, root, dentry);
+        btrfs_init_log_ctx(&ctx);
+
+        ret = btrfs_log_dentry_safe(trans, root, dentry, &ctx);
         if (ret < 0) {
                 /* Fallthrough and commit/free transaction. */
                 ret = 1;
@@ -1971,7 +2003,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         if (ret != BTRFS_NO_LOG_SYNC) {
                 if (!ret) {
-                        ret = btrfs_sync_log(trans, root);
+                        ret = btrfs_sync_log(trans, root, &ctx);
                         if (!ret) {
                                 ret = btrfs_end_transaction(trans, root);
                                 goto out;
@@ -2157,6 +2189,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
         bool same_page = ((offset >> PAGE_CACHE_SHIFT) ==
                           ((offset + len - 1) >> PAGE_CACHE_SHIFT));
         bool no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
+        u64 ino_size = round_up(inode->i_size, PAGE_CACHE_SIZE);
 
         ret = btrfs_wait_ordered_range(inode, offset, len);
         if (ret)
@@ -2172,14 +2205,14 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
          * entire page.
          */
         if (same_page && len < PAGE_CACHE_SIZE) {
-                if (offset < round_up(inode->i_size, PAGE_CACHE_SIZE))
+                if (offset < ino_size)
                         ret = btrfs_truncate_page(inode, offset, len, 0);
                 mutex_unlock(&inode->i_mutex);
                 return ret;
         }
 
         /* zero back part of the first page */
-        if (offset < round_up(inode->i_size, PAGE_CACHE_SIZE)) {
+        if (offset < ino_size) {
                 ret = btrfs_truncate_page(inode, offset, 0, 0);
                 if (ret) {
                         mutex_unlock(&inode->i_mutex);
@@ -2188,7 +2221,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
         }
 
         /* zero the front end of the last page */
-        if (offset + len < round_up(inode->i_size, PAGE_CACHE_SIZE)) {
+        if (offset + len < ino_size) {
                 ret = btrfs_truncate_page(inode, offset + len, 0, 1);
                 if (ret) {
                         mutex_unlock(&inode->i_mutex);
@@ -2277,10 +2310,13 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
 
                 trans->block_rsv = &root->fs_info->trans_block_rsv;
 
-                ret = fill_holes(trans, inode, path, cur_offset, drop_end);
-                if (ret) {
-                        err = ret;
-                        break;
+                if (cur_offset < ino_size) {
+                        ret = fill_holes(trans, inode, path, cur_offset,
+                                         drop_end);
+                        if (ret) {
+                                err = ret;
+                                break;
+                        }
                 }
 
                 cur_offset = drop_end;
@@ -2313,10 +2349,12 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
         }
 
         trans->block_rsv = &root->fs_info->trans_block_rsv;
-        ret = fill_holes(trans, inode, path, cur_offset, drop_end);
-        if (ret) {
-                err = ret;
-                goto out_trans;
+        if (cur_offset < ino_size) {
+                ret = fill_holes(trans, inode, path, cur_offset, drop_end);
+                if (ret) {
+                        err = ret;
+                        goto out_trans;
+                }
         }
 
 out_trans: