Btrfs: add a flags field to btrfs_fs_info

We have a lot of random ints in btrfs_fs_info that can be put into flags.  This
is mostly equivalent with the exception of how we deal with quota going on or
off, now instead we set a flag when we are turning it on or off and deal with
that appropriately, rather than just having a pending state that the current
quota_enabled gets set to.  Thanks,

Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 4919aedb5fc18a81faebb30abc01463cc4f2c8c1..1a8fa46ff87eb6eccae9be16d5e600ff8de0ef8b 100644 (file)
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -44,17 +44,6 @@
 #define BTRFS_INODE_IN_DELALLOC_LIST           9
 #define BTRFS_INODE_READDIO_NEED_LOCK          10
 #define BTRFS_INODE_HAS_PROPS                  11
-/*
- * The following 3 bits are meant only for the btree inode.
- * When any of them is set, it means an error happened while writing an
- * extent buffer belonging to:
- * 1) a non-log btree
- * 2) a log btree and first log sub-transaction
- * 3) a log btree and second log sub-transaction
- */
-#define BTRFS_INODE_BTREE_ERR                  12
-#define BTRFS_INODE_BTREE_LOG1_ERR             13
-#define BTRFS_INODE_BTREE_LOG2_ERR             14
 
 /* in memory btrfs inode */
 struct btrfs_inode {

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 176a61967a8ad1606013655dcdb3a1edf8938d56..2b7041ed4cb87cc0293f7a44c2c07467da034a73 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -677,9 +677,25 @@ struct btrfs_device;
 struct btrfs_fs_devices;
 struct btrfs_balance_control;
 struct btrfs_delayed_root;
+
+#define BTRFS_FS_BARRIER                       1
+#define BTRFS_FS_CLOSING_START                 2
+#define BTRFS_FS_CLOSING_DONE                  3
+#define BTRFS_FS_LOG_RECOVERING                        4
+#define BTRFS_FS_OPEN                          5
+#define BTRFS_FS_QUOTA_ENABLED                 6
+#define BTRFS_FS_QUOTA_ENABLING                        7
+#define BTRFS_FS_QUOTA_DISABLING               8
+#define BTRFS_FS_UPDATE_UUID_TREE_GEN          9
+#define BTRFS_FS_CREATING_FREE_SPACE_TREE      10
+#define BTRFS_FS_BTREE_ERR                     11
+#define BTRFS_FS_LOG1_ERR                      12
+#define BTRFS_FS_LOG2_ERR                      13
+
 struct btrfs_fs_info {
        u8 fsid[BTRFS_FSID_SIZE];
        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
+       unsigned long flags;
        struct btrfs_root *extent_root;
        struct btrfs_root *tree_root;
        struct btrfs_root *chunk_root;
@@ -908,10 +924,6 @@ struct btrfs_fs_info {
        int thread_pool_size;
 
        struct kobject *space_info_kobj;
-       int do_barriers;
-       int closing;
-       int log_root_recovering;
-       int open;
 
        u64 total_pinned;
 
@@ -988,17 +1000,6 @@ struct btrfs_fs_info {
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
        u32 check_integrity_print_mask;
 #endif
-       /*
-        * quota information
-        */
-       unsigned int quota_enabled:1;
-
-       /*
-        * quota_enabled only changes state after a commit. This holds the
-        * next state.
-        */
-       unsigned int pending_quota_state:1;
-
        /* is qgroup tracking in a consistent state? */
        u64 qgroup_flags;
 
@@ -1062,7 +1063,6 @@ struct btrfs_fs_info {
        wait_queue_head_t replace_wait;
 
        struct semaphore uuid_tree_rescan_sem;
-       unsigned int update_uuid_tree_gen:1;
 
        /* Used to reclaim the metadata space in the background. */
        struct work_struct async_reclaim_work;
@@ -1081,7 +1081,6 @@ struct btrfs_fs_info {
         */
        struct list_head pinned_chunks;
 
-       int creating_free_space_tree;
        /* Used to record internally whether fs has been frozen */
        int fs_frozen;
 };
@@ -2868,10 +2867,14 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
 static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
 {
        /*
-        * Get synced with close_ctree()
+        * Do it this way so we only ever do one test_bit in the normal case.
         */
-       smp_mb();
-       return fs_info->closing;
+       if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
+               if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
+                       return 2;
+               return 1;
+       }
+       return 0;
 }
 
 /*

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 3eeb9cd8cfa57edc81bdeba91b1d37a3011d7bf9..982a168af2cea776fa99a54090b6b1d69bb0b01b 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1874,7 +1874,8 @@ int btrfs_delayed_delete_inode_ref(struct inode *inode)
         * leads to enospc problems.  This means we also can't do
         * delayed inode refs
         */
-       if (BTRFS_I(inode)->root->fs_info->log_root_recovering)
+       if (test_bit(BTRFS_FS_LOG_RECOVERING,
+                    &BTRFS_I(inode)->root->fs_info->flags))
                return -EAGAIN;
 
        delayed_node = btrfs_get_or_create_delayed_node(inode);

diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index ac02e041464bc87876cfd206a79f7e07de9846b7..a5d81f361d0b62bca0fd8a29deac68cfa53c2d98 100644 (file)
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -770,7 +770,8 @@ int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
        if (!head_ref)
                goto free_ref;
 
-       if (fs_info->quota_enabled && is_fstree(ref_root)) {
+       if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
+           is_fstree(ref_root)) {
                record = kmalloc(sizeof(*record), GFP_NOFS);
                if (!record)
                        goto free_head_ref;
@@ -828,7 +829,8 @@ int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info,
                return -ENOMEM;
        }
 
-       if (fs_info->quota_enabled && is_fstree(ref_root)) {
+       if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
+           is_fstree(ref_root)) {
                record = kmalloc(sizeof(*record), GFP_NOFS);
                if (!record) {
                        kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 754de24f17afe0ba2bc373bce72c4b72fdc3d71c..f92bfa8ffd4198ee616fac154930f17fc34d9464 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1839,7 +1839,7 @@ static int cleaner_kthread(void *arg)
                 * Do not do anything if we might cause open_ctree() to block
                 * before we have finished mounting the filesystem.
                 */
-               if (!root->fs_info->open)
+               if (!test_bit(BTRFS_FS_OPEN, &root->fs_info->flags))
                        goto sleep;
 
                if (!mutex_trylock(&root->fs_info->cleaner_mutex))
@@ -2332,8 +2332,6 @@ static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
        fs_info->qgroup_op_tree = RB_ROOT;
        INIT_LIST_HEAD(&fs_info->dirty_qgroups);
        fs_info->qgroup_seq = 1;
-       fs_info->quota_enabled = 0;
-       fs_info->pending_quota_state = 0;
        fs_info->qgroup_ulist = NULL;
        fs_info->qgroup_rescan_running = false;
        mutex_init(&fs_info->qgroup_rescan_lock);
@@ -2518,8 +2516,7 @@ static int btrfs_read_roots(struct btrfs_fs_info *fs_info,
        root = btrfs_read_tree_root(tree_root, &location);
        if (!IS_ERR(root)) {
                set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
-               fs_info->quota_enabled = 1;
-               fs_info->pending_quota_state = 1;
+               set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
                fs_info->quota_root = root;
        }
 
@@ -2710,8 +2707,7 @@ int open_ctree(struct super_block *sb,
        extent_io_tree_init(&fs_info->freed_extents[1],
                             fs_info->btree_inode->i_mapping);
        fs_info->pinned_extents = &fs_info->freed_extents[0];
-       fs_info->do_barriers = 1;
-
+       set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
 
        mutex_init(&fs_info->ordered_operations_mutex);
        mutex_init(&fs_info->tree_log_mutex);
@@ -3199,10 +3195,9 @@ retry_root_backup:
                        return ret;
                }
        } else {
-               fs_info->update_uuid_tree_gen = 1;
+               set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
        }
-
-       fs_info->open = 1;
+       set_bit(BTRFS_FS_OPEN, &fs_info->flags);
 
        /*
         * backuproot only affect mount behavior, and if open_ctree succeeded,
@@ -3893,8 +3888,7 @@ void close_ctree(struct btrfs_root *root)
        struct btrfs_fs_info *fs_info = root->fs_info;
        int ret;
 
-       fs_info->closing = 1;
-       smp_mb();
+       set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
 
        /* wait for the qgroup rescan worker to stop */
        btrfs_qgroup_wait_for_completion(fs_info, false);
@@ -3939,8 +3933,7 @@ void close_ctree(struct btrfs_root *root)
        kthread_stop(fs_info->transaction_kthread);
        kthread_stop(fs_info->cleaner_kthread);
 
-       fs_info->closing = 2;
-       smp_mb();
+       set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
 
        btrfs_free_qgroup_config(fs_info);
 
@@ -3965,7 +3958,7 @@ void close_ctree(struct btrfs_root *root)
        invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
        btrfs_stop_all_workers(fs_info);
 
-       fs_info->open = 0;
+       clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
        free_root_pointers(fs_info, 1);
 
        iput(fs_info->btree_inode);

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index e9d60607a0bd70bcc29f38df25fe970938a61aa9..3e360132a2b7c0daec53dd1d65f5ccfe010517eb 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2940,7 +2940,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
        if (trans->aborted)
                return 0;
 
-       if (root->fs_info->creating_free_space_tree)
+       if (test_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &root->fs_info->flags))
                return 0;
 
        if (root == root->fs_info->extent_root)
@@ -5188,7 +5188,7 @@ static int __reserve_metadata_bytes(struct btrfs_root *root,
                 * which means we won't have fs_info->fs_root set, so don't do
                 * the async reclaim as we will panic.
                 */
-               if (!root->fs_info->log_root_recovering &&
+               if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags) &&
                    need_do_async_reclaim(space_info, root, used) &&
                    !work_busy(&root->fs_info->async_reclaim_work)) {
                        trace_btrfs_trigger_flush(root->fs_info,
@@ -5794,7 +5794,7 @@ int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
        int ret;
        struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
 
-       if (root->fs_info->quota_enabled) {
+       if (test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags)) {
                /* One for parent inode, two for dir entries */
                num_bytes = 3 * root->nodesize;
                ret = btrfs_qgroup_reserve_meta(root, num_bytes);
@@ -5972,7 +5972,7 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
        csum_bytes = BTRFS_I(inode)->csum_bytes;
        spin_unlock(&BTRFS_I(inode)->lock);
 
-       if (root->fs_info->quota_enabled) {
+       if (test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags)) {
                ret = btrfs_qgroup_reserve_meta(root,
                                nr_extents * root->nodesize);
                if (ret)
@@ -8544,7 +8544,7 @@ static int account_leaf_items(struct btrfs_trans_handle *trans,
        u64 bytenr, num_bytes;
 
        /* We can be called directly from walk_up_proc() */
-       if (!root->fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags))
                return 0;
 
        for (i = 0; i < nr; i++) {
@@ -8653,7 +8653,7 @@ static int account_shared_subtree(struct btrfs_trans_handle *trans,
        BUG_ON(root_level < 0 || root_level > BTRFS_MAX_LEVEL);
        BUG_ON(root_eb == NULL);
 
-       if (!root->fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags))
                return 0;
 
        if (!extent_buffer_uptodate(root_eb)) {
@@ -10803,7 +10803,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
        struct btrfs_trans_handle *trans;
        int ret = 0;
 
-       if (!fs_info->open)
+       if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
                return;
 
        spin_lock(&fs_info->unused_bgs_lock);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index e26e3feca500fe42b21a9505ea72eff1e245e17a..14ab8576cc93128d2ed1a518ecdbae2ac3c1384c 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3625,7 +3625,6 @@ static void end_extent_buffer_writeback(struct extent_buffer *eb)
 static void set_btree_ioerr(struct page *page)
 {
        struct extent_buffer *eb = (struct extent_buffer *)page->private;
-       struct btrfs_inode *btree_ino = BTRFS_I(eb->fs_info->btree_inode);
 
        SetPageError(page);
        if (test_and_set_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags))
@@ -3671,13 +3670,13 @@ static void set_btree_ioerr(struct page *page)
         */
        switch (eb->log_index) {
        case -1:
-               set_bit(BTRFS_INODE_BTREE_ERR, &btree_ino->runtime_flags);
+               set_bit(BTRFS_FS_BTREE_ERR, &eb->fs_info->flags);
                break;
        case 0:
-               set_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags);
+               set_bit(BTRFS_FS_LOG1_ERR, &eb->fs_info->flags);
                break;
        case 1:
-               set_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags);
+               set_bit(BTRFS_FS_LOG2_ERR, &eb->fs_info->flags);
                break;
        default:
                BUG(); /* unexpected, logic error */

diff --git a/fs/btrfs/free-space-tree.c b/fs/btrfs/free-space-tree.c
index 87e7e3d3e6760ebb2b07ef73162ff1d83942d641..83ee63bdca9606dec2a8623118642766342be244 100644 (file)
--- a/fs/btrfs/free-space-tree.c
+++ b/fs/btrfs/free-space-tree.c
@@ -1163,7 +1163,7 @@ int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)
        if (IS_ERR(trans))
                return PTR_ERR(trans);
 
-       fs_info->creating_free_space_tree = 1;
+       set_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);
        free_space_root = btrfs_create_tree(trans, fs_info,
                                            BTRFS_FREE_SPACE_TREE_OBJECTID);
        if (IS_ERR(free_space_root)) {
@@ -1183,7 +1183,7 @@ int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)
        }
 
        btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE);
-       fs_info->creating_free_space_tree = 0;
+       clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);
 
        ret = btrfs_commit_transaction(trans, tree_root);
        if (ret)
@@ -1192,7 +1192,7 @@ int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)
        return 0;
 
 abort:
-       fs_info->creating_free_space_tree = 0;
+       clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);
        btrfs_abort_transaction(trans, ret);
        btrfs_end_transaction(trans, tree_root);
        return ret;

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 8c63752b0a962c7cd77376f7c998a9328037e27e..b5e08a903bb3860588199ddd0b27601b87ab3272 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3948,7 +3948,7 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
         */
        if (!btrfs_is_free_space_inode(inode)
            && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
-           && !root->fs_info->log_root_recovering) {
+           && !test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) {
                btrfs_update_root_times(trans, root);
 
                ret = btrfs_delayed_update_inode(trans, root, inode);
@@ -5235,7 +5235,7 @@ void btrfs_evict_inode(struct inode *inode)
 
        btrfs_free_io_failure_record(inode, 0, (u64)-1);
 
-       if (root->fs_info->log_root_recovering) {
+       if (test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) {
                BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
                                 &BTRFS_I(inode)->runtime_flags));
                goto no_delete;

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 8db2e29fdcf417db6096a107c938a4a133fb6af2..13c2dc79501b3e1e1067faf1c26fe8dfd6501dc5 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -309,7 +309,7 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
        u64 flags = 0;
        u64 rescan_progress = 0;
 
-       if (!fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
                return 0;
 
        fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS);
@@ -463,13 +463,11 @@ next2:
        }
 out:
        fs_info->qgroup_flags |= flags;
-       if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) {
-               fs_info->quota_enabled = 0;
-               fs_info->pending_quota_state = 0;
-       } else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN &&
-                  ret >= 0) {
+       if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))
+               clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
+       else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN &&
+                ret >= 0)
                ret = qgroup_rescan_init(fs_info, rescan_progress, 0);
