1 files changed, 41 insertions, 30 deletions

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5699bbc23feb..4b02591b0301 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -50,6 +50,7 @@
 #include "raid56.h"
 #include "sysfs.h"
 #include "qgroup.h"
+#include "compression.h"
 
 #ifdef CONFIG_X86
 #include <asm/cpufeature.h>
@@ -110,8 +111,7 @@ int __init btrfs_end_io_wq_init(void)
 
 void btrfs_end_io_wq_exit(void)
 {
-        if (btrfs_end_io_wq_cache)
-                kmem_cache_destroy(btrfs_end_io_wq_cache);
+        kmem_cache_destroy(btrfs_end_io_wq_cache);
 }
 
 /*
@@ -612,6 +612,7 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
         int found_level;
         struct extent_buffer *eb;
         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
+        struct btrfs_fs_info *fs_info = root->fs_info;
         int ret = 0;
         int reads_done;
 
@@ -637,21 +638,21 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
 
         found_start = btrfs_header_bytenr(eb);
         if (found_start != eb->start) {
-                btrfs_err_rl(eb->fs_info, "bad tree block start %llu %llu",
-                               found_start, eb->start);
+                btrfs_err_rl(fs_info, "bad tree block start %llu %llu",
+                             found_start, eb->start);
                 ret = -EIO;
                 goto err;
         }
-        if (check_tree_block_fsid(root->fs_info, eb)) {
-                btrfs_err_rl(eb->fs_info, "bad fsid on block %llu",
-                               eb->start);
+        if (check_tree_block_fsid(fs_info, eb)) {
+                btrfs_err_rl(fs_info, "bad fsid on block %llu",
+                             eb->start);
                 ret = -EIO;
                 goto err;
         }
         found_level = btrfs_header_level(eb);
         if (found_level >= BTRFS_MAX_LEVEL) {
-                btrfs_err(root->fs_info, "bad tree block level %d",
-                           (int)btrfs_header_level(eb));
+                btrfs_err(fs_info, "bad tree block level %d",
+                          (int)btrfs_header_level(eb));
                 ret = -EIO;
                 goto err;
         }
@@ -659,7 +660,7 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
         btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
                                        eb, found_level);
 
-        ret = csum_tree_block(root->fs_info, eb, 1);
+        ret = csum_tree_block(fs_info, eb, 1);
         if (ret) {
                 ret = -EIO;
                 goto err;
@@ -680,7 +681,7 @@ static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
 err:
         if (reads_done &&
             test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
-                btree_readahead_hook(root, eb, eb->start, ret);
+                btree_readahead_hook(fs_info, eb, eb->start, ret);
 
         if (ret) {
                 /*
@@ -699,14 +700,13 @@ out:
 static int btree_io_failed_hook(struct page *page, int failed_mirror)
 {
         struct extent_buffer *eb;
-        struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 
         eb = (struct extent_buffer *)page->private;
         set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
         eb->read_mirror = failed_mirror;
         atomic_dec(&eb->io_pages);
         if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
-                btree_readahead_hook(root, eb, eb->start, -EIO);
+                btree_readahead_hook(eb->fs_info, eb, eb->start, -EIO);
         return -EIO;    /* we fixed nothing */
 }
 
@@ -816,7 +816,7 @@ static void run_one_async_done(struct btrfs_work *work)
             waitqueue_active(&fs_info->async_submit_wait))
                 wake_up(&fs_info->async_submit_wait);
 
