1 files changed, 122 insertions, 62 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 1204c8ef6f32..cfb3cf711b34 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -113,7 +113,8 @@ static noinline int
 block_group_cache_done(struct btrfs_block_group_cache *cache)
 {
         smp_mb();
-        return cache->cached == BTRFS_CACHE_FINISHED;
+        return cache->cached == BTRFS_CACHE_FINISHED ||
+                cache->cached == BTRFS_CACHE_ERROR;
 }
 
 static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
@@ -389,7 +390,7 @@ static noinline void caching_thread(struct btrfs_work *work)
         u64 total_found = 0;
         u64 last = 0;
         u32 nritems;
-        int ret = 0;
+        int ret = -ENOMEM;
 
         caching_ctl = container_of(work, struct btrfs_caching_control, work);
         block_group = caching_ctl->block_group;
@@ -420,6 +421,7 @@ again:
         /* need to make sure the commit_root doesn't disappear */
         down_read(&fs_info->extent_commit_sem);
 
+next:
         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
         if (ret < 0)
                 goto err;
@@ -459,6 +461,16 @@ again:
                         continue;
                 }
 
+                if (key.objectid < last) {
+                        key.objectid = last;
+                        key.offset = 0;
+                        key.type = BTRFS_EXTENT_ITEM_KEY;
+
+                        caching_ctl->progress = last;
+                        btrfs_release_path(path);
+                        goto next;
+                }
+
                 if (key.objectid < block_group->key.objectid) {
                         path->slots[0]++;
                         continue;
@@ -506,6 +518,12 @@ err:
 
         mutex_unlock(&caching_ctl->mutex);
 out:
+        if (ret) {
+                spin_lock(&block_group->lock);
+                block_group->caching_ctl = NULL;
+                block_group->cached = BTRFS_CACHE_ERROR;
+                spin_unlock(&block_group->lock);
+        }
         wake_up(&caching_ctl->wait);
 
         put_caching_control(caching_ctl);
@@ -771,10 +789,23 @@ again:
                 goto out_free;
 
         if (ret > 0 && metadata && key.type == BTRFS_METADATA_ITEM_KEY) {
-                key.type = BTRFS_EXTENT_ITEM_KEY;
-                key.offset = root->leafsize;
-                btrfs_release_path(path);
-                goto again;
+                metadata = 0;
+                if (path->slots[0]) {
+                        path->slots[0]--;
+                        btrfs_item_key_to_cpu(path->nodes[0], &key,
+                                              path->slots[0]);
+                        if (key.objectid == bytenr &&
+                            key.type == BTRFS_EXTENT_ITEM_KEY &&
+                            key.offset == root->leafsize)
+                                ret = 0;
+                }
+                if (ret) {
+                        key.objectid = bytenr;
+                        key.type = BTRFS_EXTENT_ITEM_KEY;
+                        key.offset = root->leafsize;
+                        btrfs_release_path(path);
+                        goto again;
+                }
         }
 
         if (ret == 0) {
@@ -2011,6 +2042,8 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
         ins.type = BTRFS_EXTENT_ITEM_KEY;
 
         ref = btrfs_delayed_node_to_data_ref(node);
+        trace_run_delayed_data_ref(node, ref, node->action);
+
         if (node->type == BTRFS_SHARED_DATA_REF_KEY)
                 parent = ref->parent;
         else
@@ -2154,6 +2187,8 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
                                                  SKINNY_METADATA);
 
         ref = btrfs_delayed_node_to_tree_ref(node);
+        trace_run_delayed_tree_ref(node, ref, node->action);
+
         if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
                 parent = ref->parent;
         else
@@ -2212,6 +2247,8 @@ static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
                  */
                 BUG_ON(extent_op);
                 head = btrfs_delayed_node_to_head(node);
+                trace_run_delayed_ref_head(node, head, node->action);
+
                 if (insert_reserved) {
                         btrfs_pin_extent(root, node->bytenr,
                                          node->num_bytes, 1);
@@ -2403,6 +2440,8 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                         default:
                                 WARN_ON(1);
                         }
+                } else {
+                        list_del_init(&locked_ref->cluster);
                 }
                 spin_unlock(&delayed_refs->lock);
 
@@ -2425,7 +2464,6 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                  * list before we release it.
                  */
                 if (btrfs_delayed_ref_is_head(ref)) {
-                        list_del_init(&locked_ref->cluster);
                         btrfs_delayed_ref_unlock(locked_ref);
                         locked_ref = NULL;
                 }