-       }
        btrfs_free_path(path);
 
        if (ret < 0) {
@@ -847,7 +845,7 @@ static int btrfs_clean_quota_tree(struct btrfs_trans_handle *trans,
        }
        ret = 0;
 out:
-       root->fs_info->pending_quota_state = 0;
+       set_bit(BTRFS_FS_QUOTA_DISABLING, &root->fs_info->flags);
        btrfs_free_path(path);
        return ret;
 }
@@ -868,7 +866,7 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
 
        mutex_lock(&fs_info->qgroup_ioctl_lock);
        if (fs_info->quota_root) {
-               fs_info->pending_quota_state = 1;
+               set_bit(BTRFS_FS_QUOTA_ENABLING, &fs_info->flags);
                goto out;
        }
 
@@ -964,7 +962,7 @@ out_add_root:
        }
        spin_lock(&fs_info->qgroup_lock);
        fs_info->quota_root = quota_root;
-       fs_info->pending_quota_state = 1;
+       set_bit(BTRFS_FS_QUOTA_ENABLING, &fs_info->flags);
        spin_unlock(&fs_info->qgroup_lock);
 out_free_path:
        btrfs_free_path(path);
@@ -993,8 +991,8 @@ int btrfs_quota_disable(struct btrfs_trans_handle *trans,
        mutex_lock(&fs_info->qgroup_ioctl_lock);
        if (!fs_info->quota_root)
                goto out;
-       fs_info->quota_enabled = 0;
-       fs_info->pending_quota_state = 0;
+       clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
+       set_bit(BTRFS_FS_QUOTA_DISABLING, &fs_info->flags);
        btrfs_qgroup_wait_for_completion(fs_info, false);
        spin_lock(&fs_info->qgroup_lock);
        quota_root = fs_info->quota_root;
@@ -1490,7 +1488,8 @@ int btrfs_qgroup_insert_dirty_extent(struct btrfs_trans_handle *trans,
        struct btrfs_delayed_ref_root *delayed_refs;
        int ret;
 
-       if (!fs_info->quota_enabled || bytenr == 0 || num_bytes == 0)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)
+           || bytenr == 0 || num_bytes == 0)
                return 0;
        if (WARN_ON(trans == NULL))
                return -EINVAL;
