Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Pull btrfs updates from Chris Mason:
 "This is against 3.11-rc7, but was pulled and tested against your tree
  as of yesterday.  We do have two small incrementals queued up, but I
  wanted to get this bunch out the door before I hop on an airplane.

  This is a fairly large batch of fixes, performance improvements, and
  cleanups from the usual Btrfs suspects.

  We've included Stefan Behren's work to index subvolume UUIDs, which is
  targeted at speeding up send/receive with many subvolumes or snapshots
  in place.  It closes a long standing performance issue that was built
  in to the disk format.

  Mark Fasheh's offline dedup work is also here.  In this case offline
  means the FS is mounted and active, but the dedup work is not done
  inline during file IO.  This is a building block where utilities are
  able to ask the FS to dedup a series of extents.  The kernel takes
  care of verifying the data involved really is the same.  Today this
  involves reading both extents, but we'll continue to evolve the
  patches"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (118 commits)
  Btrfs: optimize key searches in btrfs_search_slot
  Btrfs: don't use an async starter for most of our workers
  Btrfs: only update disk_i_size as we remove extents
  Btrfs: fix deadlock in uuid scan kthread
  Btrfs: stop refusing the relocation of chunk 0
  Btrfs: fix memory leak of uuid_root in free_fs_info
  btrfs: reuse kbasename helper
  btrfs: return btrfs error code for dev excl ops err
  Btrfs: allow partial ordered extent completion
  Btrfs: convert all bug_ons in free-space-cache.c
  Btrfs: add support for asserts
  Btrfs: adjust the fs_devices->missing count on unmount
  Btrf: cleanup: don't check for root_refs == 0 twice
  Btrfs: fix for patch "cleanup: don't check the same thing twice"
  Btrfs: get rid of one BUG() in write_all_supers()
  Btrfs: allocate prelim_ref with a slab allocater
  Btrfs: pass gfp_t to __add_prelim_ref() to avoid always using GFP_ATOMIC
  Btrfs: fix race conditions in BTRFS_IOC_FS_INFO ioctl
  Btrfs: fix race between removing a dev and writing sbs
  Btrfs: remove ourselves from the cluster list under lock
  ...

1 files changed, 281 insertions, 334 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 7bdc83d04d54..db1e43948579 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -230,12 +230,13 @@ fail:
  * does the checks required to make sure the data is small enough
  * to fit as an inline extent.
  */
-static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
-                                 struct btrfs_root *root,
-                                 struct inode *inode, u64 start, u64 end,
-                                 size_t compressed_size, int compress_type,
-                                 struct page **compressed_pages)
+static noinline int cow_file_range_inline(struct btrfs_root *root,
+                                          struct inode *inode, u64 start,
+                                          u64 end, size_t compressed_size,
+                                          int compress_type,
+                                          struct page **compressed_pages)
 {
+        struct btrfs_trans_handle *trans;
         u64 isize = i_size_read(inode);
         u64 actual_end = min(end + 1, isize);
         u64 inline_len = actual_end - start;
@@ -256,9 +257,16 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                 return 1;
         }
 
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans))
+                return PTR_ERR(trans);
+        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
+
         ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
-        if (ret)
-                return ret;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         if (isize > actual_end)
                 inline_len = min_t(u64, isize, actual_end);
@@ -267,15 +275,18 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                                    compress_type, compressed_pages);
         if (ret && ret != -ENOSPC) {
                 btrfs_abort_transaction(trans, root, ret);
-                return ret;
+                goto out;
         } else if (ret == -ENOSPC) {
-                return 1;
+                ret = 1;
+                goto out;
         }
 
         set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
         btrfs_delalloc_release_metadata(inode, end + 1 - start);
         btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
