7 files changed, 93 insertions, 24 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index a99f1c2a710d..fedf8b9f03a2 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1469,6 +1469,7 @@ read_block_for_search(struct btrfs_trans_handle *trans,
         u32 blocksize;
         struct extent_buffer *b = *eb_ret;
         struct extent_buffer *tmp;
+        int ret;
 
         blocknr = btrfs_node_blockptr(b, slot);
         gen = btrfs_node_ptr_generation(b, slot);
@@ -1476,6 +1477,10 @@ read_block_for_search(struct btrfs_trans_handle *trans,
 
         tmp = btrfs_find_tree_block(root, blocknr, blocksize);
         if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
+                /*
+                 * we found an up to date block without sleeping, return
+                 * right away
+                 */
                 *eb_ret = tmp;
                 return 0;
         }
@@ -1483,7 +1488,9 @@ read_block_for_search(struct btrfs_trans_handle *trans,
         /*
          * reduce lock contention at high levels
          * of the btree by dropping locks before
-         * we read.
+         * we read.  Don't release the lock on the current
+         * level because we need to walk this node to figure
+         * out which blocks to read.
          */
         btrfs_unlock_up_safe(p, level + 1);
         btrfs_set_path_blocking(p);
@@ -1494,10 +1501,21 @@ read_block_for_search(struct btrfs_trans_handle *trans,
                 reada_for_search(root, p, level, slot, key->objectid);
 
         btrfs_release_path(NULL, p);
+
+        ret = -EAGAIN;
         tmp = read_tree_block(root, blocknr, blocksize, gen);
-        if (tmp)
+        if (tmp) {
+                /*
+                 * If the read above didn't mark this buffer up to date,
+                 * it will never end up being up to date.  Set ret to EIO now
+                 * and give up so that our caller doesn't loop forever
+                 * on our EAGAINs.
+                 */
+                if (!btrfs_buffer_uptodate(tmp, 0))
+                        ret = -EIO;
                 free_extent_buffer(tmp);
-        return -EAGAIN;
+        }
+        return ret;
 }
 
 /*
@@ -1696,6 +1714,9 @@ cow_done:
                         if (ret == -EAGAIN)
                                 goto again;
 
+                        if (ret == -EIO)
+                                goto done;
+
                         if (!p->skip_locking) {
                                 int lret;
 
@@ -1738,6 +1759,8 @@ done:
          */
         if (!p->leave_spinning)
                 btrfs_set_path_blocking(p);
+        if (ret < 0)
+                btrfs_release_path(root, p);
         return ret;
 }
 
@@ -4212,6 +4235,11 @@ again:
                 if (ret == -EAGAIN)
                         goto again;
 
+                if (ret < 0) {
+                        btrfs_release_path(root, path);
+                        goto done;
+                }
+
                 if (!path->skip_locking) {
                         ret = btrfs_try_spin_lock(next);
                         if (!ret) {
@@ -4246,6 +4274,11 @@ again:
                 if (ret == -EAGAIN)
                         goto again;
 
+                if (ret < 0) {
+                        btrfs_release_path(root, path);
+                        goto done;
+                }
+
                 if (!path->skip_locking) {
                         btrfs_assert_tree_locked(path->nodes[level]);
                         ret = btrfs_try_spin_lock(next);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 0ff16d3331da..4b0ea0b80c23 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -848,8 +848,6 @@ struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
 
         if (ret == 0)
                 set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
-        else
-                WARN_ON(1);
         return buf;
 
 }
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index e4966444811b..35af93355063 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -312,7 +312,7 @@ btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
 }
 
 /*
- * return the block group that contains teh given bytenr
+ * return the block group that contains the given bytenr
  */
 struct btrfs_block_group_cache *btrfs_lookup_block_group(
                                                  struct btrfs_fs_info *info,
@@ -2622,7 +2622,18 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
                                                        search_start);
                 if (block_group && block_group_bits(block_group, data)) {
                         down_read(&space_info->groups_sem);
-                        goto have_block_group;
+                        if (list_empty(&block_group->list) ||
+                            block_group->ro) {
+                                /*
+                                 * someone is removing this block group,
+                                 * we can't jump into the have_block_group
+                                 * target because our list pointers are not
+                                 * valid
+                                 */
+                                btrfs_put_block_group(block_group);
+                                up_read(&space_info->groups_sem);
+                        } else
+                                goto have_block_group;
                 } else if (block_group) {
                         btrfs_put_block_group(block_group);
                 }
@@ -2656,6 +2667,13 @@ have_block_group:
                          * people trying to start a new cluster
                          */
                         spin_lock(&last_ptr->refill_lock);
+                        if (last_ptr->block_group &&
+                            (last_ptr->block_group->ro ||
+                            !block_group_bits(last_ptr->block_group, data))) {
+                                offset = 0;
+                                goto refill_cluster;
+                        }
+
                         offset = btrfs_alloc_from_cluster(block_group, last_ptr,
                                                  num_bytes, search_start);
                         if (offset) {
@@ -2681,10 +2699,17 @@ have_block_group:
 
                                 last_ptr_loop = 1;
                                 search_start = block_group->key.objectid;
+                                /*
+                                 * we know this block group is properly
+                                 * in the list because
+                                 * btrfs_remove_block_group, drops the
+                                 * cluster before it removes the block
+                                 * group from the list
+                                 */
                                 goto have_block_group;
                         }
                         spin_unlock(&last_ptr->lock);
-
+refill_cluster:
                         /*
                          * this cluster didn't work out, free it and
                          * start over
@@ -5968,6 +5993,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 {
         struct btrfs_path *path;
         struct btrfs_block_group_cache *block_group;
+        struct btrfs_free_cluster *cluster;
         struct btrfs_key key;
         int ret;
 
@@ -5979,6 +6005,21 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 
         memcpy(&key, &block_group->key, sizeof(key));
 
+        /* make sure this block group isn't part of an allocation cluster */
+        cluster = &root->fs_info->data_alloc_cluster;
+        spin_lock(&cluster->refill_lock);
+        btrfs_return_cluster_to_free_space(block_group, cluster);
+        spin_unlock(&cluster->refill_lock);
+
+        /*
+         * make sure this block group isn't part of a metadata
+         * allocation cluster
+         */
+        cluster = &root->fs_info->meta_alloc_cluster;
+        spin_lock(&cluster->refill_lock);
+        btrfs_return_cluster_to_free_space(block_group, cluster);
+        spin_unlock(&cluster->refill_lock);
+
         path = btrfs_alloc_path();
         BUG_ON(!path);
 
@@ -5988,7 +6029,11 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
         spin_unlock(&root->fs_info->block_group_cache_lock);
         btrfs_remove_free_space_cache(block_group);
         down_write(&block_group->space_info->groups_sem);
-        list_del(&block_group->list);
+        /*
+         * we must use list_del_init so people can check to see if they
+         * are still on the list after taking the semaphore
+         */
+        list_del_init(&block_group->list);
         up_write(&block_group->space_info->groups_sem);
 
         spin_lock(&block_group->space_info->lock);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 90c23eb28829..1c8b0190d031 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3122,6 +3122,7 @@ static noinline void init_btrfs_i(struct inode *inode)
         bi->flags = 0;
         bi->index_cnt = (u64)-1;
         bi->last_unlink_trans = 0;
+        bi->ordered_data_close = 0;
         extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
         extent_io_tree_init(&BTRFS_I(inode)->io_tree,
                              inode->i_mapping, GFP_NOFS);
@@ -4295,7 +4296,6 @@ out:
         }
         if (err) {
                 free_extent_map(em);
-                WARN_ON(1);
                 return ERR_PTR(err);
         }
         return em;
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 5e94ea6e1cbe..2624b53ea783 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -437,10 +437,6 @@ out_unlock:
         return 0;
 }
 