@@ -1713,7 +1712,7 @@ btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans,
        if (old_roots)
                nr_old_roots = old_roots->nnodes;
 
-       if (!fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
                goto out_free;
        BUG_ON(!fs_info->quota_root);
 
@@ -1833,10 +1832,14 @@ int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
        if (!quota_root)
                goto out;
 
-       if (!fs_info->quota_enabled && fs_info->pending_quota_state)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
+           test_bit(BTRFS_FS_QUOTA_ENABLING, &fs_info->flags))
                start_rescan_worker = 1;
 
-       fs_info->quota_enabled = fs_info->pending_quota_state;
+       if (test_and_clear_bit(BTRFS_FS_QUOTA_ENABLING, &fs_info->flags))
+               set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
+       if (test_and_clear_bit(BTRFS_FS_QUOTA_DISABLING, &fs_info->flags))
+               clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
 
        spin_lock(&fs_info->qgroup_lock);
        while (!list_empty(&fs_info->dirty_qgroups)) {
@@ -1855,7 +1858,7 @@ int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
                                        BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
                spin_lock(&fs_info->qgroup_lock);
        }
-       if (fs_info->quota_enabled)
+       if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
                fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON;
        else
                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON;
@@ -1900,7 +1903,7 @@ int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans,
        u64 nums;
 
        mutex_lock(&fs_info->qgroup_ioctl_lock);