-        return 0;
+out:
+        btrfs_end_transaction(trans, root);
+        return ret;
 }
 
 struct async_extent {
@@ -343,7 +354,6 @@ static noinline int compress_file_range(struct inode *inode,
                                         int *num_added)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
         u64 num_bytes;
         u64 blocksize = root->sectorsize;
         u64 actual_end;
@@ -461,45 +471,36 @@ again:
         }
 cont:
         if (start == 0) {
-                trans = btrfs_join_transaction(root);
-                if (IS_ERR(trans)) {
-                        ret = PTR_ERR(trans);
-                        trans = NULL;
-                        goto cleanup_and_out;
-                }
-                trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-
                 /* lets try to make an inline extent */
                 if (ret || total_in < (actual_end - start)) {
                         /* we didn't compress the entire range, try
                          * to make an uncompressed inline extent.
                          */
-                        ret = cow_file_range_inline(trans, root, inode,
-                                                    start, end, 0, 0, NULL);
+                        ret = cow_file_range_inline(root, inode, start, end,
+                                                    0, 0, NULL);
                 } else {
                         /* try making a compressed inline extent */
-                        ret = cow_file_range_inline(trans, root, inode,
-                                                    start, end,
+                        ret = cow_file_range_inline(root, inode, start, end,
                                                     total_compressed,
                                                     compress_type, pages);
                 }
                 if (ret <= 0) {
+                        unsigned long clear_flags = EXTENT_DELALLOC |
+                                EXTENT_DEFRAG;
+                        clear_flags |= (ret < 0) ? EXTENT_DO_ACCOUNTING : 0;
+
                         /*
                          * inline extent creation worked or returned error,
                          * we don't need to create any more async work items.
                          * Unlock and free up our temp pages.
                          */
-                        extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             start, end, NULL,
-                             EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
-
-                        btrfs_end_transaction(trans, root);
+                        extent_clear_unlock_delalloc(inode, start, end, NULL,
+                                                     clear_flags, PAGE_UNLOCK |
+                                                     PAGE_CLEAR_DIRTY |
+                                                     PAGE_SET_WRITEBACK |
+                                                     PAGE_END_WRITEBACK);
                         goto free_pages_out;
                 }
-                btrfs_end_transaction(trans, root);
         }
 
         if (will_compress) {
@@ -590,20 +591,6 @@ free_pages_out:
         kfree(pages);
 
         goto out;
-
-cleanup_and_out:
-        extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
-                                     start, end, NULL,
-                                     EXTENT_CLEAR_UNLOCK_PAGE |
-                                     EXTENT_CLEAR_DIRTY |
-                                     EXTENT_CLEAR_DELALLOC |
-                                     EXTENT_SET_WRITEBACK |
-                                     EXTENT_END_WRITEBACK);
-        if (!trans || IS_ERR(trans))
-                btrfs_error(root->fs_info, ret, "Failed to join transaction");
-        else
-                btrfs_abort_transaction(trans, root, ret);
-        goto free_pages_out;
 }
 
 /*
@@ -617,7 +604,6 @@ static noinline int submit_compressed_extents(struct inode *inode,
 {
         struct async_extent *async_extent;
         u64 alloc_hint = 0;
-        struct btrfs_trans_handle *trans;
         struct btrfs_key ins;
         struct extent_map *em;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -678,20 +664,10 @@ retry:
                 lock_extent(io_tree, async_extent->start,
                             async_extent->start + async_extent->ram_size - 1);
 
-                trans = btrfs_join_transaction(root);
-                if (IS_ERR(trans)) {
-                        ret = PTR_ERR(trans);
-                } else {
-                        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-                        ret = btrfs_reserve_extent(trans, root,
+                ret = btrfs_reserve_extent(root,
                                            async_extent->compressed_size,
                                            async_extent->compressed_size,
                                            0, alloc_hint, &ins, 1);
-                        if (ret && ret != -ENOSPC)
-                                btrfs_abort_transaction(trans, root, ret);
-                        btrfs_end_transaction(trans, root);
-                }
-
                 if (ret) {
                         int i;
 
@@ -770,16 +746,12 @@ retry:
                 /*
                  * clear dirty, set writeback and unlock the pages.
                  */
-                extent_clear_unlock_delalloc(inode,
-                                &BTRFS_I(inode)->io_tree,
-                                async_extent->start,
+                extent_clear_unlock_delalloc(inode, async_extent->start,
                                 async_extent->start +
                                 async_extent->ram_size - 1,
-                                NULL, EXTENT_CLEAR_UNLOCK_PAGE |
-                                EXTENT_CLEAR_UNLOCK |
-                                EXTENT_CLEAR_DELALLOC |
-                                EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
-
+                                NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
+                                PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
+                                PAGE_SET_WRITEBACK);
                 ret = btrfs_submit_compressed_write(inode,
                                     async_extent->start,
                                     async_extent->ram_size,
@@ -798,16 +770,13 @@ out:
 out_free_reserve:
         btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
 out_free:
-        extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
-                                     async_extent->start,
+        extent_clear_unlock_delalloc(inode, async_extent->start,
                                      async_extent->start +
                                      async_extent->ram_size - 1,
-                                     NULL, EXTENT_CLEAR_UNLOCK_PAGE |
-                                     EXTENT_CLEAR_UNLOCK |
-                                     EXTENT_CLEAR_DELALLOC |
-                                     EXTENT_CLEAR_DIRTY |
-                                     EXTENT_SET_WRITEBACK |
-                                     EXTENT_END_WRITEBACK);
+                                     NULL, EXTENT_LOCKED | EXTENT_DELALLOC |
+                                     EXTENT_DEFRAG | EXTENT_DO_ACCOUNTING,
+                                     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
+                                     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK);
         kfree(async_extent);
         goto again;
 }
@@ -857,14 +826,13 @@ static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
  * required to start IO on it.  It may be clean and already done with
  * IO when we return.
  */
