1 files changed, 41 insertions, 192 deletions

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index dfdab849037b..10a2a579cc7f 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -50,6 +50,8 @@
 #include "sysfs.h"
 #include "qgroup.h"
 #include "compression.h"
+#include "tree-checker.h"
+#include "ref-verify.h"
 
 #ifdef CONFIG_X86
 #include <asm/cpufeature.h>
@@ -543,146 +545,6 @@ static int check_tree_block_fsid(struct btrfs_fs_info *fs_info,
         return ret;
 }
 
-#define CORRUPT(reason, eb, root, slot)                                 \
-        btrfs_crit(root->fs_info,                                       \
-                   "corrupt %s, %s: block=%llu, root=%llu, slot=%d",    \
-                   btrfs_header_level(eb) == 0 ? "leaf" : "node",       \
-                   reason, btrfs_header_bytenr(eb), root->objectid, slot)
-
-static noinline int check_leaf(struct btrfs_root *root,
-                               struct extent_buffer *leaf)
-{
-        struct btrfs_fs_info *fs_info = root->fs_info;
-        struct btrfs_key key;
-        struct btrfs_key leaf_key;
-        u32 nritems = btrfs_header_nritems(leaf);
-        int slot;
-
-        /*
-         * Extent buffers from a relocation tree have a owner field that
-         * corresponds to the subvolume tree they are based on. So just from an
-         * extent buffer alone we can not find out what is the id of the
-         * corresponding subvolume tree, so we can not figure out if the extent
-         * buffer corresponds to the root of the relocation tree or not. So skip
-         * this check for relocation trees.
-         */
-        if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) {
-                struct btrfs_root *check_root;
-
-                key.objectid = btrfs_header_owner(leaf);
-                key.type = BTRFS_ROOT_ITEM_KEY;
-                key.offset = (u64)-1;
-
-                check_root = btrfs_get_fs_root(fs_info, &key, false);
-                /*
-                 * The only reason we also check NULL here is that during
-                 * open_ctree() some roots has not yet been set up.
-                 */
-                if (!IS_ERR_OR_NULL(check_root)) {
-                        struct extent_buffer *eb;
-
-                        eb = btrfs_root_node(check_root);
-                        /* if leaf is the root, then it's fine */
-                        if (leaf != eb) {
-                                CORRUPT("non-root leaf's nritems is 0",
-                                        leaf, check_root, 0);
-                                free_extent_buffer(eb);
-                                return -EIO;
-                        }
-                        free_extent_buffer(eb);
-                }
-                return 0;
-        }
-
-        if (nritems == 0)
-                return 0;
-
-        /* Check the 0 item */
-        if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
-            BTRFS_LEAF_DATA_SIZE(fs_info)) {
-                CORRUPT("invalid item offset size pair", leaf, root, 0);
-                return -EIO;
-        }
-
-        /*
-         * Check to make sure each items keys are in the correct order and their
-         * offsets make sense.  We only have to loop through nritems-1 because
-         * we check the current slot against the next slot, which verifies the
-         * next slot's offset+size makes sense and that the current's slot
-         * offset is correct.
-         */
-        for (slot = 0; slot < nritems - 1; slot++) {
-                btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
-                btrfs_item_key_to_cpu(leaf, &key, slot + 1);
-
-                /* Make sure the keys are in the right order */
-                if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
-                        CORRUPT("bad key order", leaf, root, slot);
-                        return -EIO;
-                }
-
-                /*
-                 * Make sure the offset and ends are right, remember that the
-                 * item data starts at the end of the leaf and grows towards the
-                 * front.
-                 */
-                if (btrfs_item_offset_nr(leaf, slot) !=
-                        btrfs_item_end_nr(leaf, slot + 1)) {
-                        CORRUPT("slot offset bad", leaf, root, slot);
-                        return -EIO;
-                }
-
-                /*
-                 * Check to make sure that we don't point outside of the leaf,
-                 * just in case all the items are consistent to each other, but
-                 * all point outside of the leaf.
-                 */
-                if (btrfs_item_end_nr(leaf, slot) >
-                    BTRFS_LEAF_DATA_SIZE(fs_info)) {
-                        CORRUPT("slot end outside of leaf", leaf, root, slot);
-                        return -EIO;
-                }
-        }
-
-        return 0;
-}
-
-static int check_node(struct btrfs_root *root, struct extent_buffer *node)
-{
-        unsigned long nr = btrfs_header_nritems(node);
-        struct btrfs_key key, next_key;
-        int slot;
-        u64 bytenr;
-        int ret = 0;
-
-        if (nr == 0 || nr > BTRFS_NODEPTRS_PER_BLOCK(root->fs_info)) {
-                btrfs_crit(root->fs_info,
-                           "corrupt node: block %llu root %llu nritems %lu",
-                           node->start, root->objectid, nr);
-                return -EIO;
-        }
-
-        for (slot = 0; slot < nr - 1; slot++) {
-                bytenr = btrfs_node_blockptr(node, slot);
-                btrfs_node_key_to_cpu(node, &key, slot);
-                btrfs_node_key_to_cpu(node, &next_key, slot + 1);
-
-                if (!bytenr) {
-                        CORRUPT("invalid item slot", node, root, slot);
-                        ret = -EIO;
-                        goto out;
-                }
-
-                if (btrfs_comp_cpu_keys(&key, &next_key) >= 0) {
-                        CORRUPT("bad key order", node, root, slot);
-                        ret = -EIO;
-                        goto out;
-                }
-        }
-out:
-        return ret;
-}
-
 static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
                                       u64 phy_offset, struct page *page,
                                       u64 start, u64 end, int mirror)