@@ -3799,8 +3837,12 @@ again:
         if (force < space_info->force_alloc)
                 force = space_info->force_alloc;
         if (space_info->full) {
+                if (should_alloc_chunk(extent_root, space_info, force))
+                        ret = -ENOSPC;
+                else
+                        ret = 0;
                 spin_unlock(&space_info->lock);
-                return 0;
+                return ret;
         }
 
         if (!should_alloc_chunk(extent_root, space_info, force)) {
@@ -4320,6 +4362,9 @@ static struct btrfs_block_rsv *get_block_rsv(
         if (root == root->fs_info->csum_root && trans->adding_csums)
                 block_rsv = trans->block_rsv;
 
+        if (root == root->fs_info->uuid_root)
+                block_rsv = trans->block_rsv;
+
         if (!block_rsv)
                 block_rsv = root->block_rsv;
 
@@ -4729,10 +4774,12 @@ void btrfs_orphan_release_metadata(struct inode *inode)
 int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
                                      struct btrfs_block_rsv *rsv,
                                      int items,
-                                     u64 *qgroup_reserved)
+                                     u64 *qgroup_reserved,
+                                     bool use_global_rsv)
 {
         u64 num_bytes;
         int ret;
+        struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
 
         if (root->fs_info->quota_enabled) {
                 /* One for parent inode, two for dir entries */
@@ -4751,6 +4798,10 @@ int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
                                             BTRFS_BLOCK_GROUP_METADATA);
         ret = btrfs_block_rsv_add(root, rsv, num_bytes,
                                   BTRFS_RESERVE_FLUSH_ALL);
+
+        if (ret == -ENOSPC && use_global_rsv)
+                ret = btrfs_block_rsv_migrate(global_rsv, rsv, num_bytes);
+
         if (ret) {
                 if (*qgroup_reserved)
                         btrfs_qgroup_free(root, *qgroup_reserved);
@@ -5668,7 +5719,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
 
                         if (ret) {
                                 btrfs_err(info, "umm, got %d back from search, was looking for %llu",
-                                        ret, (unsigned long long)bytenr);
+                                        ret, bytenr);
                                 if (ret > 0)
                                         btrfs_print_leaf(extent_root,
                                                          path->nodes[0]);
@@ -5684,11 +5735,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                 WARN_ON(1);
                 btrfs_err(info,
                         "unable to find ref byte nr %llu parent %llu root %llu  owner %llu offset %llu",
-                        (unsigned long long)bytenr,
-                        (unsigned long long)parent,
-                        (unsigned long long)root_objectid,
-                        (unsigned long long)owner_objectid,
-                        (unsigned long long)owner_offset);
+                        bytenr, parent, root_objectid, owner_objectid,
+                        owner_offset);
         } else {
                 btrfs_abort_transaction(trans, extent_root, ret);
                 goto out;
@@ -5717,7 +5765,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                         -1, 1);
                 if (ret) {
                         btrfs_err(info, "umm, got %d back from search, was looking for %llu",
-                                ret, (unsigned long long)bytenr);
+                                ret, bytenr);
                         btrfs_print_leaf(extent_root, path->nodes[0]);
                 }
                 if (ret < 0) {
@@ -5999,8 +6047,11 @@ static u64 stripe_align(struct btrfs_root *root,
  * for our min num_bytes.  Another option is to have it go ahead
  * and look in the rbtree for a free extent of a given size, but this
  * is a good start.
+ *
+ * Callers of this must check if cache->cached == BTRFS_CACHE_ERROR before using
+ * any of the information in this block group.
  */
-static noinline int
+static noinline void
 wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
                                 u64 num_bytes)
 {
@@ -6008,28 +6059,29 @@ wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
 
         caching_ctl = get_caching_control(cache);
         if (!caching_ctl)
-                return 0;
+                return;
 
         wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
                    (cache->free_space_ctl->free_space >= num_bytes));
 
         put_caching_control(caching_ctl);
-        return 0;
 }
 
 static noinline int
 wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
 {
         struct btrfs_caching_control *caching_ctl;
+        int ret = 0;
 
         caching_ctl = get_caching_control(cache);
         if (!caching_ctl)
-                return 0;
+                return (cache->cached == BTRFS_CACHE_ERROR) ? -EIO : 0;
 
         wait_event(caching_ctl->wait, block_group_cache_done(cache));
-
+        if (cache->cached == BTRFS_CACHE_ERROR)
+                ret = -EIO;
         put_caching_control(caching_ctl);
-        return 0;
+        return ret;
 }
 
 int __get_raid_index(u64 flags)