-static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
-                                     struct inode *inode,
-                                     struct btrfs_root *root,
-                                     struct page *locked_page,
-                                     u64 start, u64 end, int *page_started,
-                                     unsigned long *nr_written,
-                                     int unlock)
+static noinline int cow_file_range(struct inode *inode,
+                                   struct page *locked_page,
+                                   u64 start, u64 end, int *page_started,
+                                   unsigned long *nr_written,
+                                   int unlock)
 {
+        struct btrfs_root *root = BTRFS_I(inode)->root;
         u64 alloc_hint = 0;
         u64 num_bytes;
         unsigned long ram_size;
@@ -885,29 +853,24 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
         /* if this is a small write inside eof, kick off defrag */
         if (num_bytes < 64 * 1024 &&
             (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
-                btrfs_add_inode_defrag(trans, inode);
+                btrfs_add_inode_defrag(NULL, inode);
 
         if (start == 0) {
                 /* lets try to make an inline extent */
-                ret = cow_file_range_inline(trans, root, inode,
-                                            start, end, 0, 0, NULL);
+                ret = cow_file_range_inline(root, inode, start, end, 0, 0,
+                                            NULL);
                 if (ret == 0) {
-                        extent_clear_unlock_delalloc(inode,
-                                     &BTRFS_I(inode)->io_tree,
-                                     start, end, NULL,
-                                     EXTENT_CLEAR_UNLOCK_PAGE |
-                                     EXTENT_CLEAR_UNLOCK |
-                                     EXTENT_CLEAR_DELALLOC |
-                                     EXTENT_CLEAR_DIRTY |
-                                     EXTENT_SET_WRITEBACK |
-                                     EXTENT_END_WRITEBACK);
+                        extent_clear_unlock_delalloc(inode, start, end, NULL,
+                                     EXTENT_LOCKED | EXTENT_DELALLOC |
+                                     EXTENT_DEFRAG, PAGE_UNLOCK |
+                                     PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK |
+                                     PAGE_END_WRITEBACK);
 
                         *nr_written = *nr_written +
                              (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
                         *page_started = 1;
                         goto out;
                 } else if (ret < 0) {
-                        btrfs_abort_transaction(trans, root, ret);
                         goto out_unlock;
                 }
         }
@@ -922,13 +885,11 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
                 unsigned long op;
 
                 cur_alloc_size = disk_num_bytes;
-                ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
+                ret = btrfs_reserve_extent(root, cur_alloc_size,
                                            root->sectorsize, 0, alloc_hint,
                                            &ins, 1);
-                if (ret < 0) {
-                        btrfs_abort_transaction(trans, root, ret);
+                if (ret < 0)
                         goto out_unlock;
-                }
 
                 em = alloc_extent_map();
                 if (!em) {
@@ -974,10 +935,8 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
                     BTRFS_DATA_RELOC_TREE_OBJECTID) {
                         ret = btrfs_reloc_clone_csums(inode, start,
                                                       cur_alloc_size);
-                        if (ret) {
-                                btrfs_abort_transaction(trans, root, ret);
+                        if (ret)
                                 goto out_reserve;
-                        }
                 }
 
                 if (disk_num_bytes < cur_alloc_size)
@@ -990,13 +949,13 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
                  * Do set the Private2 bit so we know this page was properly
                  * setup for writepage
                  */
-                op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
-                op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
-                        EXTENT_SET_PRIVATE2;
+                op = unlock ? PAGE_UNLOCK : 0;
+                op |= PAGE_SET_PRIVATE2;
 
-                extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
-                                             start, start + ram_size - 1,
-                                             locked_page, op);
+                extent_clear_unlock_delalloc(inode, start,
+                                             start + ram_size - 1, locked_page,
+                                             EXTENT_LOCKED | EXTENT_DELALLOC,
+                                             op);
                 disk_num_bytes -= cur_alloc_size;
                 num_bytes -= cur_alloc_size;
                 alloc_hint = ins.objectid + ins.offset;
@@ -1008,52 +967,14 @@ out:
 out_reserve:
         btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
 out_unlock:
-        extent_clear_unlock_delalloc(inode,
-                     &BTRFS_I(inode)->io_tree,
-                     start, end, locked_page,
-                     EXTENT_CLEAR_UNLOCK_PAGE |
-                     EXTENT_CLEAR_UNLOCK |
-                     EXTENT_CLEAR_DELALLOC |
-                     EXTENT_CLEAR_DIRTY |
-                     EXTENT_SET_WRITEBACK |
-                     EXTENT_END_WRITEBACK);
-
+        extent_clear_unlock_delalloc(inode, start, end, locked_page,
+                                     EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
+                                     EXTENT_DELALLOC | EXTENT_DEFRAG,
+                                     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
+                                     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK);
         goto out;
 }
 
-static noinline int cow_file_range(struct inode *inode,
-                                   struct page *locked_page,
-                                   u64 start, u64 end, int *page_started,
-                                   unsigned long *nr_written,
-                                   int unlock)
-{
-        struct btrfs_trans_handle *trans;
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        int ret;
-
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans)) {
-                extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             start, end, locked_page,
-                             EXTENT_CLEAR_UNLOCK_PAGE |
-                             EXTENT_CLEAR_UNLOCK |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_CLEAR_DIRTY |
-                             EXTENT_SET_WRITEBACK |
-                             EXTENT_END_WRITEBACK);
-                return PTR_ERR(trans);
-        }
-        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-
-        ret = __cow_file_range(trans, inode, root, locked_page, start, end,
-                               page_started, nr_written, unlock);
-
-        btrfs_end_transaction(trans, root);
-
-        return ret;
-}
-
 /*
  * work queue call back to started compression on a file and pages
  */
@@ -1221,15 +1142,13 @@ static noinline int run_delalloc_nocow(struct inode *inode,
 
         path = btrfs_alloc_path();
         if (!path) {
-                extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             start, end, locked_page,
-                             EXTENT_CLEAR_UNLOCK_PAGE |
-                             EXTENT_CLEAR_UNLOCK |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_CLEAR_DIRTY |
-                             EXTENT_SET_WRITEBACK |
-                             EXTENT_END_WRITEBACK);
+                extent_clear_unlock_delalloc(inode, start, end, locked_page,
+                                             EXTENT_LOCKED | EXTENT_DELALLOC |
+                                             EXTENT_DO_ACCOUNTING |
+                                             EXTENT_DEFRAG, PAGE_UNLOCK |
+                                             PAGE_CLEAR_DIRTY |
+                                             PAGE_SET_WRITEBACK |
+                                             PAGE_END_WRITEBACK);
                 return -ENOMEM;
         }
 