-       if (!fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
                goto out;
 
        if (!quota_root) {
@@ -2347,7 +2350,7 @@ static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
                        err = PTR_ERR(trans);
                        break;
                }
-               if (!fs_info->quota_enabled) {
+               if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) {
                        err = -EINTR;
                } else {
                        err = qgroup_rescan_leaf(fs_info, path, trans);
@@ -2578,8 +2581,8 @@ int btrfs_qgroup_reserve_data(struct inode *inode, u64 start, u64 len)
        struct ulist_iterator uiter;
        int ret;
 
-       if (!root->fs_info->quota_enabled || !is_fstree(root->objectid) ||
-           len == 0)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags) ||
+           !is_fstree(root->objectid) || len == 0)
                return 0;
 
        changeset.bytes_changed = 0;
@@ -2676,8 +2679,8 @@ int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes)
 {
        int ret;
 
-       if (!root->fs_info->quota_enabled || !is_fstree(root->objectid) ||
-           num_bytes == 0)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags) ||
+           !is_fstree(root->objectid) || num_bytes == 0)
                return 0;
 
        BUG_ON(num_bytes != round_down(num_bytes, root->nodesize));
@@ -2692,7 +2695,8 @@ void btrfs_qgroup_free_meta_all(struct btrfs_root *root)
 {
        int reserved;
 
-       if (!root->fs_info->quota_enabled || !is_fstree(root->objectid))
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags) ||
+           !is_fstree(root->objectid))
                return;
 
        reserved = atomic_xchg(&root->qgroup_meta_rsv, 0);
