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

Pull btrfs fixes from Chris Mason:
 "Miao Xie has been very busy, fixing races and enospc problems and many
  other small but important pieces.

  Alexandre Oliva discovered some problems with how our error handling
  was interacting with the block layer and for now has disabled our
  partial handling of sub-page writes.  The real sub-page work is in a
  series of patches from IBM that we still need to integrate and test.
  The code Alexandre has turned off was really incomplete.

  Josef has more error handling fixes and an important fix for the new
  skinny extent format.

  This also has my fix for the tracepoint crash from late in 3.9.  It's
  the first stage in a larger clean up to get rid of btrfs_bio and make
  a proper bioset for all the items we need to tack into the bio.  For
  now the bioset only holds our mirror_num and stripe_index, but for the
  next merge window I'll shuffle more in."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (25 commits)
  Btrfs: use a btrfs bioset instead of abusing bio internals
  Btrfs: make sure roots are assigned before freeing their nodes
  Btrfs: explicitly use global_block_rsv for quota_tree
  btrfs: do away with non-whole_page extent I/O
  Btrfs: don't invoke btrfs_invalidate_inodes() in the spin lock context
  Btrfs: remove BUG_ON() in btrfs_read_fs_tree_no_radix()
  Btrfs: pause the space balance when remounting to R/O
  Btrfs: fix unprotected root node of the subvolume's inode rb-tree
  Btrfs: fix accessing a freed tree root
  Btrfs: return errno if possible when we fail to allocate memory
  Btrfs: update the global reserve if it is empty
  Btrfs: don't steal the reserved space from the global reserve if their space type is different
  Btrfs: optimize the error handle of use_block_rsv()
  Btrfs: don't use global block reservation for inode cache truncation
  Btrfs: don't abort the current transaction if there is no enough space for inode cache
  Correct allowed raid levels on balance.
  Btrfs: fix possible memory leak in replace_path()
  Btrfs: fix possible memory leak in the find_parent_nodes()
  Btrfs: don't allow device replace on RAID5/RAID6
  Btrfs: handle running extent ops with skinny metadata
  ...

1 files changed, 53 insertions, 28 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 9b31b3b091fc..af978f7682b3 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -715,8 +715,10 @@ retry:
                                         async_extent->ram_size - 1, 0);
 
                 em = alloc_extent_map();
-                if (!em)
+                if (!em) {
+                        ret = -ENOMEM;
                         goto out_free_reserve;
+                }
                 em->start = async_extent->start;
                 em->len = async_extent->ram_size;
                 em->orig_start = em->start;
@@ -923,8 +925,10 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
                 }
 
                 em = alloc_extent_map();
-                if (!em)
+                if (!em) {
+                        ret = -ENOMEM;
                         goto out_reserve;
+                }
                 em->start = start;
                 em->orig_start = em->start;
                 ram_size = ins.offset;
@@ -4724,6 +4728,7 @@ void btrfs_evict_inode(struct inode *inode)
         btrfs_end_transaction(trans, root);
         btrfs_btree_balance_dirty(root);
 no_delete:
+        btrfs_remove_delayed_node(inode);
         clear_inode(inode);
         return;
 }
@@ -4839,14 +4844,13 @@ static void inode_tree_add(struct inode *inode)
         struct rb_node **p;
         struct rb_node *parent;
         u64 ino = btrfs_ino(inode);
-again:
-        p = &root->inode_tree.rb_node;
-        parent = NULL;
 
         if (inode_unhashed(inode))
                 return;
-
+again:
+        parent = NULL;
         spin_lock(&root->inode_lock);