@@ -1241,15 +1160,13 @@ static noinline int run_delalloc_nocow(struct inode *inode,
                 trans = btrfs_join_transaction(root);
 
         if (IS_ERR(trans)) {
-                extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             start, end, locked_page,
-                             EXTENT_CLEAR_UNLOCK_PAGE |
-                             EXTENT_CLEAR_UNLOCK |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_CLEAR_DIRTY |
-                             EXTENT_SET_WRITEBACK |
-                             EXTENT_END_WRITEBACK);
+                extent_clear_unlock_delalloc(inode, start, end, locked_page,
+                                             EXTENT_LOCKED | EXTENT_DELALLOC |
+                                             EXTENT_DO_ACCOUNTING |
+                                             EXTENT_DEFRAG, PAGE_UNLOCK |
+                                             PAGE_CLEAR_DIRTY |
+                                             PAGE_SET_WRITEBACK |
+                                             PAGE_END_WRITEBACK);
                 btrfs_free_path(path);
                 return PTR_ERR(trans);
         }
@@ -1369,9 +1286,9 @@ out_check:
 
                 btrfs_release_path(path);
                 if (cow_start != (u64)-1) {
-                        ret = __cow_file_range(trans, inode, root, locked_page,
-                                               cow_start, found_key.offset - 1,
-                                               page_started, nr_written, 1);
+                        ret = cow_file_range(inode, locked_page,
+                                             cow_start, found_key.offset - 1,
+                                             page_started, nr_written, 1);
                         if (ret) {
                                 btrfs_abort_transaction(trans, root, ret);
                                 goto error;
@@ -1428,11 +1345,11 @@ out_check:
                         }
                 }
 
-                extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
-                                cur_offset, cur_offset + num_bytes - 1,
-                                locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
-                                EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
-                                EXTENT_SET_PRIVATE2);
+                extent_clear_unlock_delalloc(inode, cur_offset,
+                                             cur_offset + num_bytes - 1,
+                                             locked_page, EXTENT_LOCKED |
+                                             EXTENT_DELALLOC, PAGE_UNLOCK |
+                                             PAGE_SET_PRIVATE2);
                 cur_offset = extent_end;
                 if (cur_offset > end)
                         break;
@@ -1445,9 +1362,8 @@ out_check:
         }
 
         if (cow_start != (u64)-1) {
-                ret = __cow_file_range(trans, inode, root, locked_page,
-                                       cow_start, end,
-                                       page_started, nr_written, 1);
+                ret = cow_file_range(inode, locked_page, cow_start, end,
+                                     page_started, nr_written, 1);
                 if (ret) {
                         btrfs_abort_transaction(trans, root, ret);
                         goto error;
@@ -1460,16 +1376,13 @@ error:
                 ret = err;
 
         if (ret && cur_offset < end)
-                extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             cur_offset, end, locked_page,
-                             EXTENT_CLEAR_UNLOCK_PAGE |
-                             EXTENT_CLEAR_UNLOCK |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_CLEAR_DIRTY |
-                             EXTENT_SET_WRITEBACK |
-                             EXTENT_END_WRITEBACK);
-
+                extent_clear_unlock_delalloc(inode, cur_offset, end,
+                                             locked_page, EXTENT_LOCKED |
+                                             EXTENT_DELALLOC | EXTENT_DEFRAG |
+                                             EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
+                                             PAGE_CLEAR_DIRTY |
+                                             PAGE_SET_WRITEBACK |
+                                             PAGE_END_WRITEBACK);
         btrfs_free_path(path);
         return ret;
 }
@@ -2132,6 +2045,7 @@ static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
                 WARN_ON(1);
                 return ret;
         }
+        ret = 0;
 
         while (1) {
                 cond_resched();
@@ -2181,8 +2095,6 @@ static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
                     old->len || extent_offset + num_bytes <=
                     old->extent_offset + old->offset)
                         continue;
-
-                ret = 0;
                 break;
         }
 
@@ -2238,16 +2150,18 @@ static noinline bool record_extent_backrefs(struct btrfs_path *path,
 
 static int relink_is_mergable(struct extent_buffer *leaf,
                               struct btrfs_file_extent_item *fi,
-                              u64 disk_bytenr)
+                              struct new_sa_defrag_extent *new)
 {
-        if (btrfs_file_extent_disk_bytenr(leaf, fi) != disk_bytenr)
+        if (btrfs_file_extent_disk_bytenr(leaf, fi) != new->bytenr)
                 return 0;
 
         if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
                 return 0;
 
-        if (btrfs_file_extent_compression(leaf, fi) ||
-            btrfs_file_extent_encryption(leaf, fi) ||
+        if (btrfs_file_extent_compression(leaf, fi) != new->compress_type)
+                return 0;
+
+        if (btrfs_file_extent_encryption(leaf, fi) ||
             btrfs_file_extent_other_encoding(leaf, fi))
                 return 0;
 
@@ -2391,8 +2305,8 @@ again:
                                     struct btrfs_file_extent_item);
                 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
 
-                if (relink_is_mergable(leaf, fi, new->bytenr) &&
-                    extent_len + found_key.offset == start) {
+                if (extent_len + found_key.offset == start &&
+                    relink_is_mergable(leaf, fi, new)) {
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         extent_len + len);
                         btrfs_mark_buffer_dirty(leaf);
@@ -2648,8 +2562,10 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
         struct extent_state *cached_state = NULL;
         struct new_sa_defrag_extent *new = NULL;
         int compress_type = 0;
-        int ret;
+        int ret = 0;
+        u64 logical_len = ordered_extent->len;
         bool nolock;
+        bool truncated = false;
 
         nolock = btrfs_is_free_space_inode(inode);
 
@@ -2658,6 +2574,14 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
                 goto out;
         }
 
+        if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {
+                truncated = true;
+                logical_len = ordered_extent->truncated_len;
+                /* Truncated the entire extent, don't bother adding */
+                if (!logical_len)
+                        goto out;
+        }
+
         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
                 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
                 btrfs_ordered_update_i_size(inode, 0, ordered_extent);
@@ -2713,15 +2637,14 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
                 ret = btrfs_mark_extent_written(trans, inode,
                                                 ordered_extent->file_offset,
                                                 ordered_extent->file_offset +
-                                                ordered_extent->len);
+                                                logical_len);
         } else {
                 BUG_ON(root == root->fs_info->tree_root);
                 ret = insert_reserved_file_extent(trans, inode,
                                                 ordered_extent->file_offset,
                                                 ordered_extent->start,
                                                 ordered_extent->disk_len,
-                                                ordered_extent->len,
-                                                ordered_extent->len,
+                                                logical_len, logical_len,
                                                 compress_type, 0, 0,
                                                 BTRFS_FILE_EXTENT_REG);
         }