@@ -2703,7 +2707,8 @@ void btrfs_qgroup_free_meta_all(struct btrfs_root *root)
 
 void btrfs_qgroup_free_meta(struct btrfs_root *root, int num_bytes)
 {
-       if (!root->fs_info->quota_enabled || !is_fstree(root->objectid))
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags) ||
+           !is_fstree(root->objectid))
                return;
 
        BUG_ON(num_bytes != round_down(num_bytes, root->nodesize));

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 7d53f2acb09ef6156324b061e74eb3acaa337acc..83fc51f786ab8ddb86c30710f1bdeb19fd3dcca9 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3952,7 +3952,7 @@ static int qgroup_fix_relocated_data_extents(struct btrfs_trans_handle *trans,
        struct btrfs_key key;
        int ret = 0;
 
-       if (!fs_info->quota_enabled)
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
                return 0;
 
        /*

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 4071fe2bd0981a547f983ebeaa944f3179d97659..21f2b2d87f373898a63336faf58d0bcddaf65c9b 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1836,7 +1836,7 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                }
                sb->s_flags &= ~MS_RDONLY;
 
-               fs_info->open = 1;
+               set_bit(BTRFS_FS_OPEN, &fs_info->flags);
        }
 out:
        wake_up_process(fs_info->transaction_kthread);

diff --git a/fs/btrfs/tests/qgroup-tests.c b/fs/btrfs/tests/qgroup-tests.c
index 4407fef7c16c1911cef2c6eec107018b6546d513..ca7cb5e6d3857cb80338521509cf557aed43443f 100644 (file)
--- a/fs/btrfs/tests/qgroup-tests.c
+++ b/fs/btrfs/tests/qgroup-tests.c
@@ -480,7 +480,7 @@ int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
         */
        root->fs_info->tree_root = root;
        root->fs_info->quota_root = root;
-       root->fs_info->quota_enabled = 1;
+       set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
 
        /*
         * Can't use bytenr 0, some things freak out

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 95d41919d034ef69647b6983dfac27f87f17e130..b53104042e954f493aee84965072567a040a6d47 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -441,7 +441,7 @@ static void wait_current_trans(struct btrfs_root *root)
 
 static int may_wait_transaction(struct btrfs_root *root, int type)
 {
-       if (root->fs_info->log_root_recovering)
+       if (test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags))
                return 0;
 
        if (type == TRANS_USERSPACE)
@@ -993,7 +993,6 @@ int btrfs_wait_marked_extents(struct btrfs_root *root,
        struct extent_state *cached_state = NULL;
        u64 start = 0;
        u64 end;
-       struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
        bool errors = false;
 
        while (!find_first_extent_bit(dirty_pages, start, &start, &end,
@@ -1025,17 +1024,17 @@ int btrfs_wait_marked_extents(struct btrfs_root *root,
 
        if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
                if ((mark & EXTENT_DIRTY) &&
-                   test_and_clear_bit(BTRFS_INODE_BTREE_LOG1_ERR,
-                                      &btree_ino->runtime_flags))
+                   test_and_clear_bit(BTRFS_FS_LOG1_ERR,
+                                      &root->fs_info->flags))
                        errors = true;
 
                if ((mark & EXTENT_NEW) &&
-                   test_and_clear_bit(BTRFS_INODE_BTREE_LOG2_ERR,
-                                      &btree_ino->runtime_flags))
+                   test_and_clear_bit(BTRFS_FS_LOG2_ERR,
+                                      &root->fs_info->flags))
                        errors = true;
        } else {
-               if (test_and_clear_bit(BTRFS_INODE_BTREE_ERR,
-                                      &btree_ino->runtime_flags))
+               if (test_and_clear_bit(BTRFS_FS_BTREE_ERR,
+                                      &root->fs_info->flags))
                        errors = true;
        }
 
@@ -1335,7 +1334,7 @@ static int qgroup_account_snapshot(struct btrfs_trans_handle *trans,
         * kick in anyway.
         */
        mutex_lock(&fs_info->qgroup_ioctl_lock);
-       if (!fs_info->quota_enabled) {
+       if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) {
                mutex_unlock(&fs_info->qgroup_ioctl_lock);
                return 0;
        }
@@ -1712,7 +1711,7 @@ static void update_super_roots(struct btrfs_root *root)
        super->root_level = root_item->level;
        if (btrfs_test_opt(root->fs_info, SPACE_CACHE))
                super->cache_generation = root_item->generation;
-       if (root->fs_info->update_uuid_tree_gen)
+       if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &root->fs_info->flags))
                super->uuid_tree_generation = root_item->generation;
 }
 