-/*
- * Called inside transaction, so use GFP_NOFS
- */
-
 static int btrfs_ioctl_resize(struct btrfs_root *root, void __user *arg)
 {
         u64 new_size;
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 3536bdb2d7cb..2ff7cd2db25f 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -436,9 +436,9 @@ static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
         if (btrfs_test_opt(root, SSD))
                 seq_puts(seq, ",ssd");
         if (btrfs_test_opt(root, NOTREELOG))
-                seq_puts(seq, ",no-treelog");
+                seq_puts(seq, ",notreelog");
         if (btrfs_test_opt(root, FLUSHONCOMMIT))
-                seq_puts(seq, ",flush-on-commit");
+                seq_puts(seq, ",flushoncommit");
         if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
                 seq_puts(seq, ",noacl");
         return 0;
@@ -502,8 +502,7 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
 
         if (s->s_root) {
                 if ((flags ^ s->s_flags) & MS_RDONLY) {
-                        up_write(&s->s_umount);
-                        deactivate_super(s);
+                        deactivate_locked_super(s);
                         error = -EBUSY;
                         goto error_close_devices;
                 }
@@ -517,8 +516,7 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
                 error = btrfs_fill_super(s, fs_devices, data,
                                          flags & MS_SILENT ? 1 : 0);
                 if (error) {
-                        up_write(&s->s_umount);
-                        deactivate_super(s);
+                        deactivate_locked_super(s);
                         goto error_free_subvol_name;
                 }
 
@@ -535,15 +533,13 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
                 mutex_unlock(&s->s_root->d_inode->i_mutex);
 
                 if (IS_ERR(root)) {
-                        up_write(&s->s_umount);
-                        deactivate_super(s);
+                        deactivate_locked_super(s);
                         error = PTR_ERR(root);
                         goto error_free_subvol_name;
                 }
                 if (!root->d_inode) {
                         dput(root);
-                        up_write(&s->s_umount);
-                        deactivate_super(s);
+                        deactivate_locked_super(s);
                         error = -ENXIO;
                         goto error_free_subvol_name;
                 }
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 5f01dad4b696..a6d35b0054ca 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1440,6 +1440,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
         device->io_align = root->sectorsize;
         device->sector_size = root->sectorsize;
         device->total_bytes = i_size_read(bdev->bd_inode);
+        device->disk_total_bytes = device->total_bytes;
         device->dev_root = root->fs_info->dev_root;
         device->bdev = bdev;
         device->in_fs_metadata = 1;