@@ -2753,17 +2676,27 @@ out:
         if (trans)
                 btrfs_end_transaction(trans, root);
 
-        if (ret) {
-                clear_extent_uptodate(io_tree, ordered_extent->file_offset,
-                                      ordered_extent->file_offset +
-                                      ordered_extent->len - 1, NULL, GFP_NOFS);
+        if (ret || truncated) {
+                u64 start, end;
+
+                if (truncated)
+                        start = ordered_extent->file_offset + logical_len;
+                else
+                        start = ordered_extent->file_offset;
+                end = ordered_extent->file_offset + ordered_extent->len - 1;
+                clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS);
+
+                /* Drop the cache for the part of the extent we didn't write. */
+                btrfs_drop_extent_cache(inode, start, end, 0);
 
                 /*
                  * If the ordered extent had an IOERR or something else went
                  * wrong we need to return the space for this ordered extent
-                 * back to the allocator.
+                 * back to the allocator.  We only free the extent in the
+                 * truncated case if we didn't write out the extent at all.
                  */
-                if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
+                if ((ret || !logical_len) &&
+                    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
                     !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags))
                         btrfs_free_reserved_extent(root, ordered_extent->start,
                                                    ordered_extent->disk_len);
@@ -2827,16 +2760,16 @@ static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
  * if there's a match, we allow the bio to finish.  If not, the code in
  * extent_io.c will try to find good copies for us.
  */
-static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
-                               struct extent_state *state, int mirror)
+static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
+                                      u64 phy_offset, struct page *page,
+                                      u64 start, u64 end, int mirror)
 {
         size_t offset = start - page_offset(page);
         struct inode *inode = page->mapping->host;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         char *kaddr;
-        u64 private = ~(u32)0;
-        int ret;
         struct btrfs_root *root = BTRFS_I(inode)->root;
+        u32 csum_expected;
         u32 csum = ~(u32)0;
         static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
                                       DEFAULT_RATELIMIT_BURST);
@@ -2856,19 +2789,13 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
                 return 0;
         }
 
-        if (state && state->start == start) {
-                private = state->private;
-                ret = 0;
-        } else {
-                ret = get_state_private(io_tree, start, &private);
-        }
-        kaddr = kmap_atomic(page);
-        if (ret)
-                goto zeroit;
+        phy_offset >>= inode->i_sb->s_blocksize_bits;
+        csum_expected = *(((u32 *)io_bio->csum) + phy_offset);
 
+        kaddr = kmap_atomic(page);
         csum = btrfs_csum_data(kaddr + offset, csum,  end - start + 1);
         btrfs_csum_final(csum, (char *)&csum);
-        if (csum != private)
+        if (csum != csum_expected)
                 goto zeroit;
 
         kunmap_atomic(kaddr);
@@ -2877,14 +2804,12 @@ good:
 
 zeroit:
         if (__ratelimit(&_rs))
-                btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u private %llu",
-                        (unsigned long long)btrfs_ino(page->mapping->host),
-                        (unsigned long long)start, csum,
-                        (unsigned long long)private);
+                btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
+                        btrfs_ino(page->mapping->host), start, csum, csum_expected);
         memset(kaddr + offset, 1, end - start + 1);
         flush_dcache_page(page);
         kunmap_atomic(kaddr);
-        if (private == 0)
+        if (csum_expected == 0)
                 return 0;
         return -EIO;
 }
@@ -2971,8 +2896,10 @@ void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
             btrfs_root_refs(&root->root_item) > 0) {
                 ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
                                             root->root_key.objectid);