+        p = &root->inode_tree.rb_node;
         while (*p) {
                 parent = *p;
                 entry = rb_entry(parent, struct btrfs_inode, rb_node);
@@ -6928,7 +6932,11 @@ struct btrfs_dio_private {
         /* 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)
@@ -6938,6 +6946,7 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
         struct bio_vec *bvec = bio->bi_io_vec;
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct bio *dio_bio;
         u64 start;
 
         start = dip->logical_offset;
@@ -6977,14 +6986,15 @@ failed:
 
         unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
                       dip->logical_offset + dip->bytes - 1);
-        bio->bi_private = dip->private;
+        dio_bio = dip->dio_bio;
 
         kfree(dip);
 
         /* If we had a csum failure make sure to clear the uptodate flag */
         if (err)
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
-        dio_end_io(bio, err);
+                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
+        dio_end_io(dio_bio, err);
+        bio_put(bio);
 }
 
 static void btrfs_endio_direct_write(struct bio *bio, int err)
@@ -6995,6 +7005,7 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
         struct btrfs_ordered_extent *ordered = NULL;
         u64 ordered_offset = dip->logical_offset;
         u64 ordered_bytes = dip->bytes;
+        struct bio *dio_bio;
         int ret;
 
         if (err)
@@ -7022,14 +7033,15 @@ out_test:
                 goto again;
         }
 out_done:
-        bio->bi_private = dip->private;
+        dio_bio = dip->dio_bio;
 
         kfree(dip);
 
         /* If we had an error make sure to clear the uptodate flag */
         if (err)
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
-        dio_end_io(bio, err);
+                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
+        dio_end_io(dio_bio, err);
+        bio_put(bio);
 }
 
 static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
@@ -7065,10 +7077,10 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
         if (!atomic_dec_and_test(&dip->pending_bios))
                 goto out;
 
-        if (dip->errors)
+        if (dip->errors) {
                 bio_io_error(dip->orig_bio);
-        else {
-                set_bit(BIO_UPTODATE, &dip->orig_bio->bi_flags);
+        } else {
+                set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags);
                 bio_endio(dip->orig_bio, 0);
         }
 out:
@@ -7243,25 +7255,34 @@ out_err:
         return 0;
 }
 
-static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
-                                loff_t file_offset)
+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_vec *bvec = bio->bi_io_vec;
+        struct bio_vec *bvec = dio_bio->bi_io_vec;
+        struct bio *io_bio;
         int skip_sum;
         int write = rw & REQ_WRITE;
         int ret = 0;
 
         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 (!dip) {
                 ret = -ENOMEM;
-                goto free_ordered;
+                goto free_io_bio;
         }
 
-        dip->private = bio->bi_private;
+        dip->private = dio_bio->bi_private;
+        io_bio->bi_private = dio_bio->bi_private;
         dip->inode = inode;
         dip->logical_offset = file_offset;
 
@@ -7269,22 +7290,27 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
         do {
                 dip->bytes += bvec->bv_len;
                 bvec++;
-        } while (bvec <= (bio->bi_io_vec + bio->bi_vcnt - 1));
+        } while (bvec <= (dio_bio->bi_io_vec + dio_bio->bi_vcnt - 1));
 
-        dip->disk_bytenr = (u64)bio->bi_sector << 9;
-        bio->bi_private = dip;
+        dip->disk_bytenr = (u64)dio_bio->bi_sector << 9;
+        io_bio->bi_private = dip;
         dip->errors = 0;
-        dip->orig_bio = bio;
+        dip->orig_bio = io_bio;
+        dip->dio_bio = dio_bio;
         atomic_set(&dip->pending_bios, 0);
 
         if (write)
-                bio->bi_end_io = btrfs_endio_direct_write;
+                io_bio->bi_end_io = btrfs_endio_direct_write;
         else
-                bio->bi_end_io = btrfs_endio_direct_read;
+                io_bio->bi_end_io = btrfs_endio_direct_read;
 
         ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
         if (!ret)
                 return;
+
+free_io_bio:
+        bio_put(io_bio);
+
 free_ordered:
         /*
          * If this is a write, we need to clean up the reserved space and kill
@@ -7300,7 +7326,7 @@ free_ordered:
                 btrfs_put_ordered_extent(ordered);
                 btrfs_put_ordered_extent(ordered);
         }
-        bio_endio(bio, ret);
+        bio_endio(dio_bio, ret);
 }
 
 static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
@@ -7979,7 +8005,6 @@ void btrfs_destroy_inode(struct inode *inode)
         inode_tree_del(inode);
         btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
 free:
-        btrfs_remove_delayed_node(inode);
         call_rcu(&inode->i_rcu, btrfs_i_callback);
 }