@@ -1919,7 +1918,6 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 {
        struct btrfs_transaction *cur_trans = trans->transaction;
        struct btrfs_transaction *prev_trans = NULL;
-       struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode);
        int ret;
 
        /* Stop the commit early if ->aborted is set */
@@ -2213,8 +2211,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        btrfs_update_commit_device_size(root->fs_info);
        btrfs_update_commit_device_bytes_used(root, cur_trans);
 
-       clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags);
-       clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags);
+       clear_bit(BTRFS_FS_LOG1_ERR, &root->fs_info->flags);
+       clear_bit(BTRFS_FS_LOG2_ERR, &root->fs_info->flags);
 
        btrfs_trans_release_chunk_metadata(trans);
 

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index ef9c55bc79074534e826fd30c9e72a0d5036af84..d22adf4fea7ecc40a25c1f2fe3fcf815ef33841f 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -5579,7 +5579,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
        if (!path)
                return -ENOMEM;
 
-       fs_info->log_root_recovering = 1;
+       set_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
 
        trans = btrfs_start_transaction(fs_info->tree_root, 0);
        if (IS_ERR(trans)) {
@@ -5689,7 +5689,7 @@ again:
 
        free_extent_buffer(log_root_tree->node);
        log_root_tree->log_root = NULL;
-       fs_info->log_root_recovering = 0;
+       clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
        kfree(log_root_tree);
 
        return 0;

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 4ff39952bdfc4c589c3de43f9fc74ecc6cef54cc..c356ce332229fbf81d82ca877321647b90789c33 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4217,7 +4217,7 @@ out:
        if (ret)
                btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
        else
-               fs_info->update_uuid_tree_gen = 1;
+               set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
        up(&fs_info->uuid_tree_rescan_sem);
        return 0;
 }