-                BUG_ON(ret);
-                root->orphan_item_inserted = 0;
+                if (ret)
+                        btrfs_abort_transaction(trans, root, ret);
+                else
+                        root->orphan_item_inserted = 0;
         }
 
         if (block_rsv) {
@@ -3041,11 +2968,18 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
         /* insert an orphan item to track this unlinked/truncated file */
         if (insert >= 1) {
                 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
-                if (ret && ret != -EEXIST) {
-                        clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
-                                  &BTRFS_I(inode)->runtime_flags);
-                        btrfs_abort_transaction(trans, root, ret);
-                        return ret;
+                if (ret) {
+                        if (reserve) {
+                                clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
+                                          &BTRFS_I(inode)->runtime_flags);
+                                btrfs_orphan_release_metadata(inode);
+                        }
+                        if (ret != -EEXIST) {
+                                clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                                          &BTRFS_I(inode)->runtime_flags);
+                                btrfs_abort_transaction(trans, root, ret);
+                                return ret;
+                        }
                 }
                 ret = 0;
         }
@@ -3084,17 +3018,15 @@ static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
                 release_rsv = 1;
         spin_unlock(&root->orphan_lock);
 
-        if (trans && delete_item) {
+        if (trans && delete_item)
                 ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
-                BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
-        }
 
         if (release_rsv) {
                 btrfs_orphan_release_metadata(inode);
                 atomic_dec(&root->orphan_inodes);
         }
 
-        return 0;
+        return ret;
 }
 
 /*
@@ -3224,8 +3156,9 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                                 found_key.objectid);
                         ret = btrfs_del_orphan_item(trans, root,
                                                     found_key.objectid);
-                        BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
                         btrfs_end_transaction(trans, root);
+                        if (ret)
+                                goto out;
                         continue;
                 }
 
@@ -3657,8 +3590,7 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         if (ret) {
                 btrfs_info(root->fs_info,
                         "failed to delete reference to %.*s, inode %llu parent %llu",
-                        name_len, name,
-                        (unsigned long long)ino, (unsigned long long)dir_ino);
+                        name_len, name, ino, dir_ino);
                 btrfs_abort_transaction(trans, root, ret);
                 goto err;
         }
@@ -3929,6 +3861,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         u64 extent_num_bytes = 0;
         u64 extent_offset = 0;
         u64 item_end = 0;
+        u64 last_size = (u64)-1;
         u32 found_type = (u8)-1;
         int found_extent;
         int del_item;
@@ -4026,6 +3959,11 @@ search_again:
                 if (found_type != BTRFS_EXTENT_DATA_KEY)
                         goto delete;
 
+                if (del_item)
+                        last_size = found_key.offset;
+                else
+                        last_size = new_size;
+
                 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
                         u64 num_dec;
                         extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
@@ -4137,6 +4075,8 @@ out:
                         btrfs_abort_transaction(trans, root, ret);
         }
 error:
+        if (last_size != (u64)-1)
+                btrfs_ordered_update_i_size(inode, last_size, NULL);
         btrfs_free_path(path);
         return err;
 }
@@ -4465,8 +4405,26 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
                 btrfs_inode_resume_unlocked_dio(inode);
 
                 ret = btrfs_truncate(inode);
-                if (ret && inode->i_nlink)
-                        btrfs_orphan_del(NULL, inode);
+                if (ret && inode->i_nlink) {
+                        int err;
+
+                        /*
+                         * failed to truncate, disk_i_size is only adjusted down
+                         * as we remove extents, so it should represent the true
+                         * size of the inode, so reset the in memory size and
+                         * delete our orphan entry.
+                         */
+                        trans = btrfs_join_transaction(root);
+                        if (IS_ERR(trans)) {
+                                btrfs_orphan_del(NULL, inode);
+                                return ret;
+                        }
+                        i_size_write(inode, BTRFS_I(inode)->disk_i_size);
+                        err = btrfs_orphan_del(trans, inode);
+                        if (err)
+                                btrfs_abort_transaction(trans, root, err);
+                        btrfs_end_transaction(trans, root);
+                }
         }
 
         return ret;
@@ -4601,10 +4559,15 @@ void btrfs_evict_inode(struct inode *inode)
 
         btrfs_free_block_rsv(root, rsv);
 
+        /*
+         * Errors here aren't a big deal, it just means we leave orphan items
+         * in the tree.  They will be cleaned up on the next mount.
+         */
         if (ret == 0) {
                 trans->block_rsv = root->orphan_block_rsv;
-                ret = btrfs_orphan_del(trans, inode);
-                BUG_ON(ret);
+                btrfs_orphan_del(trans, inode);
+        } else {
+                btrfs_orphan_del(NULL, inode);
         }
 
         trans->block_rsv = &root->fs_info->trans_block_rsv;
@@ -6161,10 +6124,7 @@ insert:
         btrfs_release_path(path);
         if (em->start > start || extent_map_end(em) <= start) {
                 btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]",
-                        (unsigned long long)em->start,
-                        (unsigned long long)em->len,
-                        (unsigned long long)start,
-                        (unsigned long long)len);
+                        em->start, em->len, start, len);
                 err = -EIO;
                 goto out;
         }
@@ -6362,39 +6322,32 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
                                                   u64 start, u64 len)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
         struct extent_map *em;
         struct btrfs_key ins;
         u64 alloc_hint;
         int ret;
 
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans))
-                return ERR_CAST(trans);
-
-        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-
         alloc_hint = get_extent_allocation_hint(inode, start, len);
-        ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
+        ret = btrfs_reserve_extent(root, len, root->sectorsize, 0,
                                    alloc_hint, &ins, 1);
-        if (ret) {
-                em = ERR_PTR(ret);
-                goto out;
-        }
+        if (ret)
+                return ERR_PTR(ret);
 
         em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
                               ins.offset, ins.offset, ins.offset, 0);