@@ -748,12 +610,12 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
          * that we don't try and read the other copies of this block, just
          * return -EIO.
          */
-        if (found_level == 0 && check_leaf(root, eb)) {
+        if (found_level == 0 && btrfs_check_leaf_full(root, eb)) {
                 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
                 ret = -EIO;
         }
 
-        if (found_level > 0 && check_node(root, eb))
+        if (found_level > 0 && btrfs_check_node(root, eb))
                 ret = -EIO;
 
         if (!ret)
@@ -879,22 +741,9 @@ static void run_one_async_start(struct btrfs_work *work)
 
 static void run_one_async_done(struct btrfs_work *work)
 {
-        struct btrfs_fs_info *fs_info;
         struct async_submit_bio *async;
-        int limit;
 
         async = container_of(work, struct  async_submit_bio, work);
-        fs_info = async->fs_info;
-
-        limit = btrfs_async_submit_limit(fs_info);
-        limit = limit * 2 / 3;
-
-        /*
-         * atomic_dec_return implies a barrier for waitqueue_active
-         */
-        if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
-            waitqueue_active(&fs_info->async_submit_wait))
-                wake_up(&fs_info->async_submit_wait);
 
         /* If an error occurred we just want to clean up the bio and move on */
         if (async->status) {
@@ -942,19 +791,10 @@ blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
 
         async->status = 0;
 
-        atomic_inc(&fs_info->nr_async_submits);
-
         if (op_is_sync(bio->bi_opf))
                 btrfs_set_work_high_priority(&async->work);
 
         btrfs_queue_work(fs_info->workers, &async->work);
-
-        while (atomic_read(&fs_info->async_submit_draining) &&
-              atomic_read(&fs_info->nr_async_submits)) {
-                wait_event(fs_info->async_submit_wait,
-                           (atomic_read(&fs_info->nr_async_submits) == 0));
-        }
-
         return 0;
 }
 
@@ -1005,9 +845,9 @@ static blk_status_t __btree_submit_bio_done(void *private_data, struct bio *bio,
         return ret;
 }
 
-static int check_async_write(unsigned long bio_flags)
+static int check_async_write(struct btrfs_inode *bi)
 {
-        if (bio_flags & EXTENT_BIO_TREE_LOG)
+        if (atomic_read(&bi->sync_writers))
                 return 0;
 #ifdef CONFIG_X86
         if (static_cpu_has(X86_FEATURE_XMM4_2))
@@ -1022,7 +862,7 @@ static blk_status_t btree_submit_bio_hook(void *private_data, struct bio *bio,
 {
         struct inode *inode = private_data;
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-        int async = check_async_write(bio_flags);
+        int async = check_async_write(BTRFS_I(inode));
         blk_status_t ret;
 
         if (bio_op(bio) != REQ_OP_WRITE) {
@@ -2607,14 +2447,6 @@ int open_ctree(struct super_block *sb,
                 goto fail_delalloc_bytes;
         }
 
-        fs_info->btree_inode = new_inode(sb);
-        if (!fs_info->btree_inode) {
-                err = -ENOMEM;
-                goto fail_bio_counter;
-        }
-
-        mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
-
         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
         INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
         INIT_LIST_HEAD(&fs_info->trans_list);
@@ -2647,17 +2479,12 @@ int open_ctree(struct super_block *sb,
         btrfs_mapping_init(&fs_info->mapping_tree);
         btrfs_init_block_rsv(&fs_info->global_block_rsv,
                              BTRFS_BLOCK_RSV_GLOBAL);
-        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
-                             BTRFS_BLOCK_RSV_DELALLOC);
         btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
         btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
         btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
         btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
                              BTRFS_BLOCK_RSV_DELOPS);
-        atomic_set(&fs_info->nr_async_submits, 0);
         atomic_set(&fs_info->async_delalloc_pages, 0);
-        atomic_set(&fs_info->async_submit_draining, 0);
-        atomic_set(&fs_info->nr_async_bios, 0);
         atomic_set(&fs_info->defrag_running, 0);
         atomic_set(&fs_info->qgroup_op_seq, 0);
         atomic_set(&fs_info->reada_works_cnt, 0);
@@ -2673,12 +2500,21 @@ int open_ctree(struct super_block *sb,
         /* readahead state */
         INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
         spin_lock_init(&fs_info->reada_lock);
+        btrfs_init_ref_verify(fs_info);
 
         fs_info->thread_pool_size = min_t(unsigned long,
                                           num_online_cpus() + 2, 8);
 
         INIT_LIST_HEAD(&fs_info->ordered_roots);
         spin_lock_init(&fs_info->ordered_root_lock);
+
+        fs_info->btree_inode = new_inode(sb);
+        if (!fs_info->btree_inode) {
+                err = -ENOMEM;
+                goto fail_bio_counter;
+        }
+        mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
+
         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
                                         GFP_KERNEL);
         if (!fs_info->delayed_root) {
@@ -2895,12 +2731,13 @@ int open_ctree(struct super_block *sb,
         sb->s_bdi->congested_fn = btrfs_congested_fn;
         sb->s_bdi->congested_data = fs_info;
         sb->s_bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
-        sb->s_bdi->ra_pages = VM_MAX_READAHEAD * 1024 / PAGE_SIZE;
+        sb->s_bdi->ra_pages = VM_MAX_READAHEAD * SZ_1K / PAGE_SIZE;
         sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
         sb->s_bdi->ra_pages = max(sb->s_bdi->ra_pages, SZ_4M / PAGE_SIZE);
 
         sb->s_blocksize = sectorsize;
         sb->s_blocksize_bits = blksize_bits(sectorsize);
+        memcpy(&sb->s_uuid, fs_info->fsid, BTRFS_FSID_SIZE);
 
         mutex_lock(&fs_info->chunk_mutex);
         ret = btrfs_read_sys_array(fs_info);
@@ -3083,6 +2920,9 @@ retry_root_backup:
         if (ret)
                 goto fail_trans_kthread;
 
+        if (btrfs_build_ref_tree(fs_info))
+                btrfs_err(fs_info, "couldn't build ref tree");
+
         /* do not make disk changes in broken FS or nologreplay is given */
         if (btrfs_super_log_root(disk_super) != 0 &&
             !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
@@ -3948,6 +3788,7 @@ void close_ctree(struct btrfs_fs_info *fs_info)
         cleanup_srcu_struct(&fs_info->subvol_srcu);
 
         btrfs_free_stripe_hash_table(fs_info);
+        btrfs_free_ref_cache(fs_info);
 
         __btrfs_free_block_rsv(root->orphan_block_rsv);
         root->orphan_block_rsv = NULL;
@@ -4007,7 +3848,13 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
                                          buf->len,
                                          fs_info->dirty_metadata_batch);
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
-        if (btrfs_header_level(buf) == 0 && check_leaf(root, buf)) {
+        /*
+         * Since btrfs_mark_buffer_dirty() can be called with item pointer set
+         * but item data not updated.
+         * So here we should only check item pointers, not item data.
+         */
+        if (btrfs_header_level(buf) == 0 &&
+            btrfs_check_leaf_relaxed(root, buf)) {
                 btrfs_print_leaf(buf);
                 ASSERT(0);
         }
@@ -4272,26 +4119,28 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
 
         while ((node = rb_first(&delayed_refs->href_root)) != NULL) {
                 struct btrfs_delayed_ref_head *head;
-                struct btrfs_delayed_ref_node *tmp;
+                struct rb_node *n;
                 bool pin_bytes = false;
 
                 head = rb_entry(node, struct btrfs_delayed_ref_head,
                                 href_node);
                 if (!mutex_trylock(&head->mutex)) {
-                        refcount_inc(&head->node.refs);
+                        refcount_inc(&head->refs);
                         spin_unlock(&delayed_refs->lock);
 
                         mutex_lock(&head->mutex);
                         mutex_unlock(&head->mutex);
-                        btrfs_put_delayed_ref(&head->node);
+                        btrfs_put_delayed_ref_head(head);
                         spin_lock(&delayed_refs->lock);
                         continue;
                 }
                 spin_lock(&head->lock);
-                list_for_each_entry_safe_reverse(ref, tmp, &head->ref_list,
-                                                 list) {
+                while ((n = rb_first(&head->ref_tree)) != NULL) {
+                        ref = rb_entry(n, struct btrfs_delayed_ref_node,
+                                       ref_node);
                         ref->in_tree = 0;
-                        list_del(&ref->list);
+                        rb_erase(&ref->ref_node, &head->ref_tree);
+                        RB_CLEAR_NODE(&ref->ref_node);
                         if (!list_empty(&ref->add_list))
                                 list_del(&ref->add_list);
                         atomic_dec(&delayed_refs->num_entries);
@@ -4304,16 +4153,16 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
                 if (head->processing == 0)
                         delayed_refs->num_heads_ready--;
                 atomic_dec(&delayed_refs->num_entries);
-                head->node.in_tree = 0;
                 rb_erase(&head->href_node, &delayed_refs->href_root);
+                RB_CLEAR_NODE(&head->href_node);
                 spin_unlock(&head->lock);
                 spin_unlock(&delayed_refs->lock);
                 mutex_unlock(&head->mutex);
 
                 if (pin_bytes)
-                        btrfs_pin_extent(fs_info, head->node.bytenr,
-                                         head->node.num_bytes, 1);
-                btrfs_put_delayed_ref(&head->node);
+                        btrfs_pin_extent(fs_info, head->bytenr,
+                                         head->num_bytes, 1);
+                btrfs_put_delayed_ref_head(head);
                 cond_resched();
                 spin_lock(&delayed_refs->lock);
         }