@@ -6070,8 +6122,7 @@ enum btrfs_loop_type {
  * ins->offset == number of blocks
  * Any available blocks before search_start are skipped.
  */
-static noinline int find_free_extent(struct btrfs_trans_handle *trans,
-                                     struct btrfs_root *orig_root,
+static noinline int find_free_extent(struct btrfs_root *orig_root,
                                      u64 num_bytes, u64 empty_size,
                                      u64 hint_byte, struct btrfs_key *ins,
                                      u64 flags)
@@ -6212,6 +6263,8 @@ have_block_group:
                         ret = 0;
                 }
 
+                if (unlikely(block_group->cached == BTRFS_CACHE_ERROR))
+                        goto loop;
                 if (unlikely(block_group->ro))
                         goto loop;
 
@@ -6292,10 +6345,10 @@ refill_cluster:
                                               block_group->full_stripe_len);
 
                         /* allocate a cluster in this block group */
-                        ret = btrfs_find_space_cluster(trans, root,
-                                               block_group, last_ptr,
-                                               search_start, num_bytes,
-                                               aligned_cluster);
+                        ret = btrfs_find_space_cluster(root, block_group,
+                                                       last_ptr, search_start,
+                                                       num_bytes,
+                                                       aligned_cluster);
                         if (ret == 0) {
                                 /*
                                  * now pull our allocation out of this
@@ -6426,17 +6479,28 @@ loop:
                 index = 0;
                 loop++;
                 if (loop == LOOP_ALLOC_CHUNK) {
+                        struct btrfs_trans_handle *trans;
+
+                        trans = btrfs_join_transaction(root);
+                        if (IS_ERR(trans)) {
+                                ret = PTR_ERR(trans);
+                                goto out;
+                        }
+
                         ret = do_chunk_alloc(trans, root, flags,
                                              CHUNK_ALLOC_FORCE);
                         /*
                          * Do not bail out on ENOSPC since we
                          * can do more things.
                          */
-                        if (ret < 0 && ret != -ENOSPC) {
+                        if (ret < 0 && ret != -ENOSPC)
                                 btrfs_abort_transaction(trans,
                                                         root, ret);
+                        else
+                                ret = 0;
+                        btrfs_end_transaction(trans, root);
+                        if (ret)
                                 goto out;
-                        }
                 }
 
                 if (loop == LOOP_NO_EMPTY_SIZE) {
@@ -6463,19 +6527,15 @@ static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
 
         spin_lock(&info->lock);
         printk(KERN_INFO "space_info %llu has %llu free, is %sfull\n",
-               (unsigned long long)info->flags,
-               (unsigned long long)(info->total_bytes - info->bytes_used -
-                                    info->bytes_pinned - info->bytes_reserved -
-                                    info->bytes_readonly),
+               info->flags,
+               info->total_bytes - info->bytes_used - info->bytes_pinned -
+               info->bytes_reserved - info->bytes_readonly,
                (info->full) ? "" : "not ");
         printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
                "reserved=%llu, may_use=%llu, readonly=%llu\n",
-               (unsigned long long)info->total_bytes,
-               (unsigned long long)info->bytes_used,
-               (unsigned long long)info->bytes_pinned,
-               (unsigned long long)info->bytes_reserved,
-               (unsigned long long)info->bytes_may_use,
-               (unsigned long long)info->bytes_readonly);
+               info->total_bytes, info->bytes_used, info->bytes_pinned,
+               info->bytes_reserved, info->bytes_may_use,
+               info->bytes_readonly);
         spin_unlock(&info->lock);
 
         if (!dump_block_groups)
@@ -6486,12 +6546,9 @@ again:
         list_for_each_entry(cache, &info->block_groups[index], list) {
                 spin_lock(&cache->lock);
                 printk(KERN_INFO "block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s\n",
-                       (unsigned long long)cache->key.objectid,
-                       (unsigned long long)cache->key.offset,
-                       (unsigned long long)btrfs_block_group_used(&cache->item),
-                       (unsigned long long)cache->pinned,
-                       (unsigned long long)cache->reserved,
-                       cache->ro ? "[readonly]" : "");
+                       cache->key.objectid, cache->key.offset,
+                       btrfs_block_group_used(&cache->item), cache->pinned,
+                       cache->reserved, cache->ro ? "[readonly]" : "");
                 btrfs_dump_free_space(cache, bytes);
                 spin_unlock(&cache->lock);
         }
@@ -6500,8 +6557,7 @@ again:
         up_read(&info->groups_sem);
 }
 
