mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
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>
This commit is contained in:
parent
ba8b04c1d4
commit
afcdd129e0
16 changed files with 99 additions and 109 deletions
|
@ -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 {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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 @@ int open_ctree(struct super_block *sb,
|
|||
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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
|
|||
}
|
||||
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 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
|
|||
}
|
||||
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));
|
||||
|
|
|
@ -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;
|
||||
|
||||
/*
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
|
|||
|
||||
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;
|
||||
|
|
|
@ -4217,7 +4217,7 @@ static int btrfs_uuid_scan_kthread(void *data)
|
|||
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;
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue