public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-09-18 22:14:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

btrfs: btrfs_test_opt and friends should take a btrfs_fs_info

Browse source 
btrfs_test_opt and friends only use the root pointer to access
the fs_info.  Let's pass the fs_info directly in preparation to
eliminate similar patterns all over btrfs.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Jeff Mahoney 2016-06-09 21:38:35 -04:00 • committed by David Sterba
parent bc074524e1
commit 3cdde2240d
13 changed files with 135 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
fs/btrfs/ctree.h
View file

@ -1301,21 +1301,21 @@ struct btrfs_root {
#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
#define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt) #define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt)
#define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \ #define btrfs_test_opt(fs_info, opt) ((fs_info)->mount_opt & \
BTRFS_MOUNT_##opt) BTRFS_MOUNT_##opt)
#define btrfs_set_and_info(root, opt, fmt, args...) \ #define btrfs_set_and_info(fs_info, opt, fmt, args...) \
{ \ { \
if (!btrfs_test_opt(root, opt)) \ if (!btrfs_test_opt(fs_info, opt)) \
btrfs_info(root->fs_info, fmt, ##args); \ btrfs_info(fs_info, fmt, ##args); \
btrfs_set_opt(root->fs_info->mount_opt, opt); \ btrfs_set_opt(fs_info->mount_opt, opt); \
} }
#define btrfs_clear_and_info(root, opt, fmt, args...) \ #define btrfs_clear_and_info(fs_info, opt, fmt, args...) \
{ \ { \
if (btrfs_test_opt(root, opt)) \ if (btrfs_test_opt(fs_info, opt)) \
btrfs_info(root->fs_info, fmt, ##args); \ btrfs_info(fs_info, fmt, ##args); \
btrfs_clear_opt(root->fs_info->mount_opt, opt); \ btrfs_clear_opt(fs_info->mount_opt, opt); \
} }
#ifdef CONFIG_BTRFS_DEBUG #ifdef CONFIG_BTRFS_DEBUG
@ -1323,9 +1323,9 @@ static inline int
btrfs_should_fragment_free_space(struct btrfs_root *root, btrfs_should_fragment_free_space(struct btrfs_root *root,
struct btrfs_block_group_cache *block_group) struct btrfs_block_group_cache *block_group)
{ {
return (btrfs_test_opt(root, FRAGMENT_METADATA) && return (btrfs_test_opt(root->fs_info, FRAGMENT_METADATA) &&
block_group->flags & BTRFS_BLOCK_GROUP_METADATA) || block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
(btrfs_test_opt(root, FRAGMENT_DATA) && (btrfs_test_opt(root->fs_info, FRAGMENT_DATA) &&
block_group->flags & BTRFS_BLOCK_GROUP_DATA); block_group->flags & BTRFS_BLOCK_GROUP_DATA);
} }
#endif #endif

4
fs/btrfs/dev-replace.c
View file

@ -142,7 +142,7 @@ no_valid_dev_replace_entry_found:
* missing * missing
*/ */
if (!dev_replace->srcdev && if (!dev_replace->srcdev &&
!btrfs_test_opt(dev_root, DEGRADED)) { !btrfs_test_opt(dev_root->fs_info, DEGRADED)) {
ret = -EIO; ret = -EIO;
btrfs_warn(fs_info, btrfs_warn(fs_info,
"cannot mount because device replace operation is ongoing and"); "cannot mount because device replace operation is ongoing and");
@ -151,7 +151,7 @@ no_valid_dev_replace_entry_found:
src_devid); src_devid);
} }
if (!dev_replace->tgtdev && if (!dev_replace->tgtdev &&
!btrfs_test_opt(dev_root, DEGRADED)) { !btrfs_test_opt(dev_root->fs_info, DEGRADED)) {
ret = -EIO; ret = -EIO;
btrfs_warn(fs_info, btrfs_warn(fs_info,
"cannot mount because device replace operation is ongoing and"); "cannot mount because device replace operation is ongoing and");

22
fs/btrfs/disk-io.c
View file

@ -3019,8 +3019,8 @@ retry_root_backup:
if (IS_ERR(fs_info->transaction_kthread)) if (IS_ERR(fs_info->transaction_kthread))
goto fail_cleaner; goto fail_cleaner;
if (!btrfs_test_opt(tree_root, SSD) && if (!btrfs_test_opt(tree_root->fs_info, SSD) &&
!btrfs_test_opt(tree_root, NOSSD) && !btrfs_test_opt(tree_root->fs_info, NOSSD) &&
!fs_info->fs_devices->rotating) { !fs_info->fs_devices->rotating) {
btrfs_info(fs_info, "detected SSD devices, enabling SSD mode"); btrfs_info(fs_info, "detected SSD devices, enabling SSD mode");
btrfs_set_opt(fs_info->mount_opt, SSD); btrfs_set_opt(fs_info->mount_opt, SSD);
@ -3033,9 +3033,9 @@ retry_root_backup:
btrfs_apply_pending_changes(fs_info); btrfs_apply_pending_changes(fs_info);
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) { if (btrfs_test_opt(tree_root->fs_info, CHECK_INTEGRITY)) {
ret = btrfsic_mount(tree_root, fs_devices, ret = btrfsic_mount(tree_root, fs_devices,
btrfs_test_opt(tree_root, btrfs_test_opt(tree_root->fs_info,
CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ? CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
1 : 0, 1 : 0,
fs_info->check_integrity_print_mask); fs_info->check_integrity_print_mask);
@ -3051,7 +3051,7 @@ retry_root_backup:
/* do not make disk changes in broken FS or nologreplay is given */ /* do not make disk changes in broken FS or nologreplay is given */
if (btrfs_super_log_root(disk_super) != 0 && if (btrfs_super_log_root(disk_super) != 0 &&
!btrfs_test_opt(tree_root, NOLOGREPLAY)) { !btrfs_test_opt(tree_root->fs_info, NOLOGREPLAY)) {
ret = btrfs_replay_log(fs_info, fs_devices); ret = btrfs_replay_log(fs_info, fs_devices);
if (ret) { if (ret) {
err = ret; err = ret;
@ -3092,7 +3092,7 @@ retry_root_backup:
if (sb->s_flags & MS_RDONLY) if (sb->s_flags & MS_RDONLY)
return 0; return 0;
if (btrfs_test_opt(tree_root, FREE_SPACE_TREE) && if (btrfs_test_opt(tree_root->fs_info, FREE_SPACE_TREE) &&
!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) { !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
btrfs_info(fs_info, "creating free space tree"); btrfs_info(fs_info, "creating free space tree");
ret = btrfs_create_free_space_tree(fs_info); ret = btrfs_create_free_space_tree(fs_info);
@ -3129,7 +3129,7 @@ retry_root_backup:
btrfs_qgroup_rescan_resume(fs_info); btrfs_qgroup_rescan_resume(fs_info);
if (btrfs_test_opt(tree_root, CLEAR_CACHE) && if (btrfs_test_opt(tree_root->fs_info, CLEAR_CACHE) &&
btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) { btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
btrfs_info(fs_info, "clearing free space tree"); btrfs_info(fs_info, "clearing free space tree");
ret = btrfs_clear_free_space_tree(fs_info); ret = btrfs_clear_free_space_tree(fs_info);
@ -3150,7 +3150,7 @@ retry_root_backup:
close_ctree(tree_root); close_ctree(tree_root);
return ret; return ret;
} }
} else if (btrfs_test_opt(tree_root, RESCAN_UUID_TREE) || } else if (btrfs_test_opt(tree_root->fs_info, RESCAN_UUID_TREE) ||
fs_info->generation != fs_info->generation !=
btrfs_super_uuid_tree_generation(disk_super)) { btrfs_super_uuid_tree_generation(disk_super)) {
btrfs_info(fs_info, "checking UUID tree"); btrfs_info(fs_info, "checking UUID tree");
@ -3227,7 +3227,7 @@ fail:
return err; return err;
recovery_tree_root: recovery_tree_root:
if (!btrfs_test_opt(tree_root, USEBACKUPROOT)) if (!btrfs_test_opt(tree_root->fs_info, USEBACKUPROOT))
goto fail_tree_roots; goto fail_tree_roots;
free_root_pointers(fs_info, 0); free_root_pointers(fs_info, 0);
@ -3642,7 +3642,7 @@ static int write_all_supers(struct btrfs_root *root, int max_mirrors)
int total_errors = 0; int total_errors = 0;
u64 flags; u64 flags;
do_barriers = !btrfs_test_opt(root, NOBARRIER); do_barriers = !btrfs_test_opt(root->fs_info, NOBARRIER);
backup_super_roots(root->fs_info); backup_super_roots(root->fs_info);
sb = root->fs_info->super_for_commit; sb = root->fs_info->super_for_commit;
@ -3926,7 +3926,7 @@ void close_ctree(struct btrfs_root *root)
iput(fs_info->btree_inode); iput(fs_info->btree_inode);
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
if (btrfs_test_opt(root, CHECK_INTEGRITY)) if (btrfs_test_opt(root->fs_info, CHECK_INTEGRITY))
btrfsic_unmount(root, fs_info->fs_devices); btrfsic_unmount(root, fs_info->fs_devices);
#endif #endif

30
fs/btrfs/extent-tree.c
View file

@ -3448,7 +3448,7 @@ again:
spin_lock(&block_group->lock); spin_lock(&block_group->lock);
if (block_group->cached != BTRFS_CACHE_FINISHED || if (block_group->cached != BTRFS_CACHE_FINISHED ||
!btrfs_test_opt(root, SPACE_CACHE)) { !btrfs_test_opt(root->fs_info, SPACE_CACHE)) {
/* /*
* don't bother trying to write stuff out _if_ * don't bother trying to write stuff out _if_
* a) we're not cached, * a) we're not cached,
@ -3525,7 +3525,7 @@ int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
struct btrfs_path *path; struct btrfs_path *path;
if (list_empty(&cur_trans->dirty_bgs) || if (list_empty(&cur_trans->dirty_bgs) ||
!btrfs_test_opt(root, SPACE_CACHE)) !btrfs_test_opt(root->fs_info, SPACE_CACHE))
return 0; return 0;
path = btrfs_alloc_path(); path = btrfs_alloc_path();
@ -4444,7 +4444,7 @@ void check_system_chunk(struct btrfs_trans_handle *trans,
thresh = btrfs_calc_trunc_metadata_size(root, num_devs) + thresh = btrfs_calc_trunc_metadata_size(root, num_devs) +
btrfs_calc_trans_metadata_size(root, 1); btrfs_calc_trans_metadata_size(root, 1);
if (left < thresh && btrfs_test_opt(root, ENOSPC_DEBUG)) { if (left < thresh && btrfs_test_opt(root->fs_info, ENOSPC_DEBUG)) {
btrfs_info(root->fs_info, "left=%llu, need=%llu, flags=%llu", btrfs_info(root->fs_info, "left=%llu, need=%llu, flags=%llu",
left, thresh, type); left, thresh, type);
dump_space_info(info, 0, 0); dump_space_info(info, 0, 0);
@ -6216,7 +6216,7 @@ static int update_block_group(struct btrfs_trans_handle *trans,
spin_lock(&cache->space_info->lock); spin_lock(&cache->space_info->lock);
spin_lock(&cache->lock); spin_lock(&cache->lock);
if (btrfs_test_opt(root, SPACE_CACHE) && if (btrfs_test_opt(root->fs_info, SPACE_CACHE) &&
cache->disk_cache_state < BTRFS_DC_CLEAR) cache->disk_cache_state < BTRFS_DC_CLEAR)
cache->disk_cache_state = BTRFS_DC_CLEAR; cache->disk_cache_state = BTRFS_DC_CLEAR;
@ -6598,7 +6598,7 @@ fetch_cluster_info(struct btrfs_root *root, struct btrfs_space_info *space_info,
u64 *empty_cluster) u64 *empty_cluster)
{ {
struct btrfs_free_cluster *ret = NULL; struct btrfs_free_cluster *ret = NULL;
bool ssd = btrfs_test_opt(root, SSD); bool ssd = btrfs_test_opt(root->fs_info, SSD);
*empty_cluster = 0; *empty_cluster = 0;
if (btrfs_mixed_space_info(space_info)) if (btrfs_mixed_space_info(space_info))
@ -6743,7 +6743,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
break; break;
} }
if (btrfs_test_opt(root, DISCARD)) if (btrfs_test_opt(root->fs_info, DISCARD))
ret = btrfs_discard_extent(root, start, ret = btrfs_discard_extent(root, start,
end + 1 - start, NULL); end + 1 - start, NULL);
@ -7962,7 +7962,7 @@ again:
if (num_bytes == min_alloc_size) if (num_bytes == min_alloc_size)
final_tried = true; final_tried = true;
goto again; goto again;
} else if (btrfs_test_opt(root, ENOSPC_DEBUG)) { } else if (btrfs_test_opt(root->fs_info, ENOSPC_DEBUG)) {
struct btrfs_space_info *sinfo; struct btrfs_space_info *sinfo;
sinfo = __find_space_info(root->fs_info, flags); sinfo = __find_space_info(root->fs_info, flags);
@ -7993,7 +7993,7 @@ static int __btrfs_free_reserved_extent(struct btrfs_root *root,
if (pin) if (pin)
pin_down_extent(root, cache, start, len, 1); pin_down_extent(root, cache, start, len, 1);
else { else {
if (btrfs_test_opt(root, DISCARD)) if (btrfs_test_opt(root->fs_info, DISCARD))
ret = btrfs_discard_extent(root, start, len, NULL); ret = btrfs_discard_extent(root, start, len, NULL);
btrfs_add_free_space(cache, start, len); btrfs_add_free_space(cache, start, len);
btrfs_update_reserved_bytes(cache, len, RESERVE_FREE, delalloc); btrfs_update_reserved_bytes(cache, len, RESERVE_FREE, delalloc);
@ -8301,7 +8301,7 @@ again:
goto again; goto again;
} }
if (btrfs_test_opt(root, ENOSPC_DEBUG)) { if (btrfs_test_opt(root->fs_info, ENOSPC_DEBUG)) {
static DEFINE_RATELIMIT_STATE(_rs, static DEFINE_RATELIMIT_STATE(_rs,
DEFAULT_RATELIMIT_INTERVAL * 10, DEFAULT_RATELIMIT_INTERVAL * 10,
/*DEFAULT_RATELIMIT_BURST*/ 1); /*DEFAULT_RATELIMIT_BURST*/ 1);
@ -9735,7 +9735,7 @@ int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
int full = 0; int full = 0;
int ret = 0; int ret = 0;
debug = btrfs_test_opt(root, ENOSPC_DEBUG); debug = btrfs_test_opt(root->fs_info, ENOSPC_DEBUG);
block_group = btrfs_lookup_block_group(root->fs_info, bytenr); block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
@ -10148,10 +10148,10 @@ int btrfs_read_block_groups(struct btrfs_root *root)
path->reada = READA_FORWARD; path->reada = READA_FORWARD;
cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy); cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
if (btrfs_test_opt(root, SPACE_CACHE) && if (btrfs_test_opt(root->fs_info, SPACE_CACHE) &&
btrfs_super_generation(root->fs_info->super_copy) != cache_gen) btrfs_super_generation(root->fs_info->super_copy) != cache_gen)
need_clear = 1; need_clear = 1;
if (btrfs_test_opt(root, CLEAR_CACHE)) if (btrfs_test_opt(root->fs_info, CLEAR_CACHE))
need_clear = 1; need_clear = 1;
while (1) { while (1) {
@ -10182,7 +10182,7 @@ int btrfs_read_block_groups(struct btrfs_root *root)
* b) Setting 'dirty flag' makes sure that we flush * b) Setting 'dirty flag' makes sure that we flush
* the new space cache info onto disk. * the new space cache info onto disk.
*/ */
if (btrfs_test_opt(root, SPACE_CACHE)) if (btrfs_test_opt(root->fs_info, SPACE_CACHE))
cache->disk_cache_state = BTRFS_DC_CLEAR; cache->disk_cache_state = BTRFS_DC_CLEAR;
} }
@ -10641,7 +10641,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
spin_lock(&block_group->space_info->lock); spin_lock(&block_group->space_info->lock);
list_del_init(&block_group->ro_list); list_del_init(&block_group->ro_list);
if (btrfs_test_opt(root, ENOSPC_DEBUG)) { if (btrfs_test_opt(root->fs_info, ENOSPC_DEBUG)) {
WARN_ON(block_group->space_info->total_bytes WARN_ON(block_group->space_info->total_bytes
< block_group->key.offset); < block_group->key.offset);
WARN_ON(block_group->space_info->bytes_readonly WARN_ON(block_group->space_info->bytes_readonly
@ -10909,7 +10909,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
spin_unlock(&space_info->lock); spin_unlock(&space_info->lock);
/* DISCARD can flip during remount */ /* DISCARD can flip during remount */
trimming = btrfs_test_opt(root, DISCARD); trimming = btrfs_test_opt(root->fs_info, DISCARD);
/* Implicit trim during transaction commit. */ /* Implicit trim during transaction commit. */
if (trimming) if (trimming)

2
fs/btrfs/file.c
View file

@ -132,7 +132,7 @@ static int __btrfs_add_inode_defrag(struct inode *inode,
static inline int __need_auto_defrag(struct btrfs_root *root) static inline int __need_auto_defrag(struct btrfs_root *root)
{ {
if (!btrfs_test_opt(root, AUTO_DEFRAG)) if (!btrfs_test_opt(root->fs_info, AUTO_DEFRAG))
return 0; return 0;
if (btrfs_fs_closing(root->fs_info)) if (btrfs_fs_closing(root->fs_info))

6
fs/btrfs/free-space-cache.c
View file

@ -3026,7 +3026,7 @@ int btrfs_find_space_cluster(struct btrfs_root *root,
* For metadata, allow allocates with smaller extents. For * For metadata, allow allocates with smaller extents. For
* data, keep it dense. * data, keep it dense.
*/ */
if (btrfs_test_opt(root, SSD_SPREAD)) { if (btrfs_test_opt(root->fs_info, SSD_SPREAD)) {
cont1_bytes = min_bytes = bytes + empty_size; cont1_bytes = min_bytes = bytes + empty_size;
} else if (block_group->flags & BTRFS_BLOCK_GROUP_METADATA) { } else if (block_group->flags & BTRFS_BLOCK_GROUP_METADATA) {
cont1_bytes = bytes; cont1_bytes = bytes;
@ -3470,7 +3470,7 @@ int load_free_ino_cache(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
int ret = 0; int ret = 0;
u64 root_gen = btrfs_root_generation(&root->root_item); u64 root_gen = btrfs_root_generation(&root->root_item);
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return 0; return 0;
/* /*
@ -3514,7 +3514,7 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root,
struct btrfs_io_ctl io_ctl; struct btrfs_io_ctl io_ctl;
bool release_metadata = true; bool release_metadata = true;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return 0; return 0;
memset(&io_ctl, 0, sizeof(io_ctl)); memset(&io_ctl, 0, sizeof(io_ctl));

12
fs/btrfs/inode-map.c
View file

@ -38,7 +38,7 @@ static int caching_kthread(void *data)
int slot; int slot;
int ret; int ret;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return 0; return 0;
path = btrfs_alloc_path(); path = btrfs_alloc_path();
@ -141,7 +141,7 @@ static void start_caching(struct btrfs_root *root)
int ret; int ret;
u64 objectid; u64 objectid;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return; return;
spin_lock(&root->ino_cache_lock); spin_lock(&root->ino_cache_lock);
@ -185,7 +185,7 @@ static void start_caching(struct btrfs_root *root)
int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid) int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid)
{ {
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return btrfs_find_free_objectid(root, objectid); return btrfs_find_free_objectid(root, objectid);
again: again:
@ -211,7 +211,7 @@ void btrfs_return_ino(struct btrfs_root *root, u64 objectid)
{ {
struct btrfs_free_space_ctl *pinned = root->free_ino_pinned; struct btrfs_free_space_ctl *pinned = root->free_ino_pinned;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return; return;
again: again:
if (root->ino_cache_state == BTRFS_CACHE_FINISHED) { if (root->ino_cache_state == BTRFS_CACHE_FINISHED) {
@ -251,7 +251,7 @@ void btrfs_unpin_free_ino(struct btrfs_root *root)
struct rb_node *n; struct rb_node *n;
u64 count; u64 count;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return; return;
while (1) { while (1) {
@ -412,7 +412,7 @@ int btrfs_save_ino_cache(struct btrfs_root *root,
if (btrfs_root_refs(&root->root_item) == 0) if (btrfs_root_refs(&root->root_item) == 0)
return 0; return 0;
if (!btrfs_test_opt(root, INODE_MAP_CACHE)) if (!btrfs_test_opt(root->fs_info, INODE_MAP_CACHE))
return 0; return 0;
path = btrfs_alloc_path(); path = btrfs_alloc_path();

12
fs/btrfs/inode.c
View file

@ -376,12 +376,12 @@ static inline int inode_need_compress(struct inode *inode)
struct btrfs_root *root = BTRFS_I(inode)->root; struct btrfs_root *root = BTRFS_I(inode)->root;
/* force compress */ /* force compress */
if (btrfs_test_opt(root, FORCE_COMPRESS)) if (btrfs_test_opt(root->fs_info, FORCE_COMPRESS))
return 1; return 1;
/* bad compression ratios */ /* bad compression ratios */
if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
return 0; return 0;
if (btrfs_test_opt(root, COMPRESS) || if (btrfs_test_opt(root->fs_info, COMPRESS) ||
BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS || BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS ||
BTRFS_I(inode)->force_compress) BTRFS_I(inode)->force_compress)
return 1; return 1;
@ -622,7 +622,7 @@ cont:
nr_pages_ret = 0; nr_pages_ret = 0;
/* flag the file so we don't compress in the future */ /* flag the file so we don't compress in the future */
if (!btrfs_test_opt(root, FORCE_COMPRESS) && if (!btrfs_test_opt(root->fs_info, FORCE_COMPRESS) &&
!(BTRFS_I(inode)->force_compress)) { !(BTRFS_I(inode)->force_compress)) {
BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
} }
@ -1159,7 +1159,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
async_cow->start = start; async_cow->start = start;
if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS && if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS &&
!btrfs_test_opt(root, FORCE_COMPRESS)) !btrfs_test_opt(root->fs_info, FORCE_COMPRESS))
cur_end = end; cur_end = end;
else else
cur_end = min(end, start + SZ_512K - 1); cur_end = min(end, start + SZ_512K - 1);
@ -6255,9 +6255,9 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
btrfs_inherit_iflags(inode, dir); btrfs_inherit_iflags(inode, dir);
if (S_ISREG(mode)) { if (S_ISREG(mode)) {
if (btrfs_test_opt(root, NODATASUM)) if (btrfs_test_opt(root->fs_info, NODATASUM))
BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
if (btrfs_test_opt(root, NODATACOW)) if (btrfs_test_opt(root->fs_info, NODATACOW))
BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW | BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |
BTRFS_INODE_NODATASUM; BTRFS_INODE_NODATASUM;
} }

2
fs/btrfs/ioctl.c
View file

@ -2406,7 +2406,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
* rmdir(2). * rmdir(2).
*/ */
err = -EPERM; err = -EPERM;
if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED)) if (!btrfs_test_opt(root->fs_info, USER_SUBVOL_RM_ALLOWED))
goto out_dput; goto out_dput;
/* /*

132
fs/btrfs/super.c
View file

@ -454,12 +454,12 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
*/ */
break; break;
case Opt_nodatasum: case Opt_nodatasum:
btrfs_set_and_info(root, NODATASUM, btrfs_set_and_info(info, NODATASUM,
"setting nodatasum"); "setting nodatasum");
break; break;
case Opt_datasum: case Opt_datasum:
if (btrfs_test_opt(root, NODATASUM)) { if (btrfs_test_opt(info, NODATASUM)) {
if (btrfs_test_opt(root, NODATACOW)) if (btrfs_test_opt(info, NODATACOW))
btrfs_info(root->fs_info, "setting datasum, datacow enabled"); btrfs_info(root->fs_info, "setting datasum, datacow enabled");
else else
btrfs_info(root->fs_info, "setting datasum"); btrfs_info(root->fs_info, "setting datasum");
@ -468,9 +468,9 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
btrfs_clear_opt(info->mount_opt, NODATASUM); btrfs_clear_opt(info->mount_opt, NODATASUM);
break; break;
case Opt_nodatacow: case Opt_nodatacow:
if (!btrfs_test_opt(root, NODATACOW)) { if (!btrfs_test_opt(info, NODATACOW)) {
if (!btrfs_test_opt(root, COMPRESS) || if (!btrfs_test_opt(info, COMPRESS) ||
!btrfs_test_opt(root, FORCE_COMPRESS)) { !btrfs_test_opt(info, FORCE_COMPRESS)) {
btrfs_info(root->fs_info, btrfs_info(root->fs_info,
"setting nodatacow, compression disabled"); "setting nodatacow, compression disabled");
} else { } else {
@ -483,7 +483,7 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
btrfs_set_opt(info->mount_opt, NODATASUM); btrfs_set_opt(info->mount_opt, NODATASUM);
break; break;
case Opt_datacow: case Opt_datacow:
btrfs_clear_and_info(root, NODATACOW, btrfs_clear_and_info(info, NODATACOW,
"setting datacow"); "setting datacow");
break; break;
case Opt_compress_force: case Opt_compress_force:
@ -492,10 +492,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
/* Fallthrough */ /* Fallthrough */
case Opt_compress: case Opt_compress:
case Opt_compress_type: case Opt_compress_type:
saved_compress_type = btrfs_test_opt(root, COMPRESS) ? saved_compress_type = btrfs_test_opt(info,
COMPRESS) ?
info->compress_type : BTRFS_COMPRESS_NONE; info->compress_type : BTRFS_COMPRESS_NONE;
saved_compress_force = saved_compress_force =
btrfs_test_opt(root, FORCE_COMPRESS); btrfs_test_opt(info, FORCE_COMPRESS);
if (token == Opt_compress || if (token == Opt_compress ||
token == Opt_compress_force || token == Opt_compress_force ||
strcmp(args[0].from, "zlib") == 0) { strcmp(args[0].from, "zlib") == 0) {
@ -535,10 +536,10 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
*/ */
btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
} }
if ((btrfs_test_opt(root, COMPRESS) && if ((btrfs_test_opt(info, COMPRESS) &&
(info->compress_type != saved_compress_type || (info->compress_type != saved_compress_type ||
compress_force != saved_compress_force)) || compress_force != saved_compress_force)) ||
(!btrfs_test_opt(root, COMPRESS) && (!btrfs_test_opt(info, COMPRESS) &&
no_compress == 1)) { no_compress == 1)) {
btrfs_info(root->fs_info, btrfs_info(root->fs_info,
"%s %s compression", "%s %s compression",
@ -548,25 +549,25 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
compress_force = false; compress_force = false;
break; break;
case Opt_ssd: case Opt_ssd:
btrfs_set_and_info(root, SSD, btrfs_set_and_info(info, SSD,
"use ssd allocation scheme"); "use ssd allocation scheme");
break; break;
case Opt_ssd_spread: case Opt_ssd_spread:
btrfs_set_and_info(root, SSD_SPREAD, btrfs_set_and_info(info, SSD_SPREAD,
"use spread ssd allocation scheme"); "use spread ssd allocation scheme");
btrfs_set_opt(info->mount_opt, SSD); btrfs_set_opt(info->mount_opt, SSD);
break; break;
case Opt_nossd: case Opt_nossd:
btrfs_set_and_info(root, NOSSD, btrfs_set_and_info(info, NOSSD,
"not using ssd allocation scheme"); "not using ssd allocation scheme");
btrfs_clear_opt(info->mount_opt, SSD); btrfs_clear_opt(info->mount_opt, SSD);
break; break;
case Opt_barrier: case Opt_barrier:
btrfs_clear_and_info(root, NOBARRIER, btrfs_clear_and_info(info, NOBARRIER,
"turning on barriers"); "turning on barriers");
break; break;
case Opt_nobarrier: case Opt_nobarrier:
btrfs_set_and_info(root, NOBARRIER, btrfs_set_and_info(info, NOBARRIER,
"turning off barriers"); "turning off barriers");
break; break;
case Opt_thread_pool: case Opt_thread_pool:
@ -626,24 +627,24 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
root->fs_info->sb->s_flags &= ~MS_POSIXACL; root->fs_info->sb->s_flags &= ~MS_POSIXACL;
break; break;
case Opt_notreelog: case Opt_notreelog:
btrfs_set_and_info(root, NOTREELOG, btrfs_set_and_info(info, NOTREELOG,
"disabling tree log"); "disabling tree log");
break; break;
case Opt_treelog: case Opt_treelog:
btrfs_clear_and_info(root, NOTREELOG, btrfs_clear_and_info(info, NOTREELOG,
"enabling tree log"); "enabling tree log");
break; break;
case Opt_norecovery: case Opt_norecovery:
case Opt_nologreplay: case Opt_nologreplay:
btrfs_set_and_info(root, NOLOGREPLAY, btrfs_set_and_info(info, NOLOGREPLAY,
"disabling log replay at mount time"); "disabling log replay at mount time");
break; break;
case Opt_flushoncommit: case Opt_flushoncommit:
btrfs_set_and_info(root, FLUSHONCOMMIT, btrfs_set_and_info(info, FLUSHONCOMMIT,
"turning on flush-on-commit"); "turning on flush-on-commit");
break; break;
case Opt_noflushoncommit: case Opt_noflushoncommit:
btrfs_clear_and_info(root, FLUSHONCOMMIT, btrfs_clear_and_info(info, FLUSHONCOMMIT,
"turning off flush-on-commit"); "turning off flush-on-commit");
break; break;
case Opt_ratio: case Opt_ratio:
@ -660,11 +661,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
} }
break; break;
case Opt_discard: case Opt_discard:
btrfs_set_and_info(root, DISCARD, btrfs_set_and_info(info, DISCARD,
"turning on discard"); "turning on discard");
break; break;
case Opt_nodiscard: case Opt_nodiscard:
btrfs_clear_and_info(root, DISCARD, btrfs_clear_and_info(info, DISCARD,
"turning off discard"); "turning off discard");
break; break;
case Opt_space_cache: case Opt_space_cache:
@ -673,12 +674,13 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
strcmp(args[0].from, "v1") == 0) { strcmp(args[0].from, "v1") == 0) {
btrfs_clear_opt(root->fs_info->mount_opt, btrfs_clear_opt(root->fs_info->mount_opt,
FREE_SPACE_TREE); FREE_SPACE_TREE);
btrfs_set_and_info(root, SPACE_CACHE, btrfs_set_and_info(info, SPACE_CACHE,
"enabling disk space caching"); "enabling disk space caching");
} else if (strcmp(args[0].from, "v2") == 0) { } else if (strcmp(args[0].from, "v2") == 0) {
btrfs_clear_opt(root->fs_info->mount_opt, btrfs_clear_opt(root->fs_info->mount_opt,
SPACE_CACHE); SPACE_CACHE);
btrfs_set_and_info(root, FREE_SPACE_TREE, btrfs_set_and_info(info,
FREE_SPACE_TREE,
"enabling free space tree"); "enabling free space tree");
} else { } else {
ret = -EINVAL; ret = -EINVAL;
@ -689,12 +691,14 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE); btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
break; break;
case Opt_no_space_cache: case Opt_no_space_cache:
if (btrfs_test_opt(root, SPACE_CACHE)) { if (btrfs_test_opt(info, SPACE_CACHE)) {
btrfs_clear_and_info(root, SPACE_CACHE, btrfs_clear_and_info(info,
SPACE_CACHE,
"disabling disk space caching"); "disabling disk space caching");
} }
if (btrfs_test_opt(root, FREE_SPACE_TREE)) { if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
btrfs_clear_and_info(root, FREE_SPACE_TREE, btrfs_clear_and_info(info,
FREE_SPACE_TREE,
"disabling free space tree"); "disabling free space tree");
} }
break; break;
@ -707,7 +711,7 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
"disabling inode map caching"); "disabling inode map caching");
break; break;
case Opt_clear_cache: case Opt_clear_cache:
btrfs_set_and_info(root, CLEAR_CACHE, btrfs_set_and_info(info, CLEAR_CACHE,
"force clearing of disk cache"); "force clearing of disk cache");
break; break;
case Opt_user_subvol_rm_allowed: case Opt_user_subvol_rm_allowed:
@ -720,11 +724,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options,
btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG); btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
break; break;
case Opt_defrag: case Opt_defrag:
btrfs_set_and_info(root, AUTO_DEFRAG, btrfs_set_and_info(info, AUTO_DEFRAG,
"enabling auto defrag"); "enabling auto defrag");
break; break;
case Opt_nodefrag: case Opt_nodefrag:
btrfs_clear_and_info(root, AUTO_DEFRAG, btrfs_clear_and_info(info, AUTO_DEFRAG,
"disabling auto defrag"); "disabling auto defrag");
break; break;
case Opt_recovery: case Opt_recovery:
@ -832,22 +836,22 @@ check:
/* /*
* Extra check for current option against current flag * Extra check for current option against current flag
*/ */
if (btrfs_test_opt(root, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) { if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) {
btrfs_err(root->fs_info, btrfs_err(root->fs_info,
"nologreplay must be used with ro mount option"); "nologreplay must be used with ro mount option");
ret = -EINVAL; ret = -EINVAL;
} }
out: out:
if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE) && if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE) &&
!btrfs_test_opt(root, FREE_SPACE_TREE) && !btrfs_test_opt(info, FREE_SPACE_TREE) &&
!btrfs_test_opt(root, CLEAR_CACHE)) { !btrfs_test_opt(info, CLEAR_CACHE)) {
btrfs_err(root->fs_info, "cannot disable free space tree"); btrfs_err(root->fs_info, "cannot disable free space tree");
ret = -EINVAL; ret = -EINVAL;
} }
if (!ret && btrfs_test_opt(root, SPACE_CACHE)) if (!ret && btrfs_test_opt(info, SPACE_CACHE))
btrfs_info(root->fs_info, "disk space caching is enabled"); btrfs_info(root->fs_info, "disk space caching is enabled");
if (!ret && btrfs_test_opt(root, FREE_SPACE_TREE)) if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
btrfs_info(root->fs_info, "using free space tree"); btrfs_info(root->fs_info, "using free space tree");
kfree(orig); kfree(orig);
return ret; return ret;
@ -1214,13 +1218,13 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
struct btrfs_root *root = info->tree_root; struct btrfs_root *root = info->tree_root;
char *compress_type; char *compress_type;
if (btrfs_test_opt(root, DEGRADED)) if (btrfs_test_opt(info, DEGRADED))
seq_puts(seq, ",degraded"); seq_puts(seq, ",degraded");
if (btrfs_test_opt(root, NODATASUM)) if (btrfs_test_opt(info, NODATASUM))
seq_puts(seq, ",nodatasum"); seq_puts(seq, ",nodatasum");
if (btrfs_test_opt(root, NODATACOW)) if (btrfs_test_opt(info, NODATACOW))
seq_puts(seq, ",nodatacow"); seq_puts(seq, ",nodatacow");
if (btrfs_test_opt(root, NOBARRIER)) if (btrfs_test_opt(info, NOBARRIER))
seq_puts(seq, ",nobarrier"); seq_puts(seq, ",nobarrier");
if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE) if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
seq_printf(seq, ",max_inline=%llu", info->max_inline); seq_printf(seq, ",max_inline=%llu", info->max_inline);
@ -1229,56 +1233,56 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
if (info->thread_pool_size != min_t(unsigned long, if (info->thread_pool_size != min_t(unsigned long,
num_online_cpus() + 2, 8)) num_online_cpus() + 2, 8))
seq_printf(seq, ",thread_pool=%d", info->thread_pool_size); seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
if (btrfs_test_opt(root, COMPRESS)) { if (btrfs_test_opt(info, COMPRESS)) {
if (info->compress_type == BTRFS_COMPRESS_ZLIB) if (info->compress_type == BTRFS_COMPRESS_ZLIB)
compress_type = "zlib"; compress_type = "zlib";
else else
compress_type = "lzo"; compress_type = "lzo";
if (btrfs_test_opt(root, FORCE_COMPRESS)) if (btrfs_test_opt(info, FORCE_COMPRESS))
seq_printf(seq, ",compress-force=%s", compress_type); seq_printf(seq, ",compress-force=%s", compress_type);
else else
seq_printf(seq, ",compress=%s", compress_type); seq_printf(seq, ",compress=%s", compress_type);
} }
if (btrfs_test_opt(root, NOSSD)) if (btrfs_test_opt(info, NOSSD))
seq_puts(seq, ",nossd"); seq_puts(seq, ",nossd");
if (btrfs_test_opt(root, SSD_SPREAD)) if (btrfs_test_opt(info, SSD_SPREAD))
seq_puts(seq, ",ssd_spread"); seq_puts(seq, ",ssd_spread");
else if (btrfs_test_opt(root, SSD)) else if (btrfs_test_opt(info, SSD))
seq_puts(seq, ",ssd"); seq_puts(seq, ",ssd");
if (btrfs_test_opt(root, NOTREELOG)) if (btrfs_test_opt(info, NOTREELOG))
seq_puts(seq, ",notreelog"); seq_puts(seq, ",notreelog");
if (btrfs_test_opt(root, NOLOGREPLAY)) if (btrfs_test_opt(info, NOLOGREPLAY))
seq_puts(seq, ",nologreplay"); seq_puts(seq, ",nologreplay");
if (btrfs_test_opt(root, FLUSHONCOMMIT)) if (btrfs_test_opt(info, FLUSHONCOMMIT))
seq_puts(seq, ",flushoncommit"); seq_puts(seq, ",flushoncommit");
if (btrfs_test_opt(root, DISCARD)) if (btrfs_test_opt(info, DISCARD))
seq_puts(seq, ",discard"); seq_puts(seq, ",discard");
if (!(root->fs_info->sb->s_flags & MS_POSIXACL)) if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
seq_puts(seq, ",noacl"); seq_puts(seq, ",noacl");
if (btrfs_test_opt(root, SPACE_CACHE)) if (btrfs_test_opt(info, SPACE_CACHE))
seq_puts(seq, ",space_cache"); seq_puts(seq, ",space_cache");
else if (btrfs_test_opt(root, FREE_SPACE_TREE)) else if (btrfs_test_opt(info, FREE_SPACE_TREE))
seq_puts(seq, ",space_cache=v2"); seq_puts(seq, ",space_cache=v2");
else else
seq_puts(seq, ",nospace_cache"); seq_puts(seq, ",nospace_cache");
if (btrfs_test_opt(root, RESCAN_UUID_TREE)) if (btrfs_test_opt(info, RESCAN_UUID_TREE))
seq_puts(seq, ",rescan_uuid_tree"); seq_puts(seq, ",rescan_uuid_tree");
if (btrfs_test_opt(root, CLEAR_CACHE)) if (btrfs_test_opt(info, CLEAR_CACHE))
seq_puts(seq, ",clear_cache"); seq_puts(seq, ",clear_cache");
if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED)) if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))
seq_puts(seq, ",user_subvol_rm_allowed"); seq_puts(seq, ",user_subvol_rm_allowed");
if (btrfs_test_opt(root, ENOSPC_DEBUG)) if (btrfs_test_opt(info, ENOSPC_DEBUG))
seq_puts(seq, ",enospc_debug"); seq_puts(seq, ",enospc_debug");
if (btrfs_test_opt(root, AUTO_DEFRAG)) if (btrfs_test_opt(info, AUTO_DEFRAG))
seq_puts(seq, ",autodefrag"); seq_puts(seq, ",autodefrag");
if (btrfs_test_opt(root, INODE_MAP_CACHE)) if (btrfs_test_opt(info, INODE_MAP_CACHE))
seq_puts(seq, ",inode_cache"); seq_puts(seq, ",inode_cache");
if (btrfs_test_opt(root, SKIP_BALANCE)) if (btrfs_test_opt(info, SKIP_BALANCE))
seq_puts(seq, ",skip_balance"); seq_puts(seq, ",skip_balance");
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA)) if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
seq_puts(seq, ",check_int_data"); seq_puts(seq, ",check_int_data");
else if (btrfs_test_opt(root, CHECK_INTEGRITY)) else if (btrfs_test_opt(info, CHECK_INTEGRITY))
seq_puts(seq, ",check_int"); seq_puts(seq, ",check_int");
if (info->check_integrity_print_mask) if (info->check_integrity_print_mask)
seq_printf(seq, ",check_int_print_mask=%d", seq_printf(seq, ",check_int_print_mask=%d",
@ -1287,14 +1291,14 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
if (info->metadata_ratio) if (info->metadata_ratio)
seq_printf(seq, ",metadata_ratio=%d", seq_printf(seq, ",metadata_ratio=%d",
info->metadata_ratio); info->metadata_ratio);
if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR)) if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))
seq_puts(seq, ",fatal_errors=panic"); seq_puts(seq, ",fatal_errors=panic");
if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL) if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
seq_printf(seq, ",commit=%d", info->commit_interval); seq_printf(seq, ",commit=%d", info->commit_interval);
#ifdef CONFIG_BTRFS_DEBUG #ifdef CONFIG_BTRFS_DEBUG
if (btrfs_test_opt(root, FRAGMENT_DATA)) if (btrfs_test_opt(info, FRAGMENT_DATA))
seq_puts(seq, ",fragment=data"); seq_puts(seq, ",fragment=data");
if (btrfs_test_opt(root, FRAGMENT_METADATA)) if (btrfs_test_opt(info, FRAGMENT_METADATA))
seq_puts(seq, ",fragment=metadata"); seq_puts(seq, ",fragment=metadata");
#endif #endif
seq_printf(seq, ",subvolid=%llu", seq_printf(seq, ",subvolid=%llu",

6
fs/btrfs/transaction.c
View file

@ -1709,7 +1709,7 @@ static void update_super_roots(struct btrfs_root *root)
super->root = root_item->bytenr; super->root = root_item->bytenr;
super->generation = root_item->generation; super->generation = root_item->generation;
super->root_level = root_item->level; super->root_level = root_item->level;
if (btrfs_test_opt(root, SPACE_CACHE)) if (btrfs_test_opt(root->fs_info, SPACE_CACHE))
super->cache_generation = root_item->generation; super->cache_generation = root_item->generation;
if (root->fs_info->update_uuid_tree_gen) if (root->fs_info->update_uuid_tree_gen)
super->uuid_tree_generation = root_item->generation; super->uuid_tree_generation = root_item->generation;
@ -1895,14 +1895,14 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans,
static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
{ {
if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))
return btrfs_start_delalloc_roots(fs_info, 1, -1); return btrfs_start_delalloc_roots(fs_info, 1, -1);
return 0; return 0;
} }
static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
{ {
if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))
btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1); btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1);
} }

4
fs/btrfs/tree-log.c
View file

@ -2757,7 +2757,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
while (1) { while (1) {
int batch = atomic_read(&root->log_batch); int batch = atomic_read(&root->log_batch);
/* when we're on an ssd, just kick the log commit out */ /* when we're on an ssd, just kick the log commit out */
if (!btrfs_test_opt(root, SSD) && if (!btrfs_test_opt(root->fs_info, SSD) &&
test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) { test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
mutex_unlock(&root->log_mutex); mutex_unlock(&root->log_mutex);
schedule_timeout_uninterruptible(1); schedule_timeout_uninterruptible(1);
@ -5305,7 +5305,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
sb = inode->i_sb; sb = inode->i_sb;
if (btrfs_test_opt(root, NOTREELOG)) { if (btrfs_test_opt(root->fs_info, NOTREELOG)) {
ret = 1; ret = 1;
goto end_no_trans; goto end_no_trans;
} }

11
fs/btrfs/volumes.c
View file

@ -3944,7 +3944,7 @@ int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
} }
spin_unlock(&fs_info->balance_lock); spin_unlock(&fs_info->balance_lock);
if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) { if (btrfs_test_opt(fs_info, SKIP_BALANCE)) {
btrfs_info(fs_info, "force skipping balance"); btrfs_info(fs_info, "force skipping balance");
return 0; return 0;
} }
@ -6455,7 +6455,8 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
BTRFS_UUID_SIZE); BTRFS_UUID_SIZE);
map->stripes[i].dev = btrfs_find_device(root->fs_info, devid, map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
uuid, NULL); uuid, NULL);
if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) { if (!map->stripes[i].dev &&
!btrfs_test_opt(root->fs_info, DEGRADED)) {
free_extent_map(em); free_extent_map(em);
return -EIO; return -EIO;
} }
@ -6523,7 +6524,7 @@ static struct btrfs_fs_devices *open_seed_devices(struct btrfs_root *root,
fs_devices = find_fsid(fsid); fs_devices = find_fsid(fsid);
if (!fs_devices) { if (!fs_devices) {
if (!btrfs_test_opt(root, DEGRADED)) if (!btrfs_test_opt(root->fs_info, DEGRADED))
return ERR_PTR(-ENOENT); return ERR_PTR(-ENOENT);
fs_devices = alloc_fs_devices(fsid); fs_devices = alloc_fs_devices(fsid);
@ -6585,7 +6586,7 @@ static int read_one_dev(struct btrfs_root *root,
device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid); device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
if (!device) { if (!device) {
if (!btrfs_test_opt(root, DEGRADED)) if (!btrfs_test_opt(root->fs_info, DEGRADED))
return -EIO; return -EIO;
device = add_missing_dev(root, fs_devices, devid, dev_uuid); device = add_missing_dev(root, fs_devices, devid, dev_uuid);
@ -6594,7 +6595,7 @@ static int read_one_dev(struct btrfs_root *root,
btrfs_warn(root->fs_info, "devid %llu uuid %pU missing", btrfs_warn(root->fs_info, "devid %llu uuid %pU missing",
devid, dev_uuid); devid, dev_uuid);
} else { } else {
if (!device->bdev && !btrfs_test_opt(root, DEGRADED)) if (!device->bdev && !btrfs_test_opt(root->fs_info, DEGRADED))
return -EIO; return -EIO;
if(!device->bdev && !device->missing) { if(!device->bdev && !device->missing) {