-        if (IS_ERR(em))
-                goto out;
+        if (IS_ERR(em)) {
+                btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
+                return em;
+        }
 
         ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
                                            ins.offset, ins.offset, 0);
         if (ret) {
                 btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
-                em = ERR_PTR(ret);
+                free_extent_map(em);
+                return ERR_PTR(ret);
         }
-out:
-        btrfs_end_transaction(trans, root);
+
         return em;
 }
 
@@ -6402,11 +6355,11 @@ out:
  * returns 1 when the nocow is safe, < 1 on error, 0 if the
  * block must be cow'd
  */
-noinline int can_nocow_extent(struct btrfs_trans_handle *trans,
-                              struct inode *inode, u64 offset, u64 *len,
+noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
                               u64 *orig_start, u64 *orig_block_len,
                               u64 *ram_bytes)
 {
+        struct btrfs_trans_handle *trans;
         struct btrfs_path *path;
         int ret;
         struct extent_buffer *leaf;
@@ -6424,7 +6377,7 @@ noinline int can_nocow_extent(struct btrfs_trans_handle *trans,
         if (!path)
                 return -ENOMEM;
 
-        ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
+        ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(inode),
                                        offset, 0);
         if (ret < 0)
                 goto out;
@@ -6489,9 +6442,19 @@ noinline int can_nocow_extent(struct btrfs_trans_handle *trans,
          * look for other files referencing this extent, if we
          * find any we must cow
          */
-        if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
-                                  key.offset - backref_offset, disk_bytenr))
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans)) {
+                ret = 0;
                 goto out;
+        }
+
+        ret = btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
+                                    key.offset - backref_offset, disk_bytenr);
+        btrfs_end_transaction(trans, root);
+        if (ret) {
+                ret = 0;
+                goto out;
+        }
 
         /*
          * adjust disk_bytenr and num_bytes to cover just the bytes
@@ -6633,7 +6596,6 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
         u64 start = iblock << inode->i_blkbits;
         u64 lockstart, lockend;
         u64 len = bh_result->b_size;
-        struct btrfs_trans_handle *trans;
         int unlock_bits = EXTENT_LOCKED;
         int ret = 0;
 
@@ -6715,16 +6677,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                 len = min(len, em->len - (start - em->start));
                 block_start = em->block_start + (start - em->start);
 
-                /*
-                 * we're not going to log anything, but we do need
-                 * to make sure the current transaction stays open
-                 * while we look for nocow cross refs
-                 */
-                trans = btrfs_join_transaction(root);
-                if (IS_ERR(trans))
-                        goto must_cow;
-
-                if (can_nocow_extent(trans, inode, start, &len, &orig_start,
+                if (can_nocow_extent(inode, start, &len, &orig_start,
                                      &orig_block_len, &ram_bytes) == 1) {
                         if (type == BTRFS_ORDERED_PREALLOC) {
                                 free_extent_map(em);
@@ -6733,24 +6686,20 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                                                        block_start, len,
                                                        orig_block_len,
                                                        ram_bytes, type);
-                                if (IS_ERR(em)) {
-                                        btrfs_end_transaction(trans, root);
+                                if (IS_ERR(em))
                                         goto unlock_err;
-                                }
                         }
 
                         ret = btrfs_add_ordered_extent_dio(inode, start,
                                            block_start, len, len, type);
-                        btrfs_end_transaction(trans, root);
                         if (ret) {
                                 free_extent_map(em);
                                 goto unlock_err;
                         }
                         goto unlock;
                 }
-                btrfs_end_transaction(trans, root);
         }
-must_cow:
+
         /*
          * this will cow the extent, reset the len in case we changed
          * it above
@@ -6813,26 +6762,6 @@ unlock_err:
         return ret;
 }
 
-struct btrfs_dio_private {
-        struct inode *inode;
-        u64 logical_offset;
-        u64 disk_bytenr;
-        u64 bytes;
-        void *private;
-
-        /* number of bios pending for this dio */
-        atomic_t pending_bios;
-
-        /* IO errors */
-        int errors;
-
-        /* orig_bio is our btrfs_io_bio */
-        struct bio *orig_bio;
-
-        /* dio_bio came from fs/direct-io.c */
-        struct bio *dio_bio;
-};
-
 static void btrfs_endio_direct_read(struct bio *bio, int err)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
@@ -6841,6 +6770,8 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct bio *dio_bio;
+        u32 *csums = (u32 *)dip->csum;
+        int index = 0;
         u64 start;
 
         start = dip->logical_offset;
@@ -6849,12 +6780,8 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
                         struct page *page = bvec->bv_page;
                         char *kaddr;
                         u32 csum = ~(u32)0;
-                        u64 private = ~(u32)0;
                         unsigned long flags;
 
-                        if (get_state_private(&BTRFS_I(inode)->io_tree,
-                                              start, &private))
-                                goto failed;
                         local_irq_save(flags);
                         kaddr = kmap_atomic(page);
                         csum = btrfs_csum_data(kaddr + bvec->bv_offset,
@@ -6864,18 +6791,17 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
                         local_irq_restore(flags);
 
                         flush_dcache_page(bvec->bv_page);
-                        if (csum != private) {
-failed:
-                                btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u private %u",
-                                        (unsigned long long)btrfs_ino(inode),
-                                        (unsigned long long)start,
-                                        csum, (unsigned)private);
+                        if (csum != csums[index]) {
+                                btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
+                                          btrfs_ino(inode), start, csum,
+                                          csums[index]);
                                 err = -EIO;
                         }
                 }
 
                 start += bvec->bv_len;
                 bvec++;
