1 files changed, 65 insertions, 29 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 855935f6671a..e33dff356460 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4209,7 +4209,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;
+        u64 last_size = new_size;
         u32 found_type = (u8)-1;
         int found_extent;
         int del_item;
@@ -4493,8 +4493,7 @@ out:
                         btrfs_abort_transaction(trans, root, ret);
         }
 error:
-        if (last_size != (u64)-1 &&
-            root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
+        if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
                 btrfs_ordered_update_i_size(inode, last_size, NULL);
 
         btrfs_free_path(path);
@@ -4989,8 +4988,9 @@ static void evict_inode_truncate_pages(struct inode *inode)
         /*
          * Keep looping until we have no more ranges in the io tree.
          * We can have ongoing bios started by readpages (called from readahead)
-         * that didn't get their end io callbacks called yet or they are still
-         * in progress ((extent_io.c:end_bio_extent_readpage()). This means some
+         * that have their endio callback (extent_io.c:end_bio_extent_readpage)
+         * still in progress (unlocked the pages in the bio but did not yet
+         * unlocked the ranges in the io tree). Therefore this means some
          * ranges can still be locked and eviction started because before
          * submitting those bios, which are executed by a separate task (work
          * queue kthread), inode references (inode->i_count) were not taken
@@ -7546,6 +7546,7 @@ unlock:
 
                 current->journal_info = outstanding_extents;
                 btrfs_free_reserved_data_space(inode, len);
+                set_bit(BTRFS_INODE_DIO_READY, &BTRFS_I(inode)->runtime_flags);
         }
 
         /*
@@ -7871,8 +7872,6 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
         struct bio *dio_bio;
         int ret;
 
-        if (err)
-                goto out_done;
 again:
         ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
                                                    &ordered_offset,
@@ -7895,7 +7894,6 @@ out_test:
                 ordered = NULL;
                 goto again;
         }
-out_done:
         dio_bio = dip->dio_bio;
 
         kfree(dip);
@@ -8163,9 +8161,8 @@ out_err:
 static void btrfs_submit_direct(int rw, struct bio *dio_bio,
                                 struct inode *inode, loff_t file_offset)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_dio_private *dip;
-        struct bio *io_bio;
+        struct btrfs_dio_private *dip = NULL;
+        struct bio *io_bio = NULL;
         struct btrfs_io_bio *btrfs_bio;
         int skip_sum;
         int write = rw & REQ_WRITE;
@@ -8182,7 +8179,7 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
         dip = kzalloc(sizeof(*dip), GFP_NOFS);
         if (!dip) {
                 ret = -ENOMEM;
-                goto free_io_bio;
+                goto free_ordered;
         }
 
         dip->private = dio_bio->bi_private;
@@ -8210,25 +8207,55 @@ static void btrfs_submit_direct(int rw, struct bio *dio_bio,
 
         if (btrfs_bio->end_io)
                 btrfs_bio->end_io(btrfs_bio, ret);
-free_io_bio:
-        bio_put(io_bio);
 
 free_ordered:
         /*
-         * If this is a write, we need to clean up the reserved space and kill
-         * the ordered extent.
+         * If we arrived here it means either we failed to submit the dip
+         * or we either failed to clone the dio_bio or failed to allocate the
+         * dip. If we cloned the dio_bio and allocated the dip, we can just
+         * call bio_endio against our io_bio so that we get proper resource
+         * cleanup if we fail to submit the dip, otherwise, we must do the
+         * same as btrfs_endio_direct_[write|read] because we can't call these
+         * callbacks - they require an allocated dip and a clone of dio_bio.
          */
-        if (write) {
-                struct btrfs_ordered_extent *ordered;
-                ordered = btrfs_lookup_ordered_extent(inode, file_offset);
-                if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
-                    !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
-                        btrfs_free_reserved_extent(root, ordered->start,
-                                                   ordered->disk_len, 1);
-                btrfs_put_ordered_extent(ordered);
-                btrfs_put_ordered_extent(ordered);
+        if (io_bio && dip) {
+                bio_endio(io_bio, ret);
+                /*
+                 * The end io callbacks free our dip, do the final put on io_bio
+                 * and all the cleanup and final put for dio_bio (through
+                 * dio_end_io()).
+                 */
+                dip = NULL;
+                io_bio = NULL;
+        } else {
+                if (write) {
+                        struct btrfs_ordered_extent *ordered;
+
+                        ordered = btrfs_lookup_ordered_extent(inode,
+                                                              file_offset);
+                        set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
+                        /*
+                         * Decrements our ref on the ordered extent and removes
+                         * the ordered extent from the inode's ordered tree,
+                         * doing all the proper resource cleanup such as for the
+                         * reserved space and waking up any waiters for this
+                         * ordered extent (through btrfs_remove_ordered_extent).
+                         */
+                        btrfs_finish_ordered_io(ordered);
+                } else {
+                        unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
+                              file_offset + dio_bio->bi_iter.bi_size - 1);
+                }
+                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
+                /*
+                 * Releases and cleans up our dio_bio, no need to bio_put()
+                 * nor bio_endio()/bio_io_error() against dio_bio.
+                 */
+                dio_end_io(dio_bio, ret);
         }
-        bio_endio(dio_bio, ret);
+        if (io_bio)
+                bio_put(io_bio);
+        kfree(dip);
 }
 
 static ssize_t check_direct_IO(struct btrfs_root *root, struct kiocb *iocb,
@@ -8330,9 +8357,18 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
                                    btrfs_submit_direct, flags);
         if (iov_iter_rw(iter) == WRITE) {
                 current->journal_info = NULL;
-                if (ret < 0 && ret != -EIOCBQUEUED)
-                        btrfs_delalloc_release_space(inode, count);
-                else if (ret >= 0 && (size_t)ret < count)
+                if (ret < 0 && ret != -EIOCBQUEUED) {
+                        /*
+                         * If the error comes from submitting stage,
+                         * btrfs_get_blocsk_direct() has free'd data space,
+                         * and metadata space will be handled by
+                         * finish_ordered_fn, don't do that again to make
+                         * sure bytes_may_use is correct.
+                         */
+                        if (!test_and_clear_bit(BTRFS_INODE_DIO_READY,
+                                     &BTRFS_I(inode)->runtime_flags))
+                                btrfs_delalloc_release_space(inode, count);
+                } else if (ret >= 0 && (size_t)ret < count)
                         btrfs_delalloc_release_space(inode,
                                                      count - (size_t)ret);
         }