-        /* If an error occured we just want to clean up the bio and move on */
+        /* If an error occurred we just want to clean up the bio and move on */
         if (async->error) {
                 async->bio->bi_error = async->error;
                 bio_endio(async->bio);
@@ -1296,9 +1296,10 @@ static void __setup_root(u32 nodesize, u32 sectorsize, u32 stripesize,
         spin_lock_init(&root->root_item_lock);
 }
 
-static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
+static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
+                gfp_t flags)
 {
-        struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
+        struct btrfs_root *root = kzalloc(sizeof(*root), flags);
         if (root)
                 root->fs_info = fs_info;
         return root;
@@ -1310,7 +1311,7 @@ struct btrfs_root *btrfs_alloc_dummy_root(void)
 {
         struct btrfs_root *root;
 
-        root = btrfs_alloc_root(NULL);
+        root = btrfs_alloc_root(NULL, GFP_KERNEL);
         if (!root)
                 return ERR_PTR(-ENOMEM);
         __setup_root(4096, 4096, 4096, root, NULL, 1);
@@ -1332,7 +1333,7 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
         int ret = 0;
         uuid_le uuid;
 
-        root = btrfs_alloc_root(fs_info);
+        root = btrfs_alloc_root(fs_info, GFP_KERNEL);
         if (!root)
                 return ERR_PTR(-ENOMEM);
 
@@ -1408,7 +1409,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
         struct btrfs_root *tree_root = fs_info->tree_root;
         struct extent_buffer *leaf;
 
-        root = btrfs_alloc_root(fs_info);
+        root = btrfs_alloc_root(fs_info, GFP_NOFS);
         if (!root)
                 return ERR_PTR(-ENOMEM);
 
@@ -1506,7 +1507,7 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
         if (!path)
                 return ERR_PTR(-ENOMEM);
 
-        root = btrfs_alloc_root(fs_info);
+        root = btrfs_alloc_root(fs_info, GFP_NOFS);
         if (!root) {
                 ret = -ENOMEM;
                 goto alloc_fail;
@@ -2272,9 +2273,11 @@ static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
         fs_info->dev_replace.lock_owner = 0;
         atomic_set(&fs_info->dev_replace.nesting_level, 0);
         mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
-        mutex_init(&fs_info->dev_replace.lock_management_lock);
-        mutex_init(&fs_info->dev_replace.lock);
+        rwlock_init(&fs_info->dev_replace.lock);
+        atomic_set(&fs_info->dev_replace.read_locks, 0);
+        atomic_set(&fs_info->dev_replace.blocking_readers, 0);
         init_waitqueue_head(&fs_info->replace_wait);
+        init_waitqueue_head(&fs_info->dev_replace.read_lock_wq);
 }
 
 static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
@@ -2385,7 +2388,7 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
                 return -EIO;
         }
 
-        log_tree_root = btrfs_alloc_root(fs_info);
+        log_tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
         if (!log_tree_root)
                 return -ENOMEM;
 
@@ -2510,8 +2513,8 @@ int open_ctree(struct super_block *sb,
         int backup_index = 0;
         int max_active;
 
-        tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
-        chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
+        tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
+        chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
         if (!tree_root || !chunk_root) {
                 err = -ENOMEM;
                 goto fail;
@@ -2603,6 +2606,7 @@ int open_ctree(struct super_block *sb,
         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);
         atomic64_set(&fs_info->tree_mod_seq, 0);
         fs_info->sb = sb;
         fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
@@ -2622,7 +2626,7 @@ int open_ctree(struct super_block *sb,
         INIT_LIST_HEAD(&fs_info->ordered_roots);
         spin_lock_init(&fs_info->ordered_root_lock);
         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
-                                        GFP_NOFS);
+                                        GFP_KERNEL);
         if (!fs_info->delayed_root) {
                 err = -ENOMEM;
                 goto fail_iput;
@@ -2750,7 +2754,7 @@ int open_ctree(struct super_block *sb,
          */
         fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
 
-        ret = btrfs_parse_options(tree_root, options);
+        ret = btrfs_parse_options(tree_root, options, sb->s_flags);
         if (ret) {
                 err = ret;
                 goto fail_alloc;
@@ -3029,8 +3033,9 @@ retry_root_backup:
         if (ret)
                 goto fail_trans_kthread;
 
-        /* do not make disk changes in broken FS */
-        if (btrfs_super_log_root(disk_super) != 0) {
+        /* do not make disk changes in broken FS or nologreplay is given */
+        if (btrfs_super_log_root(disk_super) != 0 &&
+            !btrfs_test_opt(tree_root, NOLOGREPLAY)) {
                 ret = btrfs_replay_log(fs_info, fs_devices);
                 if (ret) {
                         err = ret;
@@ -3146,6 +3151,12 @@ retry_root_backup:
 
         fs_info->open = 1;
 
+        /*
+         * backuproot only affect mount behavior, and if open_ctree succeeded,
+         * no need to keep the flag
+         */
+        btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
+
         return 0;
 
 fail_qgroup:
@@ -3200,7 +3211,7 @@ fail:
         return err;
 
 recovery_tree_root:
-        if (!btrfs_test_opt(tree_root, RECOVERY))
+        if (!btrfs_test_opt(tree_root, USEBACKUPROOT))
                 goto fail_tree_roots;
 
         free_root_pointers(fs_info, 0);