+                index++;
         } while (bvec <= bvec_end);
 
         unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
@@ -6956,7 +6882,7 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
         if (err) {
                 printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
                       "sector %#Lx len %u err no %d\n",
-                      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
+                      btrfs_ino(dip->inode), bio->bi_rw,
                       (unsigned long long)bio->bi_sector, bio->bi_size, err);
                 dip->errors = 1;
 
@@ -6992,6 +6918,7 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
                                          int rw, u64 file_offset, int skip_sum,
                                          int async_submit)
 {
+        struct btrfs_dio_private *dip = bio->bi_private;
         int write = rw & REQ_WRITE;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
@@ -7026,7 +6953,8 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
                 if (ret)
                         goto err;
         } else if (!skip_sum) {
-                ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
+                ret = btrfs_lookup_bio_sums_dio(root, inode, dip, bio,
+                                                file_offset);
                 if (ret)
                         goto err;
         }
@@ -7061,6 +6989,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                 bio_put(orig_bio);
                 return -EIO;
         }
+
         if (map_length >= orig_bio->bi_size) {
                 bio = orig_bio;
                 goto submit;
@@ -7156,19 +7085,28 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
         struct btrfs_dio_private *dip;
         struct bio *io_bio;
         int skip_sum;
+        int sum_len;
         int write = rw & REQ_WRITE;
         int ret = 0;
+        u16 csum_size;
 
         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);
-
         if (!io_bio) {
                 ret = -ENOMEM;
                 goto free_ordered;
         }
 
-        dip = kmalloc(sizeof(*dip), GFP_NOFS);
+        if (!skip_sum && !write) {
+                csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
+                sum_len = dio_bio->bi_size >> inode->i_sb->s_blocksize_bits;
+                sum_len *= csum_size;
+        } else {
+                sum_len = 0;
+        }
+
+        dip = kmalloc(sizeof(*dip) + sum_len, GFP_NOFS);
         if (!dip) {
                 ret = -ENOMEM;
                 goto free_io_bio;
@@ -7443,10 +7381,23 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
                  * whoever cleared the private bit is responsible
                  * for the finish_ordered_io
                  */
-                if (TestClearPagePrivate2(page) &&
-                    btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
-                                                   PAGE_CACHE_SIZE, 1)) {
-                        btrfs_finish_ordered_io(ordered);
+                if (TestClearPagePrivate2(page)) {
+                        struct btrfs_ordered_inode_tree *tree;
+                        u64 new_len;
+
+                        tree = &BTRFS_I(inode)->ordered_tree;
+
+                        spin_lock_irq(&tree->lock);
+                        set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
+                        new_len = page_start - ordered->file_offset;
+                        if (new_len < ordered->truncated_len)
+                                ordered->truncated_len = new_len;
+                        spin_unlock_irq(&tree->lock);
+
+                        if (btrfs_dec_test_ordered_pending(inode, &ordered,
+                                                           page_start,
+                                                           PAGE_CACHE_SIZE, 1))
+                                btrfs_finish_ordered_io(ordered);
                 }
                 btrfs_put_ordered_extent(ordered);
                 cached_state = NULL;
@@ -7612,7 +7563,6 @@ static int btrfs_truncate(struct inode *inode)
         u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
 
         btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
-        btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
 
         /*
          * Yes ladies and gentelment, this is indeed ugly.  The fact is we have
@@ -7876,7 +7826,7 @@ void btrfs_destroy_inode(struct inode *inode)
         if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
                      &BTRFS_I(inode)->runtime_flags)) {
                 btrfs_info(root->fs_info, "inode %llu still on the orphan list",
-                        (unsigned long long)btrfs_ino(inode));
+                        btrfs_ino(inode));
                 atomic_dec(&root->orphan_inodes);
         }
 
@@ -7886,8 +7836,7 @@ void btrfs_destroy_inode(struct inode *inode)
                         break;
                 else {
                         btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup",
-                                (unsigned long long)ordered->file_offset,
-                                (unsigned long long)ordered->len);
+                                ordered->file_offset, ordered->len);
                         btrfs_remove_ordered_extent(inode, ordered);
                         btrfs_put_ordered_extent(ordered);
                         btrfs_put_ordered_extent(ordered);
@@ -8161,10 +8110,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                                  new_dentry->d_name.name,
                                                  new_dentry->d_name.len);
                 }
-                if (!ret && new_inode->i_nlink == 0) {
+                if (!ret && new_inode->i_nlink == 0)
                         ret = btrfs_orphan_add(trans, new_dentry->d_inode);
-                        BUG_ON(ret);
-                }
                 if (ret) {
                         btrfs_abort_transaction(trans, root, ret);
                         goto out_fail;
@@ -8525,8 +8472,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
 
                 cur_bytes = min(num_bytes, 256ULL * 1024 * 1024);
                 cur_bytes = max(cur_bytes, min_size);
-                ret = btrfs_reserve_extent(trans, root, cur_bytes,
-                                           min_size, 0, *alloc_hint, &ins, 1);
+                ret = btrfs_reserve_extent(root, cur_bytes, min_size, 0,
+                                           *alloc_hint, &ins, 1);
                 if (ret) {
                         if (own_trans)
                                 btrfs_end_transaction(trans, root);