-int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
-                         struct btrfs_root *root,
+int btrfs_reserve_extent(struct btrfs_root *root,
                          u64 num_bytes, u64 min_alloc_size,
                          u64 empty_size, u64 hint_byte,
                          struct btrfs_key *ins, int is_data)
@@ -6513,8 +6569,8 @@ int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
         flags = btrfs_get_alloc_profile(root, is_data);
 again:
         WARN_ON(num_bytes < root->sectorsize);
-        ret = find_free_extent(trans, root, num_bytes, empty_size,
-                               hint_byte, ins, flags);
+        ret = find_free_extent(root, num_bytes, empty_size, hint_byte, ins,
+                               flags);
 
         if (ret == -ENOSPC) {
                 if (!final_tried) {
@@ -6529,8 +6585,7 @@ again:
 
                         sinfo = __find_space_info(root->fs_info, flags);
                         btrfs_err(root->fs_info, "allocation failed flags %llu, wanted %llu",
-                                (unsigned long long)flags,
-                                (unsigned long long)num_bytes);
+                                flags, num_bytes);
                         if (sinfo)
                                 dump_space_info(sinfo, num_bytes, 1);
                 }
@@ -6550,7 +6605,7 @@ static int __btrfs_free_reserved_extent(struct btrfs_root *root,
         cache = btrfs_lookup_block_group(root->fs_info, start);
         if (!cache) {
                 btrfs_err(root->fs_info, "Unable to find block group for %llu",
-                        (unsigned long long)start);
+                        start);
                 return -ENOSPC;
         }
 
@@ -6646,8 +6701,7 @@ static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
         ret = update_block_group(root, ins->objectid, ins->offset, 1);
         if (ret) { /* -ENOENT, logic error */
                 btrfs_err(fs_info, "update block group failed for %llu %llu",
-                        (unsigned long long)ins->objectid,
-                        (unsigned long long)ins->offset);
+                        ins->objectid, ins->offset);
                 BUG();
         }
         return ret;
@@ -6719,8 +6773,7 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
         ret = update_block_group(root, ins->objectid, root->leafsize, 1);
         if (ret) { /* -ENOENT, logic error */
                 btrfs_err(fs_info, "update block group failed for %llu %llu",
-                        (unsigned long long)ins->objectid,
-                        (unsigned long long)ins->offset);
+                        ins->objectid, ins->offset);
                 BUG();
         }
         return ret;
@@ -6902,7 +6955,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
         if (IS_ERR(block_rsv))
                 return ERR_CAST(block_rsv);
 
-        ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
+        ret = btrfs_reserve_extent(root, blocksize, blocksize,
                                    empty_size, hint, &ins, 0);
         if (ret) {
                 unuse_block_rsv(root->fs_info, block_rsv, blocksize);
@@ -7173,6 +7226,8 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
                 if (!next)
                         return -ENOMEM;
+                btrfs_set_buffer_lockdep_class(root->root_key.objectid, next,
+                                               level - 1);
                 reada = 1;
         }
         btrfs_tree_lock(next);
@@ -7658,7 +7713,7 @@ out:
          * don't have it in the radix (like when we recover after a power fail
          * or unmount) so we don't leak memory.
          */
-        if (root_dropped == false)
+        if (!for_reloc && root_dropped == false)
                 btrfs_add_dead_root(root);
         if (err)
                 btrfs_std_error(root->fs_info, err);
@@ -8192,7 +8247,8 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
                  * We haven't cached this block group, which means we could
                  * possibly have excluded extents on this block group.
                  */
-                if (block_group->cached == BTRFS_CACHE_NO)
+                if (block_group->cached == BTRFS_CACHE_NO ||
+                    block_group->cached == BTRFS_CACHE_ERROR)
                         free_excluded_extents(info->extent_root, block_group);
 
                 btrfs_remove_free_space_cache(block_group);
@@ -8409,9 +8465,13 @@ int btrfs_read_block_groups(struct btrfs_root *root)
                  * avoid allocating from un-mirrored block group if there are
                  * mirrored block groups.
                  */
-                list_for_each_entry(cache, &space_info->block_groups[3], list)
+                list_for_each_entry(cache,
+                                &space_info->block_groups[BTRFS_RAID_RAID0],
+                                list)
                         set_block_group_ro(cache, 1);
-                list_for_each_entry(cache, &space_info->block_groups[4], list)
+                list_for_each_entry(cache,
+                                &space_info->block_groups[BTRFS_RAID_SINGLE],
+                                list)
                         set_block_group_ro(cache, 1);
         }