btrfs: convert to the new mount API
Subsystems (2)
v2 cover btrfs: convert to the new mount API
v1->v2:
- Fixed up some nits and paste errors.
- Fixed build failure with !ZONED.
- Fixed accidentally dropping BINARY_MOUNTDATA flag.
- Added Reviewed-by's collected up to this point.
These have run through our CI a few times, they haven't introduced any regressions.
--- Original email ---
Hello,
These patches convert us to use the new mount API. Christian tried to do this a few months ago, but ran afoul of our preference to have a bunch of small changes. I started this series before I knew he had tried to convert us, so there's a fair bit that's different, but I did copy his approach for the remount bit. I've linked to the original patch where I took inspiration, Christian let me know if you want some other annotation for credit, I wasn't really sure the best way to do that.
There are a few preparatory patches in the beginning, and then cleanups at the end. I took each call back one at a time to try and make it as small as possible. The resulting code is less, but the diffstat shows more insertions that deletions. This is because there are some big comment blocks around some of the more subtle things that we're doing to hopefully make it more clear.
This is currently running through our CI. I thought it was fine last week but we had a bunch of new failures when I finished up the remount behavior. However today I discovered this was a regression in btrfs-progs, and I'm re-running the tests with the fixes. If anything major breaks in the CI I'll resend with fixes, but I'm pretty sure these patches will pass without issue.
I utilized __maybe_unused liberally to make sure everything compiled while applied. The only "big" patch is where I went and removed the old API. If requested I can break that up a bit more, but I didn't think it was necessary. I did make sure to keep it in its own patch, so the switch to the new mount API path only has things we need to support the new mount API, and then the next patch removes the old code. Thanks,
Josef
Christian Brauner (1):
fs: indicate request originates from old mount api
Josef Bacik (17):
btrfs: split out the mount option validation code into its own helper
btrfs: set default compress type at btrfs_init_fs_info time
btrfs: move space cache settings into open_ctree
btrfs: do not allow free space tree rebuild on extent tree v2
btrfs: split out ro->rw and rw->ro helpers into their own functions
btrfs: add a NOSPACECACHE mount option flag
btrfs: add fs_parameter definitions
btrfs: add parse_param callback for the new mount api
btrfs: add fs context handling functions
btrfs: add reconfigure callback for fs_context
btrfs: add get_tree callback for new mount API
btrfs: handle the ro->rw transition for mounting different subovls
btrfs: switch to the new mount API
btrfs: move the device specific mount options to super.c
btrfs: remove old mount API code
btrfs: move one shot mount option clearing to super.c
btrfs: set clear_cache if we use usebackuproot
fs/btrfs/disk-io.c | 76 +- fs/btrfs/disk-io.h | 1 - fs/btrfs/fs.h | 15 +- fs/btrfs/super.c | 2421 +++++++++++++++++++++++--------------------- fs/btrfs/super.h | 5 +- fs/btrfs/zoned.c | 16 +- fs/btrfs/zoned.h | 6 +- fs/namespace.c | 11 + 8 files changed, 1317 insertions(+), 1234 deletions(-)
Signature · 1 line
2.41.0
PATCH v2 1/18 fs: indicate request originates from old mount api
From: Christian Brauner <[email protected]>
We already communicate to filesystems when a remount request comes from the old mount api as some filesystems choose to implement different behavior in the new mount api than the old mount api to e.g., take the chance to fix significant api bugs. Allow the same for regular mount requests.
--- fs/namespace.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/namespace.c +11 -0
@@ -2873,7 +2873,12 @@ static int do_remount(struct path *path, int ms_flags, int sb_flags,if (IS_ERR (fc))return PTR_ERR (fc); +/* +* Indicate to the filesystem that the remount request is coming +* from the legacy mount system call. +*/ fc->oldapi = true; + err =parse_monolithic_mount_data (fc, data);if (!err) {down_write (&sb->s_umount);
@@ -3322,6 +3327,12 @@ static int do_new_mount(struct path *path, const char *fstype, int sb_flags,if (IS_ERR (fc))return PTR_ERR (fc); +/* +* Indicate to the filesystem that the mount request is coming +* from the legacy mount system call. +*/ + fc->oldapi = true; +if (subtype) err =vfs_parse_fs_string (fc,"subtype" , subtype,strlen (subtype));
Signature · 1 line
2.41.0
PATCH v2 2/18 btrfs: split out the mount option validation code into its own helper
In reply to Josef BacikWe're going to need to validate mount options after they're all parsed with the new mount api, split this code out into its own helper so we can use it when we swap over to the new mount api.
--- fs/btrfs/super.c | 64 ++++++++++++++++++++++++++---------------------- 1 file changed, 35 insertions(+), 29 deletions(-)
fs/btrfs/super.c +35 -29
@@ -233,6 +233,39 @@ static bool check_ro_option(struct btrfs_fs_info *fs_info, unsigned long opt,return false; } +static bool check_options (struct btrfs_fs_info *info,unsigned long flags) +{ +if (!(flags &SB_RDONLY ) && + (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" ))) +return false; + +if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,CLEAR_CACHE )) { +btrfs_err (info,"cannot disable free space tree" ); +return false; + } +if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE )) { +btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); +return false; + } + +if (btrfs_check_mountopts_zoned (info)) +return false; + +if (!test_bit (BTRFS_FS_STATE_REMOUNTING , &info->fs_state)) { +if (btrfs_test_opt (info,SPACE_CACHE )) +btrfs_info (info,"disk space caching is enabled" ); +if (btrfs_test_opt (info,FREE_SPACE_TREE )) +btrfs_info (info,"using free space tree" ); + } + +return true; +} +static int parse_rescue_options (struct btrfs_fs_info *info,const char *options) {char *opts;
@@ -311,7 +344,6 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,int saved_compress_level;bool saved_compress_force;int no_compress =0 ; -const bool remounting =test_bit (BTRFS_FS_STATE_REMOUNTING , &info->fs_state);if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ))btrfs_set_opt (info->mount_opt,FREE_SPACE_TREE );
@@ -330,7 +362,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,* against new flags */ if (!options) - goto check; + goto out;while ((p =strsep (&options,"," )) !=NULL ) {int token;
@@ -774,35 +806,9 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,break ; } } -check: -/* We're read-only, don't have to check. */ -if (new_flags &SB_RDONLY ) - goto out; - -if (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" )) - ret = -EINVAL ; out: -if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,CLEAR_CACHE )) { -btrfs_err (info,"cannot disable free space tree" ); +if (!ret && !check_options (info, new_flags)) ret = -EINVAL ; - } -if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE )) { -btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); - ret = -EINVAL ; - } -if (!ret) - ret =btrfs_check_mountopts_zoned (info); -if (!ret && !remounting) { -if (btrfs_test_opt (info,SPACE_CACHE )) -btrfs_info (info,"disk space caching is enabled" ); -if (btrfs_test_opt (info,FREE_SPACE_TREE )) -btrfs_info (info,"using free space tree" ); - }return ret; }
Signature · 1 line
2.41.0
PATCH v2 3/18 btrfs: set default compress type at btrfs_init_fs_info time
In reply to Josef BacikWith the new mount API we'll be setting our compression well before we call open_ctree. We don't want to overwrite our settings, so set the default in btrfs_init_fs_info instead of open_ctree.
--- fs/btrfs/disk-io.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
fs/btrfs/disk-io.c +3 -7
@@ -2790,6 +2790,9 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info) fs_info->sectorsize_bits =ilog2 (4096 ); fs_info->stripesize =4096 ; +/* Default compress algorithm when user does -o compress */ + fs_info->compress_type =BTRFS_COMPRESS_ZLIB ; + fs_info->max_extent_size =BTRFS_MAX_EXTENT_SIZE ;spin_lock_init (&fs_info->swapfile_pins_lock);
@@ -3271,13 +3274,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (btrfs_super_flags (disk_super) &BTRFS_SUPER_FLAG_ERROR )WRITE_ONCE (fs_info->fs_error, -EUCLEAN ); -/* -* In the long term, we'll store the compression type in the super -* block, and it'll be used for per file compression control. -*/ - fs_info->compress_type =BTRFS_COMPRESS_ZLIB ; - -/* Set up fs_info before parsing mount options */ nodesize =btrfs_super_nodesize (disk_super); sectorsize =btrfs_super_sectorsize (disk_super);
Signature · 1 line
2.41.0
PATCH v2 4/18 btrfs: move space cache settings into open_ctree
In reply to Josef BacikCurrently we pre-load the space cache settings in btrfs_parse_options, however when we switch to the new mount API the mount option parsing will happen before we have the super block loaded. Add a helper to set the appropriate options based on the fs settings, this will allow us to have consistent free space cache settings.
This also folds in the space cache related decisions we make for subpage sectorsize support, so all of this is done in one place.
--- fs/btrfs/disk-io.c | 17 ++++++----------- fs/btrfs/super.c | 44 +++++++++++++++++++++++++++++++------------- fs/btrfs/super.h | 1 + 3 files changed, 38 insertions(+), 24 deletions(-)
fs/btrfs/disk-io.c +6 -11
@@ -3287,6 +3287,12 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device fs_info->csums_per_leaf =BTRFS_MAX_ITEM_SIZE (fs_info) / fs_info->csum_size; fs_info->stripesize = stripesize; +/* +* Handle the space caching options appropriately now that we have the +* super loaded and validated. +*/ +btrfs_set_free_space_cache_settings (fs_info); + ret =btrfs_parse_options (fs_info, options, sb->s_flags);if (ret) goto fail_alloc;
@@ -3298,17 +3304,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (sectorsize <PAGE_SIZE ) {struct btrfs_subpage_info *subpage_info; -/* -* V1 space cache has some hardcoded PAGE_SIZE usage, and is -* going to be deprecated. -* -* Force to use v2 cache for subpage case. -*/ -btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); -btrfs_set_and_info (fs_info,FREE_SPACE_TREE , -"forcing free space tree for sector size %u with page size %lu" , - sectorsize,PAGE_SIZE ); -btrfs_warn (fs_info,"read-write for sector size %u with page size %lu is experimental" , sectorsize,PAGE_SIZE );
fs/btrfs/super.c +31 -13
63 lines not on this page · raw message
fs/btrfs/super.h +1 -0
@@ -8,6 +8,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,int btrfs_sync_fs (struct super_block *sb,int wait);char *btrfs_get_subvol_name_from_objectid (struct btrfs_fs_info *fs_info,u64 subvol_objectid); +void btrfs_set_free_space_cache_settings (struct btrfs_fs_info *fs_info);static inline struct btrfs_fs_info *btrfs_sb (struct super_block *sb) {
Signature · 1 line
2.41.0
PATCH v2 5/18 btrfs: do not allow free space tree rebuild on extent tree v2
In reply to Josef BacikWe currently don't allow these options to be set if we're extent tree v2 via the mount option parsing. However when we switch to the new mount API we'll no longer have the super block loaded, so won't be able to make this distinction at mount option parsing time. Address this by checking for extent tree v2 at the point where we make the decision to rebuild the free space tree.
--- fs/btrfs/disk-io.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/btrfs/disk-io.c +2 -1
@@ -2951,7 +2951,8 @@ int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)bool rebuild_free_space_tree = false;if (btrfs_test_opt (fs_info,CLEAR_CACHE ) && -btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) { +btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && + !btrfs_fs_incompat (fs_info,EXTENT_TREE_V2 )) { rebuild_free_space_tree = true; }else if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && !btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID )) {
Signature · 1 line
2.41.0
PATCH v2 6/18 btrfs: split out ro->rw and rw->ro helpers into their own functions
In reply to Josef BacikWhen we remount ro->rw or rw->ro we have some cleanup tasks that have to be managed. Split these out into their own function to make btrfs_remount smaller.
--- fs/btrfs/super.c | 233 ++++++++++++++++++++++++----------------------- 1 file changed, 120 insertions(+), 113 deletions(-)
fs/btrfs/super.c +120 -113
@@ -1659,6 +1659,119 @@ static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,btrfs_set_free_space_cache_v1_active (fs_info, cache_opt); } +static int btrfs_remount_rw (struct btrfs_fs_info *fs_info) +{ +int ret; + +if (BTRFS_FS_ERROR (fs_info)) { +btrfs_err (fs_info, +"Remounting read-write after error is not allowed" ); +return -EINVAL ; + } + +if (fs_info->fs_devices->rw_devices ==0 ) +return -EACCES ; + +if (!btrfs_check_rw_degradable (fs_info,NULL )) { +btrfs_warn (fs_info, +"too many missing devices, writable remount is not allowed" ); +return -EACCES ; + } + +if (btrfs_super_log_root (fs_info->super_copy) !=0 ) { +btrfs_warn (fs_info, +"mount required to replay tree-log, cannot remount read-write" ); +return -EINVAL ; + } + +/* +* NOTE: when remounting with a change that does writes, don't put it +* anywhere above this point, as we are not sure to be safe to write +* until we pass the above checks. +*/ + ret =btrfs_start_pre_rw_mount (fs_info); +if (ret) +return ret; + +btrfs_clear_sb_rdonly (fs_info->sb); + +set_bit (BTRFS_FS_OPEN , &fs_info->flags); + +/* +* If we've gone from readonly -> read/write, we need to get our +* sync/async discard lists in the right state. +*/ +btrfs_discard_resume (fs_info); + +return 0 ; +} + +static int btrfs_remount_ro (struct btrfs_fs_info *fs_info) +{ +/* +* this also happens on 'umount -rf' or on shutdown, when +* the filesystem is busy. +*/ +cancel_work_sync (&fs_info->async_reclaim_work); +cancel_work_sync (&fs_info->async_data_reclaim_work); + +btrfs_discard_cleanup (fs_info); + +/* wait for the uuid_scan task to finish */ +down (&fs_info->uuid_tree_rescan_sem); +/* avoid complains from lockdep et al. */ +up (&fs_info->uuid_tree_rescan_sem); + +btrfs_set_sb_rdonly (fs_info->sb); + +/* +* Setting SB_RDONLY will put the cleaner thread to +* sleep at the next loop if it's already active. +* If it's already asleep, we'll leave unused block +* groups on disk until we're mounted read-write again +* unless we clean them up here. +*/ +btrfs_delete_unused_bgs (fs_info); + +/* +* The cleaner task could be already running before we set the +* flag BTRFS_FS_STATE_RO (and SB_RDONLY in the superblock). +* We must make sure that after we finish the remount, i.e. after +* we call btrfs_commit_super(), the cleaner can no longer start +* a transaction - either because it was dropping a dead root, +* running delayed iputs or deleting an unused block group (the +* cleaner picked a block group from the list of unused block +* groups before we were able to in the previous call to +* btrfs_delete_unused_bgs()). +*/ +wait_on_bit (&fs_info->flags,BTRFS_FS_CLEANER_RUNNING , +TASK_UNINTERRUPTIBLE ); + +/* +* We've set the superblock to RO mode, so we might have made +* the cleaner task sleep without running all pending delayed +* iputs. Go through all the delayed iputs here, so that if an +* unmount happens without remounting RW we don't end up at +* finishing close_ctree() with a non-empty list of delayed +* iputs. +*/ +btrfs_run_delayed_iputs (fs_info); + +btrfs_dev_replace_suspend_for_unmount (fs_info); +btrfs_scrub_cancel (fs_info); +btrfs_pause_balance (fs_info); + +/* +* Pause the qgroup rescan worker if it is running. We don't want +* it to be still running after we are in RO mode, as after that, +* by the time we unmount, it might have left a transaction open, +* so we would leak the transaction and/or crash. +*/ +btrfs_qgroup_wait_for_completion (fs_info, false); + +return btrfs_commit_super (fs_info); +} +static int btrfs_remount (struct super_block *sb,int *flags,char *data) {struct btrfs_fs_info *fs_info =btrfs_sb (sb);
@@ -1712,120 +1825,14 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) } } -if ((bool )(*flags &SB_RDONLY ) ==sb_rdonly (sb)) - goto out; + ret =0 ; +if (!sb_rdonly (sb) && (*flags &SB_RDONLY )) + ret =btrfs_remount_ro (fs_info); +else if (sb_rdonly (sb) && !(*flags &SB_RDONLY )) + ret =btrfs_remount_rw (fs_info); +if (ret) + goto restore; -if (*flags &SB_RDONLY ) { -/* -* this also happens on 'umount -rf' or on shutdown, when -* the filesystem is busy. -*/ -cancel_work_sync (&fs_info->async_reclaim_work); -cancel_work_sync (&fs_info->async_data_reclaim_work); - -btrfs_discard_cleanup (fs_info); - -/* wait for the uuid_scan task to finish */ -down (&fs_info->uuid_tree_rescan_sem); -/* avoid complains from lockdep et al. */ -up (&fs_info->uuid_tree_rescan_sem); - -btrfs_set_sb_rdonly (sb); - -/* -* Setting SB_RDONLY will put the cleaner thread to -* sleep at the next loop if it's already active. -* If it's already asleep, we'll leave unused block -* groups on disk until we're mounted read-write again -* unless we clean them up here. -*/ -btrfs_delete_unused_bgs (fs_info); - -/* -* The cleaner task could be already running before we set the -* flag BTRFS_FS_STATE_RO (and SB_RDONLY in the superblock). -* We must make sure that after we finish the remount, i.e. after -* we call btrfs_commit_super(), the cleaner can no longer start -* a transaction - either because it was dropping a dead root, -* running delayed iputs or deleting an unused block group (the -* cleaner picked a block group from the list of unused block -* groups before we were able to in the previous call to -* btrfs_delete_unused_bgs()). -*/ -wait_on_bit (&fs_info->flags,BTRFS_FS_CLEANER_RUNNING , -TASK_UNINTERRUPTIBLE ); - -/* -* We've set the superblock to RO mode, so we might have made -* the cleaner task sleep without running all pending delayed -* iputs. Go through all the delayed iputs here, so that if an -* unmount happens without remounting RW we don't end up at -* finishing close_ctree() with a non-empty list of delayed -* iputs. -*/ -btrfs_run_delayed_iputs (fs_info); - -btrfs_dev_replace_suspend_for_unmount (fs_info); -btrfs_scrub_cancel (fs_info); -btrfs_pause_balance (fs_info); - -/* -* Pause the qgroup rescan worker if it is running. We don't want -* it to be still running after we are in RO mode, as after that, -* by the time we unmount, it might have left a transaction open, -* so we would leak the transaction and/or crash. -*/ -btrfs_qgroup_wait_for_completion (fs_info, false); - - ret =btrfs_commit_super (fs_info); -if (ret) - goto restore; - }else { -if (BTRFS_FS_ERROR (fs_info)) { -btrfs_err (fs_info, -"Remounting read-write after error is not allowed" ); - ret = -EINVAL ; - goto restore; - } -if (fs_info->fs_devices->rw_devices ==0 ) { - ret = -EACCES ; - goto restore; - } - -if (!btrfs_check_rw_degradable (fs_info,NULL )) { -btrfs_warn (fs_info, -"too many missing devices, writable remount is not allowed" ); - ret = -EACCES ; - goto restore; - } - -if (btrfs_super_log_root (fs_info->super_copy) !=0 ) { -btrfs_warn (fs_info, -"mount required to replay tree-log, cannot remount read-write" ); - ret = -EINVAL ; - goto restore; - } - -/* -* NOTE: when remounting with a change that does writes, don't -* put it anywhere above this point, as we are not sure to be -* safe to write until we pass the above checks. -*/ - ret =btrfs_start_pre_rw_mount (fs_info); -if (ret) - goto restore; - -btrfs_clear_sb_rdonly (sb); - -set_bit (BTRFS_FS_OPEN , &fs_info->flags); - -/* -* If we've gone from readonly -> read/write, we need to get -* our sync/async discard lists in the right state. -*/ -btrfs_discard_resume (fs_info); - } -out:/* * We need to set SB_I_VERSION here otherwise it'll get cleared by VFS, * since the absence of the flag means it can be toggled off by remount.
Signature · 1 line
2.41.0
PATCH v2 7/18 btrfs: add a NOSPACECACHE mount option flag
In reply to Josef BacikWith the old mount API we'd pre-populate the mount options with the space cache settings of the file system, and then the user toggled them on or off with the mount options. When we switch to the new mount API the mount options will be set before we get into opening the file system, so we need a flag to indicate that the user explicitly asked for -o nospace_cache so we can make the appropriate changes after the fact.
--- fs/btrfs/disk-io.c | 1 + fs/btrfs/fs.h | 1 + 2 files changed, 2 insertions(+)
fs/btrfs/disk-io.c +1 -0
@@ -2938,6 +2938,7 @@ void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info) {btrfs_clear_opt (fs_info->mount_opt,USEBACKUPROOT );btrfs_clear_opt (fs_info->mount_opt,CLEAR_CACHE ); +btrfs_clear_opt (fs_info->mount_opt,NOSPACECACHE ); }/*
fs/btrfs/fs.h +1 -0
@@ -188,6 +188,7 @@ enum {BTRFS_MOUNT_IGNOREBADROOTS = (1UL <<27 ),BTRFS_MOUNT_IGNOREDATACSUMS = (1UL <<28 ),BTRFS_MOUNT_NODISCARD = (1UL <<29 ), + BTRFS_MOUNT_NOSPACECACHE = (1UL << 30), };/*
Signature · 1 line
2.41.0
PATCH v2 8/18 btrfs: add fs_parameter definitions
In reply to Josef BacikIn order to convert to the new mount api we have to change how we do the mount option parsing. For now we're going to duplicate these helpers to make it easier to follow, and then remove the old code once everything is in place. This patch contains the re-definiton of all of our mount options into the new fs_parameter_spec format.
--- fs/btrfs/super.c | 128 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 127 insertions(+), 1 deletion(-)
fs/btrfs/super.c +127 -1
@@ -27,6 +27,7 @@#include <linux/crc32c.h> #include <linux/btrfs.h> #include <linux/security.h> +#include <linux/fs_parser.h> #include "messages.h" #include "delayed-inode.h" #include "ctree.h"
@@ -132,7 +133,7 @@ enum {/* Debugging options */ Opt_enospc_debug, Opt_noenospc_debug,#ifdef CONFIG_BTRFS_DEBUG - Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, + Opt_fragment, Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, #endif #ifdef CONFIG_BTRFS_FS_REF_VERIFY Opt_ref_verify,
@@ -222,6 +223,131 @@ static const match_table_t rescue_tokens = { {Opt_err, NULL}, }; +enum { + Opt_fatal_errors_panic, + Opt_fatal_errors_bug, +}; + +static const struct constant_table btrfs_parameter_fatal_errors[] = { + {"panic" , Opt_fatal_errors_panic }, + {"bug" , Opt_fatal_errors_bug }, + {} +}; + +enum { + Opt_discard_sync, + Opt_discard_async, +}; + +static const struct constant_table btrfs_parameter_discard[] = { + {"sync" , Opt_discard_sync }, + {"async" , Opt_discard_async }, + {} +}; + +enum { + Opt_space_cache_v1, + Opt_space_cache_v2, +}; + +static const struct constant_table btrfs_parameter_space_cache[] = { + {"v1" , Opt_space_cache_v1 }, + {"v2" , Opt_space_cache_v2 }, + {} +}; + +enum { + Opt_rescue_usebackuproot, + Opt_rescue_nologreplay, + Opt_rescue_ignorebadroots, + Opt_rescue_ignoredatacsums, + Opt_rescue_parameter_all, +}; + +static const struct constant_table btrfs_parameter_rescue[] = { + {"usebackuproot" , Opt_rescue_usebackuproot }, + {"nologreplay" , Opt_rescue_nologreplay }, + {"ignorebadroots" , Opt_rescue_ignorebadroots }, + {"ibadroots" , Opt_rescue_ignorebadroots }, + {"ignoredatacsums" , Opt_rescue_ignoredatacsums }, + {"idatacsums" , Opt_rescue_ignoredatacsums }, + {"all" , Opt_rescue_parameter_all }, + {} +}; + +#ifdef CONFIG_BTRFS_DEBUG +enum { + Opt_fragment_parameter_data, + Opt_fragment_parameter_metadata, + Opt_fragment_parameter_all, +}; + +static const struct constant_table btrfs_parameter_fragment[] = { + {"data" , Opt_fragment_parameter_data }, + {"metadata" , Opt_fragment_parameter_metadata }, + {"all" , Opt_fragment_parameter_all }, + {} +}; +#endif + +static const struct fs_parameter_spec btrfs_fs_parameters[]__maybe_unused = { +fsparam_flag_no ("acl" , Opt_acl), +fsparam_flag ("clear_cache" , Opt_clear_cache), +fsparam_u32 ("commit" , Opt_commit_interval), +fsparam_flag ("compress" , Opt_compress), +fsparam_string ("compress" , Opt_compress_type), +fsparam_flag ("compress-force" , Opt_compress_force), +fsparam_string ("compress-force" , Opt_compress_force_type), +fsparam_flag ("degraded" , Opt_degraded), +fsparam_string ("device" , Opt_device), +fsparam_enum ("fatal_errors" , Opt_fatal_errors, btrfs_parameter_fatal_errors), +fsparam_flag_no ("flushoncommit" , Opt_flushoncommit), +fsparam_flag_no ("inode_cache" , Opt_inode_cache), +fsparam_string ("max_inline" , Opt_max_inline), +fsparam_flag_no ("barrier" , Opt_barrier), +fsparam_flag_no ("datacow" , Opt_datacow), +fsparam_flag_no ("datasum" , Opt_datasum), +fsparam_flag_no ("autodefrag" , Opt_defrag), +fsparam_flag_no ("discard" , Opt_discard), +fsparam_enum ("discard" , Opt_discard_mode, btrfs_parameter_discard), +fsparam_u32 ("metadata_ratio" , Opt_ratio), +fsparam_flag ("rescan_uuid_tree" , Opt_rescan_uuid_tree), +fsparam_flag ("skip_balance" , Opt_skip_balance), +fsparam_flag_no ("space_cache" , Opt_space_cache), +fsparam_enum ("space_cache" , Opt_space_cache_version, btrfs_parameter_space_cache), +fsparam_flag_no ("ssd" , Opt_ssd), +fsparam_flag_no ("ssd_spread" , Opt_ssd_spread), +fsparam_string ("subvol" , Opt_subvol), +fsparam_flag ("subvol=" , Opt_subvol_empty), +fsparam_u64 ("subvolid" , Opt_subvolid), +fsparam_u32 ("thread_pool" , Opt_thread_pool), +fsparam_flag_no ("treelog" , Opt_treelog), +fsparam_flag ("user_subvol_rm_allowed" , Opt_user_subvol_rm_allowed), + +/* Rescue options */ +fsparam_enum ("rescue" , Opt_rescue, btrfs_parameter_rescue), +/* Deprecated, with alias rescue=nologreplay */ +__fsparam (NULL ,"nologreplay" , Opt_nologreplay, fs_param_deprecated, +NULL ), +/* Deprecated, with alias rescue=usebackuproot */ +__fsparam (NULL ,"usebackuproot" , Opt_usebackuproot, fs_param_deprecated, +NULL ), + +/* Deprecated options */ +__fsparam (NULL ,"recovery" , Opt_recovery, + fs_param_neg_with_no|fs_param_deprecated,NULL ), + +/* Debugging options */ +fsparam_flag_no ("enospc_debug" , Opt_enospc_debug), +#ifdef CONFIG_BTRFS_DEBUG +fsparam_enum ("fragment" , Opt_fragment, btrfs_parameter_fragment), +#endif +#ifdef CONFIG_BTRFS_FS_REF_VERIFY +fsparam_flag ("ref_verify" , Opt_ref_verify), +#endif + {} +}; +static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long opt,const char *opt_name) {
Signature · 1 line
2.41.0
PATCH v2 9/18 btrfs: add parse_param callback for the new mount api
In reply to Josef BacikThe parse_param callback handles one parameter at a time, take our existing mount option parsing loop and adjust it to handle one parameter at a time, and tie it into the fs_context_operations.
Create a btrfs_fs_context object that will store the various mount properties, we'll house this in fc->fs_private. This is necessary to separate because remounting will use ->reconfigure, and we'll get a new copy of the parsed parameters, so we can no longer directly mess with the fs_info in this stage.
In the future we'll add this to the btrfs_fs_info and update the users to use the new context object instead.
--- fs/btrfs/super.c | 390 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 390 insertions(+)
fs/btrfs/super.c +390 -0
@@ -84,6 +84,19 @@ static void btrfs_put_super(struct super_block *sb)close_ctree (btrfs_sb (sb)); } +/* Store the mount options related information. */ +struct btrfs_fs_context { +char *subvol_name; +u64 subvol_objectid; +u64 max_inline; +u32 commit_interval; +u32 metadata_ratio; +u32 thread_pool_size; +unsigned long mount_opt; +unsigned long compress_type:4 ; +unsigned int compress_level; +}; +enum { Opt_acl, Opt_noacl, Opt_clear_cache,
@@ -348,6 +361,379 @@ static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { {} }; +static int btrfs_parse_param (struct fs_context *fc, +struct fs_parameter *param) +{ +struct btrfs_fs_context *ctx = fc->fs_private; +struct fs_parse_result result; +int opt; + + opt =fs_parse (fc, btrfs_fs_parameters, param, &result); +if (opt <0 ) +return opt; + +switch (opt) { +case Opt_degraded: +btrfs_set_opt (ctx->mount_opt,DEGRADED ); +break ; +case Opt_subvol_empty: +/* +* This exists because we used to allow it on accident, so we're +* keeping it to maintain ABI. See +* 37becec95ac31b209eb1c8e096f1093a7db00f32. +*/ +break ; +case Opt_subvol: +kfree (ctx->subvol_name); + ctx->subvol_name =kstrdup (param->string,GFP_KERNEL ); +if (!ctx->subvol_name) +return -ENOMEM ; +break ; +case Opt_subvolid: + ctx->subvol_objectid = result.uint_64; + +/* subvoldi=0 means give me the original fs_tree. */ +if (!ctx->subvol_objectid) + ctx->subvol_objectid =BTRFS_FS_TREE_OBJECTID ; +break ; +case Opt_device: { +struct btrfs_device *device; +blk_mode_t mode =sb_open_mode (fc->sb_flags); + +mutex_lock (&uuid_mutex); + device =btrfs_scan_one_device (param->string, mode, false); +mutex_unlock (&uuid_mutex); +if (IS_ERR (device)) +return PTR_ERR (device); +break ; + } +case Opt_datasum: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + } +break ; +case Opt_datacow: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); +btrfs_set_opt (ctx->mount_opt,NODATACOW ); +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); + } +break ; +case Opt_compress_force: +case Opt_compress_force_type: +btrfs_set_opt (ctx->mount_opt,FORCE_COMPRESS ); + fallthrough; +case Opt_compress: +case Opt_compress_type: +if (opt == Opt_compress || + opt == Opt_compress_force || +strncmp (param->string,"zlib" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZLIB ; + ctx->compress_level =BTRFS_ZLIB_DEFAULT_LEVEL ; +/* +* args[0] contains uninitialized data since +* for these tokens we don't expect any +* parameter. +*/ +if (opt != Opt_compress && + opt != Opt_compress_force) + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZLIB , + param->string +4 ); +btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"lzo" ,3 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_LZO ; + ctx->compress_level =0 ; +btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"zstd" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZSTD ; + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZSTD , + param->string +4 ); +btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"no" ,2 ) ==0 ) { + ctx->compress_level =0 ; + ctx->compress_type =0 ; +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); + }else { +btrfs_err (NULL ,"unrecognized compression value %s" , + param->string); +return -EINVAL ; + } +break ; +case Opt_ssd: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSSD ); +btrfs_clear_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_ssd_spread: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_set_opt (ctx->mount_opt,SSD_SPREAD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_barrier: +if (result.negated) +btrfs_set_opt (ctx->mount_opt,NOBARRIER ); +else +btrfs_clear_opt (ctx->mount_opt,NOBARRIER ); +break ; +case Opt_thread_pool: +if (result.uint_32 ==0 ) { +btrfs_err (NULL ,"invalid value 0 for thread_pool" ); +return -EINVAL ; + } + ctx->thread_pool_size = result.uint_32; +break ; +case Opt_max_inline: + ctx->max_inline =memparse (param->string,NULL ); +break ; +case Opt_acl: +if (result.negated) { + fc->sb_flags &= ~SB_POSIXACL ; + }else { +#ifdef CONFIG_BTRFS_FS_POSIX_ACL + fc->sb_flags |=SB_POSIXACL ; +#else +btrfs_err (NULL ,"support for ACL not compiled in!" ); + ret = -EINVAL ; + goto out; +#endif + } +/* +* VFS limits the ability to toggle ACL on and off via remount, +* despite every file system allowing this. This seems to be an +* oversight since we all do, but it'll fail if we're +* remounting. So don't set the mask here, we'll check it in +* btrfs_reconfigure and do the toggling ourselves. +*/ +if (fc->purpose !=FS_CONTEXT_FOR_RECONFIGURE ) + fc->sb_flags_mask |=SB_POSIXACL ; +break ; +case Opt_treelog: +if (result.negated) +btrfs_set_opt (ctx->mount_opt,NOTREELOG ); +else +btrfs_clear_opt (ctx->mount_opt,NOTREELOG ); +break ; +case Opt_recovery: +/* +* -o recovery used to be an alias for usebackuproot, and then +* norecovery was an alias for nologreplay, hence the different +* behaviors for negated and not. +*/ +if (result.negated) { +btrfs_warn (NULL , +"'norecovery' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); + }else { +btrfs_warn (NULL , +"'recovery' is deprecated, use 'rescue=usebackuproot' instead" ); +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); + } +break ; +case Opt_nologreplay: +btrfs_warn (NULL , +"'nologreplay' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +case Opt_flushoncommit: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,FLUSHONCOMMIT ); +else +btrfs_set_opt (ctx->mount_opt,FLUSHONCOMMIT ); +break ; +case Opt_ratio: + ctx->metadata_ratio = result.uint_32; +break ; +case Opt_discard: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,NODISCARD ); + }else { +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); + } +break ; +case Opt_discard_mode: +switch (result.uint_32) { +case Opt_discard_sync: +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +break ; +case Opt_discard_async: +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_ASYNC ); +break ; +default : +btrfs_err (NULL ,"unrecognized discard mode value %s" , + param->key); +return -EINVAL ; + } +btrfs_clear_opt (ctx->mount_opt,NODISCARD ); +break ; +case Opt_space_cache: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSPACECACHE ); +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); + }else { +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); + } +break ; +case Opt_space_cache_version: +switch (result.uint_32) { +case Opt_space_cache_v1: +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +case Opt_space_cache_v2: +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_set_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +default : +btrfs_err (NULL ,"unrecognized space_cache value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_rescan_uuid_tree: +btrfs_set_opt (ctx->mount_opt,RESCAN_UUID_TREE ); +break ; +case Opt_inode_cache: +btrfs_warn (NULL , +"the 'inode_cache' option is deprecated and has no effect since 5.11" ); +break ; +case Opt_clear_cache: +btrfs_set_opt (ctx->mount_opt,CLEAR_CACHE ); +break ; +case Opt_user_subvol_rm_allowed: +btrfs_set_opt (ctx->mount_opt,USER_SUBVOL_RM_ALLOWED ); +break ; +case Opt_enospc_debug: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,ENOSPC_DEBUG ); +else +btrfs_set_opt (ctx->mount_opt,ENOSPC_DEBUG ); +break ; +case Opt_defrag: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,AUTO_DEFRAG ); +else +btrfs_set_opt (ctx->mount_opt,AUTO_DEFRAG ); +break ; +case Opt_usebackuproot: +btrfs_warn (NULL , +"'usebackuproot' is deprecated, use 'rescue=usebackuproot' instead" ); +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); +break ; +case Opt_skip_balance: +btrfs_set_opt (ctx->mount_opt,SKIP_BALANCE ); +break ; +case Opt_fatal_errors: +switch (result.uint_32) { +case Opt_fatal_errors_panic: +btrfs_set_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR ); +break ; +case Opt_fatal_errors_bug: +btrfs_clear_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR ); +break ; +default : +btrfs_err (NULL ,"unrecognized fatal_errors value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_commit_interval: + ctx->commit_interval = result.uint_32; +if (!ctx->commit_interval) + ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ; +break ; +case Opt_rescue: +switch (result.uint_32) { +case Opt_rescue_usebackuproot: +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); +break ; +case Opt_rescue_nologreplay: +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +case Opt_rescue_ignorebadroots: +btrfs_set_opt (ctx->mount_opt,IGNOREBADROOTS ); +break ; +case Opt_rescue_ignoredatacsums: +btrfs_set_opt (ctx->mount_opt,IGNOREDATACSUMS ); +break ; +case Opt_rescue_parameter_all: +btrfs_set_opt (ctx->mount_opt,IGNOREDATACSUMS ); +btrfs_set_opt (ctx->mount_opt,IGNOREBADROOTS ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +default : +btrfs_info (NULL ,"unrecognized rescue option '%s'" , + param->key); +return -EINVAL ; + } +break ; +#ifdef CONFIG_BTRFS_DEBUG +case Opt_fragment: +switch (result.uint_32) { +case Opt_fragment_parameter_all: +btrfs_set_opt (ctx->mount_opt,FRAGMENT_DATA ); +btrfs_set_opt (ctx->mount_opt,FRAGMENT_METADATA ); +break ; +case Opt_fragment_parameter_metadata: +btrfs_set_opt (ctx->mount_opt,FRAGMENT_METADATA ); +break ; +case Opt_fragment_parameter_data: +btrfs_set_opt (ctx->mount_opt,FRAGMENT_DATA ); +break ; +default : +btrfs_info (NULL ,"unrecognized fragment option '%s'" , + param->key); +return -EINVAL ; + } +break ; +#endif +#ifdef CONFIG_BTRFS_FS_REF_VERIFY +case Opt_ref_verify: +btrfs_set_opt (ctx->mount_opt,REF_VERIFY ); +break ; +#endif +default : +btrfs_err (NULL ,"unrecognized mount option '%s'" , param->key); +return -EINVAL ; + } + +return 0 ; +} +static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long opt,const char *opt_name) {
@@ -2255,6 +2641,10 @@ static void btrfs_kill_super(struct super_block *sb)btrfs_free_fs_info (fs_info); } +static const struct fs_context_operations btrfs_fs_context_ops__maybe_unused = { + .parse_param = btrfs_parse_param, +}; +static struct file_system_type btrfs_fs_type = { .owner =THIS_MODULE , .name ="btrfs" ,
Signature · 1 line
2.41.0
PATCH v2 10/18 btrfs: add fs context handling functions
In reply to Josef BacikWe are going to use the fs context to hold the mount options, so allocate the btrfs_fs_context when we're asked to init the fs context, and free it in the free callback.
--- fs/btrfs/super.c | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-)
fs/btrfs/super.c +35 -1
@@ -2641,10 +2641,44 @@ static void btrfs_kill_super(struct super_block *sb)btrfs_free_fs_info (fs_info); } -static const struct fs_context_operations btrfs_fs_context_ops__maybe_unused = { +static void btrfs_free_fs_context (struct fs_context *fc) +{ +struct btrfs_fs_context *ctx = fc->fs_private; + +if (!ctx) +return ; + +kfree (ctx->subvol_name); +kfree (ctx); +} + +static const struct fs_context_operations btrfs_fs_context_ops = { .parse_param = btrfs_parse_param, + .free = btrfs_free_fs_context, }; +static int __maybe_unused btrfs_init_fs_context (struct fs_context *fc) +{ +struct btrfs_fs_context *ctx; + + ctx =kzalloc (sizeof (struct btrfs_fs_context ),GFP_KERNEL ); +if (!ctx) +return -ENOMEM ; + + ctx->thread_pool_size = min_t(unsigned long, num_online_cpus() + 2, 8); + ctx->max_inline =BTRFS_DEFAULT_MAX_INLINE ; + ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ; + ctx->subvol_objectid =BTRFS_FS_TREE_OBJECTID ; +#ifndef CONFIG_BTRFS_FS_POSIX_ACL + ctx->noacl = true; +#endif + + fc->fs_private = ctx; + fc->ops = &btrfs_fs_context_ops; + +return 0 ; +} +static struct file_system_type btrfs_fs_type = { .owner =THIS_MODULE , .name ="btrfs" ,
Signature · 1 line
2.41.0
PATCH v2 11/18 btrfs: add reconfigure callback for fs_context
In reply to Josef BacikThis is what is used to remount the file system with the new mount API. Because the mount options are parsed separately and one at a time I've added a helper to emit the mount options after the fact once the mount is configured, this matches the dmesg output for what happens with the old mount API.
--- fs/btrfs/super.c | 243 +++++++++++++++++++++++++++++++++++++++++++---- fs/btrfs/zoned.c | 16 ++-- fs/btrfs/zoned.h | 6 +- 3 files changed, 236 insertions(+), 29 deletions(-)
fs/btrfs/super.c +222 -21
@@ -734,10 +734,11 @@ static int btrfs_parse_param(struct fs_context *fc,return 0 ; } -static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long opt, +static bool check_ro_option (struct btrfs_fs_info *fs_info, +unsigned long mount_opt,unsigned long opt,const char *opt_name) { -if (fs_info->mount_opt & opt) { +if (mount_opt & opt) {btrfs_err (fs_info,"%s must be used with ro mount option" , opt_name);return true;
@@ -745,33 +746,34 @@ static bool check_ro_option(struct btrfs_fs_info *fs_info, unsigned long opt,return false; } -static bool check_options (struct btrfs_fs_info *info,unsigned long flags) +static bool check_options (struct btrfs_fs_info *info,unsigned long *mount_opt, +unsigned long flags) {if (!(flags &SB_RDONLY ) && - (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" ))) + (check_ro_option (info, *mount_opt,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || +check_ro_option (info, *mount_opt,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || +check_ro_option (info, *mount_opt,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" )))return false;if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,CLEAR_CACHE )) { + !btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE ) && + !btrfs_raw_test_opt (*mount_opt,CLEAR_CACHE )) {btrfs_err (info,"cannot disable free space tree" );return false; }if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE )) { + !btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE )) {btrfs_err (info,"cannot disable free space tree with block-group-tree feature" );return false; } -if (btrfs_check_mountopts_zoned (info)) +if (btrfs_check_mountopts_zoned (info, mount_opt))return false;if (!test_bit (BTRFS_FS_STATE_REMOUNTING , &info->fs_state)) { -if (btrfs_test_opt (info,SPACE_CACHE )) +if (btrfs_raw_test_opt (*mount_opt,SPACE_CACHE ))btrfs_info (info,"disk space caching is enabled" ); -if (btrfs_test_opt (info,FREE_SPACE_TREE )) +if (btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE ))btrfs_info (info,"using free space tree" ); }
@@ -1337,7 +1339,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, } } out: -if (!ret && !check_options (info, new_flags)) +if (!ret && !check_options (info, &info->mount_opt, new_flags)) ret = -EINVAL ;return ret; }
@@ -2377,6 +2379,203 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)return ret; } +static void btrfs_ctx_to_info (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *ctx) +{ + fs_info->max_inline = ctx->max_inline; + fs_info->commit_interval = ctx->commit_interval; + fs_info->metadata_ratio = ctx->metadata_ratio; + fs_info->thread_pool_size = ctx->thread_pool_size; + fs_info->mount_opt = ctx->mount_opt; + fs_info->compress_type = ctx->compress_type; + fs_info->compress_level = ctx->compress_level; +} + +static void btrfs_info_to_ctx (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *ctx) +{ + ctx->max_inline = fs_info->max_inline; + ctx->commit_interval = fs_info->commit_interval; + ctx->metadata_ratio = fs_info->metadata_ratio; + ctx->thread_pool_size = fs_info->thread_pool_size; + ctx->mount_opt = fs_info->mount_opt; + ctx->compress_type = fs_info->compress_type; + ctx->compress_level = fs_info->compress_level; +} + +#define btrfs_info_if_set(fs_info, old_ctx, opt, fmt, args...) \ +do { \ + if ((!old_ctx || !btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ + btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ + btrfs_info(fs_info, fmt, ##args); \ +} while (0) + +#define btrfs_info_if_unset(fs_info, old_ctx, opt, fmt, args...) \ +do { \ + if ((old_ctx && btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ + !btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ + btrfs_info(fs_info, fmt, ##args); \ +} while (0) + +static void btrfs_emit_options (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *old_ctx) +{ +btrfs_info_if_set (fs_info, old_ctx,NODATASUM ,"setting nodatasum" ); +btrfs_info_if_set (fs_info, old_ctx,DEGRADED , +"allowing degraded mounts" ); +btrfs_info_if_set (fs_info, old_ctx,NODATASUM ,"setting nodatasum" ); +btrfs_info_if_set (fs_info, old_ctx,SSD ,"enabling ssd optimizations" ); +btrfs_info_if_set (fs_info, old_ctx,SSD_SPREAD , +"using spread ssd allocation scheme" ); +btrfs_info_if_set (fs_info, old_ctx,NOBARRIER ,"turning off barriers" ); +btrfs_info_if_set (fs_info, old_ctx,NOTREELOG ,"disabling tree log" ); +btrfs_info_if_set (fs_info, old_ctx,NOLOGREPLAY , +"disabling log replay at mount time" ); +btrfs_info_if_set (fs_info, old_ctx,FLUSHONCOMMIT , +"turning on flush-on-commit" ); +btrfs_info_if_set (fs_info, old_ctx,DISCARD_SYNC , +"turning on sync discard" ); +btrfs_info_if_set (fs_info, old_ctx,DISCARD_ASYNC , +"turning on async discard" ); +btrfs_info_if_set (fs_info, old_ctx,FREE_SPACE_TREE , +"enabling free space tree" ); +btrfs_info_if_set (fs_info, old_ctx,SPACE_CACHE , +"enabling disk space caching" ); +btrfs_info_if_set (fs_info, old_ctx,CLEAR_CACHE , +"force clearing of disk cache" ); +btrfs_info_if_set (fs_info, old_ctx,AUTO_DEFRAG , +"enabling auto defrag" ); +btrfs_info_if_set (fs_info, old_ctx,FRAGMENT_DATA , +"fragmenting data" ); +btrfs_info_if_set (fs_info, old_ctx,FRAGMENT_METADATA , +"fragmenting metadata" ); +btrfs_info_if_set (fs_info, old_ctx,REF_VERIFY , +"doing ref verification" ); +btrfs_info_if_set (fs_info, old_ctx,USEBACKUPROOT , +"trying to use backup root at mount time" ); +btrfs_info_if_set (fs_info, old_ctx,IGNOREBADROOTS , +"ignoring bad roots" ); +btrfs_info_if_set (fs_info, old_ctx,IGNOREDATACSUMS , +"ignoring data csums" ); + +btrfs_info_if_unset (fs_info, old_ctx,NODATACOW ,"setting datacow" ); +btrfs_info_if_unset (fs_info, old_ctx,SSD ,"not using ssd optimizations" ); +btrfs_info_if_unset (fs_info, old_ctx,SSD_SPREAD , +"not using spread ssd allocation scheme" ); +btrfs_info_if_unset (fs_info, old_ctx,NOBARRIER , +"turning off barriers" ); +btrfs_info_if_unset (fs_info, old_ctx,NOTREELOG ,"enabling tree log" ); +btrfs_info_if_unset (fs_info, old_ctx,SPACE_CACHE , +"disabling disk space caching" ); +btrfs_info_if_unset (fs_info, old_ctx,FREE_SPACE_TREE , +"disabling free space tree" ); +btrfs_info_if_unset (fs_info, old_ctx,AUTO_DEFRAG , +"disabling auto defrag" ); +btrfs_info_if_unset (fs_info, old_ctx,COMPRESS , +"use no compression" ); + +/* Did the compression settings change? */ +if (btrfs_test_opt (fs_info,COMPRESS ) && + (!old_ctx || + old_ctx->compress_type != fs_info->compress_type || + old_ctx->compress_level != fs_info->compress_level || + (!btrfs_raw_test_opt (old_ctx->mount_opt,FORCE_COMPRESS ) && +btrfs_raw_test_opt (fs_info->mount_opt,FORCE_COMPRESS )))) { +char *compress_type ="none" ; + +switch (fs_info->compress_type) { +case BTRFS_COMPRESS_ZLIB : + compress_type ="zlib" ; +break ; +case BTRFS_COMPRESS_LZO : + compress_type ="lzo" ; +break ; +case BTRFS_COMPRESS_ZSTD : + compress_type ="zstd" ; +break ; + } + +btrfs_info (fs_info,"%s %s compression, level %d" , +btrfs_test_opt (fs_info,FORCE_COMPRESS ) ?"force" :"use" , + compress_type, fs_info->compress_level); + } + +if (fs_info->max_inline !=BTRFS_DEFAULT_MAX_INLINE ) +btrfs_info (fs_info,"max_inline at %llu" , + fs_info->max_inline); +} + +static int btrfs_reconfigure (struct fs_context *fc) +{ +struct super_block *sb = fc->root->d_sb; +struct btrfs_fs_info *fs_info =btrfs_sb (sb); +struct btrfs_fs_context *ctx = fc->fs_private; +struct btrfs_fs_context old_ctx; +int ret =0 ; + +btrfs_info_to_ctx (fs_info, &old_ctx); + +sync_filesystem (sb); +set_bit (BTRFS_FS_STATE_REMOUNTING , &fs_info->fs_state); + +if (!check_options (fs_info, &ctx->mount_opt, fc->sb_flags)) +return -EINVAL ; + + ret =btrfs_check_features (fs_info, !(fc->sb_flags &SB_RDONLY )); +if (ret <0 ) +return ret; + +btrfs_ctx_to_info (fs_info, ctx); +btrfs_remount_begin (fs_info, old_ctx.mount_opt, fc->sb_flags); +btrfs_resize_thread_pool (fs_info, fs_info->thread_pool_size, + old_ctx.thread_pool_size); + +if ((bool )btrfs_test_opt (fs_info,FREE_SPACE_TREE ) != + (bool )btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && + (!sb_rdonly (sb) || (fc->sb_flags &SB_RDONLY ))) { +btrfs_warn (fs_info, +"remount supports changing free space tree only from ro to rw" ); +/* Make sure free space cache options match the state on disk */ +if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) { +btrfs_set_opt (fs_info->mount_opt,FREE_SPACE_TREE ); +btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); + } +if (btrfs_free_space_cache_v1_active (fs_info)) { +btrfs_clear_opt (fs_info->mount_opt,FREE_SPACE_TREE ); +btrfs_set_opt (fs_info->mount_opt,SPACE_CACHE ); + } + } + + ret =0 ; +if (!sb_rdonly (sb) && (fc->sb_flags &SB_RDONLY )) + ret =btrfs_remount_ro (fs_info); +else if (sb_rdonly (sb) && !(fc->sb_flags &SB_RDONLY )) + ret =btrfs_remount_rw (fs_info); +if (ret) + goto restore; + +/* +* If we set the mask during the parameter parsing vfs would reject the +* remount. Here we can set the mask and the value will be updated +* appropriately. +*/ +if ((fc->sb_flags &SB_POSIXACL ) != (sb->s_flags &SB_POSIXACL )) + fc->sb_flags_mask |=SB_POSIXACL ; + +btrfs_emit_options (fs_info, &old_ctx); +wake_up_process (fs_info->transaction_kthread); +btrfs_remount_cleanup (fs_info, old_ctx.mount_opt); +btrfs_clear_oneshot_options (fs_info); +clear_bit (BTRFS_FS_STATE_REMOUNTING , &fs_info->fs_state); + +return 0 ; +restore: +btrfs_ctx_to_info (fs_info, &old_ctx); +btrfs_remount_cleanup (fs_info, old_ctx.mount_opt); +clear_bit (BTRFS_FS_STATE_REMOUNTING , &fs_info->fs_state); +return ret; +} +/* Used to sort the devices by max_avail(descending sort) */ static int btrfs_cmp_device_free_bytes (const void *a,const void *b) {
@@ -2654,6 +2853,7 @@ static void btrfs_free_fs_context(struct fs_context *fc)static const struct fs_context_operations btrfs_fs_context_ops = { .parse_param = btrfs_parse_param, + .reconfigure = btrfs_reconfigure, .free = btrfs_free_fs_context, };
@@ -2665,17 +2865,18 @@ static int __maybe_unused btrfs_init_fs_context(struct fs_context *fc)if (!ctx)return -ENOMEM ; - ctx->thread_pool_size = min_t(unsigned long, num_online_cpus() + 2, 8); - ctx->max_inline =BTRFS_DEFAULT_MAX_INLINE ; - ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ; - ctx->subvol_objectid =BTRFS_FS_TREE_OBJECTID ; -#ifndef CONFIG_BTRFS_FS_POSIX_ACL - ctx->noacl = true; -#endif - fc->fs_private = ctx; fc->ops = &btrfs_fs_context_ops; +if (fc->purpose ==FS_CONTEXT_FOR_RECONFIGURE ) { +btrfs_info_to_ctx (btrfs_sb (fc->root->d_sb), ctx); + }else { + ctx->thread_pool_size = + min_t(unsigned long, num_online_cpus() + 2, 8); + ctx->max_inline =BTRFS_DEFAULT_MAX_INLINE ; + ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ; + } +return 0 ; }
fs/btrfs/zoned.c +10 -6
@@ -781,7 +781,7 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)* Check mount options here, because we might change fs_info->zoned * from fs_info->zone_size. */ - ret =btrfs_check_mountopts_zoned (fs_info); + ret =btrfs_check_mountopts_zoned (fs_info, &fs_info->mount_opt);if (ret)return ret;
@@ -789,7 +789,8 @@ int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)return 0 ; } -int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info) +int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info, +unsigned long *mount_opt) {if (!btrfs_is_zoned (info))return 0 ;
@@ -798,18 +799,21 @@ int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)* Space cache writing is not COWed. Disable that to avoid write errors * in sequential zones. */ -if (btrfs_test_opt (info,SPACE_CACHE )) { +if (btrfs_raw_test_opt (*mount_opt,SPACE_CACHE )) {btrfs_err (info,"zoned: space cache v1 is not supported" );return -EINVAL ; } -if (btrfs_test_opt (info,NODATACOW )) { +if (btrfs_raw_test_opt (*mount_opt,NODATACOW )) {btrfs_err (info,"zoned: NODATACOW not supported" );return -EINVAL ; } -btrfs_clear_and_info (info,DISCARD_ASYNC , -"zoned: async discard ignored and disabled for zoned mode" ); +if (btrfs_raw_test_opt (*mount_opt,DISCARD_ASYNC )) { +btrfs_info (info, +"zoned: async discard ignored and disabled for zoned mode" ); +btrfs_clear_opt (*mount_opt,DISCARD_ASYNC ); + }return 0 ; }
fs/btrfs/zoned.h +4 -2
@@ -45,7 +45,8 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache);void btrfs_destroy_dev_zone_info (struct btrfs_device *device);struct btrfs_zoned_device_info *btrfs_clone_dev_zone_info (struct btrfs_device *orig_dev);int btrfs_check_zoned_mode (struct btrfs_fs_info *fs_info); -int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info); +int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info, +unsigned long *mount_opt);int btrfs_sb_log_location_bdev (struct block_device *bdev,int mirror,int rw,u64 *bytenr_ret); int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw,
@@ -123,7 +124,8 @@ static inline int btrfs_check_zoned_mode(const struct btrfs_fs_info *fs_info)return -EOPNOTSUPP ; } -static inline int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info) +static inline int btrfs_check_mountopts_zoned (struct btrfs_fs_info *info, +unsigned long *mount_opt) {return 0 ; }
Signature · 1 line
2.41.0
PATCH v2 12/18 btrfs: add get_tree callback for new mount API
In reply to Josef BacikThis is the actual mounting callback for the new mount API. Implement this using our current fill super as a guideline, making the appropriate adjustments for the new mount API.
Our old mount operation had two fs_types, one to handle the actual opening, and the one that we called to handle the actual opening and then did the subvol lookup for returning the actual root dentry. This is mirrored here, but simply with different behaviors for ->get_tree. We use the existence of ->s_fs_info to tell which part we're in. The initial call allocates the fs_info, then call mount_fc() with a duplicated fc to do the actual open_ctree part. Then we take that vfsmount and use it to look up our subvolume that we're mounting and return that as our s_root. This idea was taken from Christians attempt to convert us to the new mount api.
References: https://lore.kernel.org/all/[email protected]/
--- fs/btrfs/super.c | 210 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 206 insertions(+), 4 deletions(-)
fs/btrfs/super.c +206 -4
@@ -95,6 +95,7 @@ struct btrfs_fs_context {unsigned long mount_opt; unsigned long compress_type:4;unsigned int compress_level; +refcount_t refs; };enum {
@@ -2833,6 +2834,181 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)return 0 ; } +static int btrfs_fc_test_super (struct super_block *s,struct fs_context *fc) +{ +struct btrfs_fs_info *p = fc->s_fs_info; +struct btrfs_fs_info *fs_info =btrfs_sb (s); + +return fs_info->fs_devices == p->fs_devices; +} + +static int btrfs_get_tree_super (struct fs_context *fc) +{ +struct btrfs_fs_info *fs_info = fc->s_fs_info; +struct btrfs_fs_context *ctx = fc->fs_private; +struct btrfs_fs_devices *fs_devices =NULL ; +struct block_device *bdev; +struct btrfs_device *device; +struct super_block *s; +blk_mode_t mode =sb_open_mode (fc->sb_flags); +int ret; + +btrfs_ctx_to_info (fs_info, ctx); +mutex_lock (&uuid_mutex); + +/* +* With 'true' passed to btrfs_scan_one_device() (mount time) we expect +* either a valid device or an error. +*/ + device =btrfs_scan_one_device (fc->source, mode, true); +ASSERT (device !=NULL ); +if (IS_ERR (device)) { +mutex_unlock (&uuid_mutex); +return PTR_ERR (device); + } + + fs_devices = device->fs_devices; + fs_info->fs_devices = fs_devices; + + ret =btrfs_open_devices (fs_devices, mode, &btrfs_fs_type); +mutex_unlock (&uuid_mutex); +if (ret) +return ret; + +if (!(fc->sb_flags &SB_RDONLY ) && fs_devices->rw_devices ==0 ) { + ret = -EACCES ; + goto error; + } + + bdev = fs_devices->latest_dev->bdev; + +/* +* If successful, this will transfer the fs_info into the super block, +* and fc->s_fs_info will be NULL. However if there's an existing +* super, we'll still have fc->s_fs_info populated. If we error +* completely out it'll be cleaned up when we drop the fs_context, +* otherwise it's tied to the lifetime of the super_block. +* +* Adding this comment because I was horribly confused about the error +* handling from here on out. +*/ + s =sget_fc (fc, btrfs_fc_test_super, set_anon_super_fc); +if (IS_ERR (s)) { + ret =PTR_ERR (s); + goto error; + } + +if (s->s_root) { +btrfs_close_devices (fs_devices); +if ((fc->sb_flags ^ s->s_flags) &SB_RDONLY ) + ret = -EBUSY ; + }else { +snprintf (s->s_id,sizeof (s->s_id),"%pg" , bdev); +shrinker_debugfs_rename (&s->s_shrink,"sb-btrfs:%s" , s->s_id); +btrfs_sb (s)->bdev_holder = &btrfs_fs_type; + ret =btrfs_fill_super (s, fs_devices,NULL ); + } + +if (ret) { +deactivate_locked_super (s); +return ret; + } + + fc->root =dget (s->s_root); +return 0 ; + +error: +btrfs_close_devices (fs_devices); +return ret; +} + +static int btrfs_get_tree_subvol (struct fs_context *fc) +{ +struct btrfs_fs_info *fs_info =NULL ; +struct btrfs_fs_context *ctx = fc->fs_private; +struct fs_context *dup_fc; +struct dentry *dentry; +struct vfsmount *mnt; + +/* +* Setup a dummy root and fs_info for test/set super. This is because +* we don't actually fill this stuff out until open_ctree, but we need +* then open_ctree will properly initialize the file system specific +* settings later. btrfs_init_fs_info initializes the static elements +* of the fs_info (locks and such) to make cleanup easier if we find a +* superblock with our given fs_devices later on at sget() time. +*/ + fs_info =kvzalloc (sizeof (struct btrfs_fs_info ),GFP_KERNEL ); +if (!fs_info) +return -ENOMEM ; + + fs_info->super_copy =kzalloc (BTRFS_SUPER_INFO_SIZE ,GFP_KERNEL ); + fs_info->super_for_commit =kzalloc (BTRFS_SUPER_INFO_SIZE ,GFP_KERNEL ); +if (!fs_info->super_copy || !fs_info->super_for_commit) { +btrfs_free_fs_info (fs_info); +return -ENOMEM ; + } +btrfs_init_fs_info (fs_info); + + dup_fc =vfs_dup_fs_context (fc); +if (IS_ERR (dup_fc)) { +btrfs_free_fs_info (fs_info); +return PTR_ERR (dup_fc); + } + +/* +* When we do the sget_fc this gets transferred to the sb, so we only +* need to set it on the dup_fc as this is what creates the super block. +*/ + dup_fc->s_fs_info = fs_info; + +/* +* We'll do the security settings in our btrfs_get_tree_super() mount +* loop, they were duplicated into dup_fc, we can drop the originals +* here. +*/ +security_free_mnt_opts (&fc->security); + fc->security =NULL ; + + mnt =fc_mount (dup_fc); +put_fs_context (dup_fc); +if (IS_ERR (mnt)) +return PTR_ERR (mnt); + +/* +* This free's ->subvol_name, because if it isn't set we have to +* allocate a buffer to hold the subvol_name, so we just drop our +* reference to it here. +*/ + dentry =mount_subvol (ctx->subvol_name, ctx->subvol_objectid, mnt); + ctx->subvol_name =NULL ; +if (IS_ERR (dentry)) +return PTR_ERR (dentry); + + fc->root = dentry; +return 0 ; +} + +static int btrfs_get_tree (struct fs_context *fc) +{ +/* +* Since we use mount_subtree to mount the default/specified subvol, we +* have to do mounts in two steps. +* +* First pass through we call btrfs_get_tree_subvol(), this is just a +* wrapper around fc_mount() to call back into here again, and this time +* we'll call btrfs_get_tree_super(). This will do the open_ctree() and +* everything to open the devices and file system. Then we return back +* with a fully constructed vfsmount in btrfs_get_tree_subvol(), and +* from there we can do our mount_subvol() call, which will lookup +* whichever subvol we're mounting and setup this fc with the +* appropriate dentry for the subvol. +*/ +if (fc->s_fs_info) +return btrfs_get_tree_super (fc); +return btrfs_get_tree_subvol (fc); +} +static void btrfs_kill_super (struct super_block *sb) {struct btrfs_fs_info *fs_info =btrfs_sb (sb);
@@ -2843,17 +3019,42 @@ static void btrfs_kill_super(struct super_block *sb)static void btrfs_free_fs_context (struct fs_context *fc) {struct btrfs_fs_context *ctx = fc->fs_private; +struct btrfs_fs_info *fs_info = fc->s_fs_info; -if (!ctx) -return ; +if (fs_info) +btrfs_free_fs_info (fs_info); -kfree (ctx->subvol_name); -kfree (ctx); +if (ctx &&refcount_dec_and_test (&ctx->refs)) { +kfree (ctx->subvol_name); +kfree (ctx); + } +} + +static int btrfs_dup_fs_context (struct fs_context *fc, +struct fs_context *src_fc) +{ +struct btrfs_fs_context *ctx = src_fc->fs_private; + +/* +* Give a ref to our ctx to this dup, as we want to keep it around for +* our original fc so we can have the subvolume name or objectid. +* +* We unset ->source in the original fc because the dup needs it for +* mounting, and then once we free the dup it'll free ->source, so we +* need to make sure we're only pointing to it in one fc. +*/ +refcount_inc (&ctx->refs); + fc->fs_private = ctx; + fc->source = src_fc->source; + src_fc->source =NULL ; +return 0 ; }static const struct fs_context_operations btrfs_fs_context_ops = { .parse_param = btrfs_parse_param, .reconfigure = btrfs_reconfigure, + .get_tree = btrfs_get_tree, + .dup = btrfs_dup_fs_context, .free = btrfs_free_fs_context, };
@@ -2865,6 +3066,7 @@ static int __maybe_unused btrfs_init_fs_context(struct fs_context *fc)if (!ctx)return -ENOMEM ; +refcount_set (&ctx->refs,1 ); fc->fs_private = ctx; fc->ops = &btrfs_fs_context_ops;
Signature · 1 line
2.41.0
PATCH v2 13/18 btrfs: handle the ro->rw transition for mounting different subovls
In reply to Josef BacikThis is an oddity that we've carried around since 0723a0473fb4 ("btrfs:
allow mounting btrfs subvolumes with different ro/rw options") where we'll under the covers flip the file system to RW if you're mixing and matching ro/rw options with different subvol mounts. The first mount is what the super gets setup as, so we'd handle this by remount the super as rw under the covers to facilitate this behavior.
With the new mount API we can't really allow this, because user space has the ability to specify the super block settings, and the mount settings. So if the user explicitly set the super block as read only, and then tried to mount a rw mount with the super block we'll reject this. However the old API was less descriptive and thus we allowed this kind of behavior.
This patch preserves this behavior for the old api calls. This is inspired by Christians work, and includes one of his comments, and thus is included in the link below.
--- fs/btrfs/super.c | 133 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 132 insertions(+), 1 deletion(-)
fs/btrfs/super.c +132 -1
@@ -2513,13 +2513,15 @@ static int btrfs_reconfigure(struct fs_context *fc)struct btrfs_fs_context *ctx = fc->fs_private;struct btrfs_fs_context old_ctx;int ret =0 ; +bool mount_reconfigure = (fc->s_fs_info !=NULL );btrfs_info_to_ctx (fs_info, &old_ctx);sync_filesystem (sb);set_bit (BTRFS_FS_STATE_REMOUNTING , &fs_info->fs_state); -if (!check_options (fs_info, &ctx->mount_opt, fc->sb_flags)) +if (!mount_reconfigure && + !check_options (fs_info, &ctx->mount_opt, fc->sb_flags))return -EINVAL ; ret =btrfs_check_features (fs_info, !(fc->sb_flags &SB_RDONLY ));
@@ -2922,6 +2924,133 @@ static int btrfs_get_tree_super(struct fs_context *fc)return ret; } +/* +* Christian wrote this long comment about what we're doing here, preserving it +* so the history of this change is preserved. +* +* Ever since commit 0723a0473fb4 ("btrfs: allow * mounting btrfs subvolumes +* with different ro/rw * options") the following works: +* +* (i) mount /dev/sda3 -o subvol=foo,ro /mnt/foo +* (ii) mount /dev/sda3 -o subvol=bar,rw /mnt/bar +* +* which looks nice and innocent but is actually pretty * intricate and +* deserves a long comment. +* +* On another filesystem a subvolume mount is close to * something like: +* +* (iii) # create rw superblock + initial mount +* mount -t xfs /dev/sdb /opt/ +* +* # create ro bind mount +* mount --bind -o ro /opt/foo /mnt/foo +* +* # unmount initial mount +* umount /opt +* +* Of course, there's some special subvolume sauce and there's the fact that the +* sb->s_root dentry is really swapped after mount_subtree(). But conceptually +* it's very close and will help us understand the issue. +* +* The old mount api didn't cleanly distinguish between a mount being made ro +* and a superblock being made ro. The only way to change the ro state of +* either object was by passing ms_rdonly. If a new mount was created via +* mount(2) such as: +* +* mount("/dev/sdb", "/mnt", "xfs", ms_rdonly, null); +* +* the MS_RDONLY flag being specified had two effects: +* +* (1) MNT_READONLY was raised -> the resulting mount got +* @mnt->mnt_flags |= MNT_READONLY raised. +* +* (2) MS_RDONLY was passed to the filesystem's mount method and the filesystems +* made the superblock ro. Note, how SB_RDONLY has the same value as +* ms_rdonly and is raised whenever MS_RDONLY is passed through mount(2). +* +* Creating a subtree mount via (iii) ends up leaving a rw superblock with a +* subtree mounted ro. +* +* But consider the effect on the old mount api on btrfs subvolume mounting +* which combines the distinct step in (iii) into a a single step. +* +* By issuing (i) both the mount and the superblock are turned ro. Now when (ii) +* is issued the superblock is ro and thus even if the mount created for (ii) is +* rw it wouldn't help. Hence, btrfs needed to transition the superblock from ro +* to rw for (ii) which it did using an internal remount call (a bold +* choice...). +* +* IOW, subvolume mounting was inherently messy due to the ambiguity of +* MS_RDONLY in mount(2). Note, this ambiguity has mount(8) always translate +* "ro" to MS_RDONLY. IOW, in both (i) and (ii) "ro" becomes MS_RDONLY when +* passed by mount(8) to mount(2). +* +* Enter the new mount api. the new mount api disambiguates making a mount ro +* and making a superblock ro. +* +* (3) To turn a mount ro the MOUNT_ATTR_ONLY flag can be used with either +* fsmount() or mount_setattr() this is a pure vfs level change for a +* specific mount or mount tree that is never seen by the filesystem itself. +* +* (4) To turn a superblock ro the "ro" flag must be used with +* fsconfig(FSCONFIG_SET_FLAG, "ro"). This option is seen by the filesytem +* in fc->sb_flags. +* +* This disambiguation has rather positive consequences. Mounting a subvolume +* ro will not also turn the superblock ro. Only the mount for the subvolume +* will become ro. +* +* So, if the superblock creation request comes from the new mount api the +* caller must've explicitly done: +* +* fsconfig(FSCONFIG_SET_FLAG, "ro") +* fsmount/mount_setattr(MOUNT_ATTR_RDONLY) +* +* IOW, at some point the caller must have explicitly turned the whole +* superblock ro and we shouldn't just undo it like we did for the old mount +* api. In any case, it lets us avoid this nasty hack in the new mount api. +* +* Consequently, the remounting hack must only be used for requests originating +* from the old mount api and should be marked for full deprecation so it can be +* turned off in a couple of years. +* +* The new mount api has no reason to support this hack. +*/ +static struct vfsmount *btrfs_reconfigure_for_mount (struct fs_context *fc) +{ +struct vfsmount *mnt; +int ret; +bool ro2rw = !(fc->sb_flags &SB_RDONLY ); + +/* +* We got an EBUSY because our SB_RDONLY flag didn't match the existing +* super block, so invert our setting here and re-try the mount so we +* can get our vfsmount. +*/ +if (ro2rw) + fc->sb_flags |=SB_RDONLY ; +else + fc->sb_flags &= ~SB_RDONLY ; + + mnt =fc_mount (fc); +if (IS_ERR (mnt)) +return mnt; + +if (!fc->oldapi || !ro2rw) +return mnt; + +/* We need to convert to rw, call reconfigure */ + fc->sb_flags &= ~SB_RDONLY ; +down_write (&mnt->mnt_sb->s_umount); + ret =btrfs_reconfigure (fc); +up_write (&mnt->mnt_sb->s_umount); +if (ret) { +mntput (mnt); +return ERR_PTR (ret); + } +return mnt; +} +static int btrfs_get_tree_subvol (struct fs_context *fc) {struct btrfs_fs_info *fs_info =NULL ;
@@ -2971,6 +3100,8 @@ static int btrfs_get_tree_subvol(struct fs_context *fc) fc->security =NULL ; mnt =fc_mount (dup_fc); +if (PTR_ERR_OR_ZERO (mnt) == -EBUSY ) + mnt =btrfs_reconfigure_for_mount (dup_fc);put_fs_context (dup_fc);if (IS_ERR (mnt))return PTR_ERR (mnt);
Signature · 1 line
2.41.0
PATCH v2 14/18 btrfs: switch to the new mount API
In reply to Josef BacikNow that we have all of the parts in place to use the new mount API, switch our fs_type to use the new callbacks.
There are a few things that have to be done at the same time because of the order of operations changes that come along with the new mount API. These must be done in the same patch otherwise things will go wrong.
1. Export and use btrfs_check_options in open_ctree(). This is because the options are done ahead of time, and we need to check them once we have the feature flags loaded.
2. Update the free space cache settings. Since we're coming in with the options already set we need to make sure we don't undo what the user has asked for.
3. Set our sb_flags at init_fs_context time, the fs_context stuff is trying to manage the sb_flagss itself, so move that into init_fs_context and out of the fill super part.
Additionally I've marked the unused functions with __maybe_unused and will remove them in a future patch.
--- fs/btrfs/disk-io.c | 5 +-- fs/btrfs/super.c | 88 ++++++++++++++++++++++++++-------------------- fs/btrfs/super.h | 2 ++ 3 files changed, 54 insertions(+), 41 deletions(-)
fs/btrfs/disk-io.c +3 -2
@@ -3295,9 +3295,10 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device*/ btrfs_set_free_space_cache_settings (fs_info); - ret =btrfs_parse_options (fs_info, options, sb->s_flags); -if (ret) +if (!btrfs_check_options (fs_info, &fs_info->mount_opt, sb->s_flags)) { + ret = -EINVAL ; goto fail_alloc; + } ret =btrfs_check_features (fs_info, !sb_rdonly (sb));if (ret <0 )
fs/btrfs/super.c +49 -39
164 lines not on this page · raw message
fs/btrfs/super.h +2 -0
@@ -3,6 +3,8 @@#ifndef BTRFS_SUPER_H #define BTRFS_SUPER_H +bool btrfs_check_options (struct btrfs_fs_info *info,unsigned long *mount_opt, +unsigned long flags);int btrfs_parse_options (struct btrfs_fs_info *info,char *options,unsigned long new_flags);int btrfs_sync_fs (struct super_block *sb,int wait);
Signature · 1 line
2.41.0
PATCH v2 15/18 btrfs: move the device specific mount options to super.c
In reply to Josef BacikWe add these mount options based on the fs_devices settings, which can be set once we've opened the fs_devices. Move these into their own helper and call it from get_tree_super.
--- fs/btrfs/disk-io.c | 23 ----------------------- fs/btrfs/super.c | 25 +++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 23 deletions(-)
fs/btrfs/disk-io.c +0 -23
@@ -3483,29 +3483,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device goto fail_cleaner; } -if (!btrfs_test_opt (fs_info,NOSSD ) && - !fs_info->fs_devices->rotating) { -btrfs_set_and_info (fs_info,SSD ,"enabling ssd optimizations" ); - } - -/* -* For devices supporting discard turn on discard=async automatically, -* unless it's already set or disabled. This could be turned off by -* nodiscard for the same mount. -* -* The zoned mode piggy backs on the discard functionality for -* resetting a zone. There is no reason to delay the zone reset as it is -* fast enough. So, do not enable async discard for zoned mode. -*/ -if (!(btrfs_test_opt (fs_info,DISCARD_SYNC ) || -btrfs_test_opt (fs_info,DISCARD_ASYNC ) || -btrfs_test_opt (fs_info,NODISCARD )) && - fs_info->fs_devices->discardable && - !btrfs_is_zoned (fs_info)) { -btrfs_set_and_info (fs_info,DISCARD_ASYNC , -"auto enabling async discard" ); - } - ret =btrfs_read_qgroup_config (fs_info);if (ret) goto fail_trans_kthread;
fs/btrfs/super.c +25 -0
@@ -823,6 +823,29 @@ void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)btrfs_set_opt (fs_info->mount_opt,SPACE_CACHE ); } +static void set_device_specific_options (struct btrfs_fs_info *fs_info) +{ +if (!btrfs_test_opt (fs_info,NOSSD ) && + !fs_info->fs_devices->rotating) +btrfs_set_opt (fs_info->mount_opt,SSD ); + +/* +* For devices supporting discard turn on discard=async automatically, +* unless it's already set or disabled. This could be turned off by +* nodiscard for the same mount. +* +* The zoned mode piggy backs on the discard functionality for +* resetting a zone. There is no reason to delay the zone reset as it is +* fast enough. So, do not enable async discard for zoned mode. +*/ +if (!(btrfs_test_opt (fs_info,DISCARD_SYNC ) || +btrfs_test_opt (fs_info,DISCARD_ASYNC ) || +btrfs_test_opt (fs_info,NODISCARD )) && + fs_info->fs_devices->discardable && + !btrfs_is_zoned (fs_info)) +btrfs_set_opt (fs_info->mount_opt,DISCARD_ASYNC ); +} +static int parse_rescue_options (struct btrfs_fs_info *info,const char *options) {char *opts;
@@ -2913,6 +2936,8 @@ static int btrfs_get_tree_super(struct fs_context *fc) goto error; } +set_device_specific_options (fs_info); +if (s->s_root) {btrfs_close_devices (fs_devices);if ((fc->sb_flags ^ s->s_flags) &SB_RDONLY )
Signature · 1 line
2.41.0
PATCH v2 16/18 btrfs: remove old mount API code
In reply to Josef BacikNow that we've switched to the new mount api, remove the old stuff.
--- fs/btrfs/fs.h | 14 - fs/btrfs/super.c | 1078 +--------------------------------------------- fs/btrfs/super.h | 2 - 3 files changed, 13 insertions(+), 1081 deletions(-)
fs/btrfs/fs.h +0 -14
@@ -961,20 +961,6 @@ void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,#define btrfs_test_opt (fs_info, opt) ((fs_info)->mount_opt & \ BTRFS_MOUNT_##opt) -#define btrfs_set_and_info(fs_info, opt, fmt, args...) \ -do { \ - if (!btrfs_test_opt(fs_info, opt)) \ - btrfs_info(fs_info, fmt, ##args); \ - btrfs_set_opt(fs_info->mount_opt, opt); \ -} while (0) - -#define btrfs_clear_and_info(fs_info, opt, fmt, args...) \ -do { \ - if (btrfs_test_opt(fs_info, opt)) \ - btrfs_info(fs_info, fmt, ##args); \ - btrfs_clear_opt(fs_info->mount_opt, opt); \ -} while (0) -static inline int btrfs_fs_closing (struct btrfs_fs_info *fs_info) {/* Do it this way so we only ever do one test_bit in the normal case. */
fs/btrfs/super.c +13 -1065
1,145 lines not on this page · raw message
fs/btrfs/super.h +0 -2
@@ -5,8 +5,6 @@bool btrfs_check_options (struct btrfs_fs_info *info,unsigned long *mount_opt,unsigned long flags); -int btrfs_parse_options (struct btrfs_fs_info *info,char *options, -unsigned long new_flags);int btrfs_sync_fs (struct super_block *sb,int wait);char *btrfs_get_subvol_name_from_objectid (struct btrfs_fs_info *fs_info,u64 subvol_objectid);
Signature · 1 line
2.41.0
PATCH v2 17/18 btrfs: move one shot mount option clearing to super.c
In reply to Josef BacikThere's no reason this has to happen in open_ctree, and in fact in the old mount API we had to call this from remount. Move this to super.c, unexport it, and call it from both mount and reconfigure.
--- fs/btrfs/disk-io.c | 16 +--------------- fs/btrfs/disk-io.h | 1 - fs/btrfs/super.c | 15 +++++++++++++++ 3 files changed, 16 insertions(+), 16 deletions(-)
fs/btrfs/disk-io.c +1 -15
@@ -2929,18 +2929,6 @@ static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)return err; } -/* -* Some options only have meaning at mount time and shouldn't persist across -* remounts, or be displayed. Clear these at the end of mount and remount -* code paths. -*/ -void btrfs_clear_oneshot_options (struct btrfs_fs_info *fs_info) -{ -btrfs_clear_opt (fs_info->mount_opt,USEBACKUPROOT ); -btrfs_clear_opt (fs_info->mount_opt,CLEAR_CACHE ); -btrfs_clear_opt (fs_info->mount_opt,NOSPACECACHE ); -} -/* * Mounting logic specific to read-write file systems. Shared by open_ctree * and btrfs_remount when remounting from read-only to read-write.
@@ -3508,7 +3496,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device }if (sb_rdonly (sb)) - goto clear_oneshot; +return 0 ; ret =btrfs_start_pre_rw_mount (fs_info);if (ret) {
@@ -3536,8 +3524,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (test_bit (BTRFS_FS_UNFINISHED_DROPS , &fs_info->flags))wake_up_process (fs_info->cleaner_kthread); -clear_oneshot: -btrfs_clear_oneshot_options (fs_info);return 0 ; fail_qgroup:
fs/btrfs/disk-io.h +0 -1
@@ -37,7 +37,6 @@ struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr, u64 owner_root, int level); -void btrfs_clear_oneshot_options (struct btrfs_fs_info *fs_info);int btrfs_start_pre_rw_mount (struct btrfs_fs_info *fs_info);int btrfs_check_super_csum (struct btrfs_fs_info *fs_info,const struct btrfs_super_block *disk_sb);
fs/btrfs/super.c +15 -0
@@ -640,6 +640,19 @@ static int btrfs_parse_param(struct fs_context *fc,return 0 ; } +/* +* Some options only have meaning at mount time and shouldn't persist across +* remounts, or be displayed. Clear these at the end of mount and remount +* code paths. +*/ +static void btrfs_clear_oneshot_options (struct btrfs_fs_info *fs_info) +{ +btrfs_clear_opt (fs_info->mount_opt,USEBACKUPROOT ); +btrfs_clear_opt (fs_info->mount_opt,CLEAR_CACHE ); +btrfs_clear_opt (fs_info->mount_opt,NOSPACECACHE ); +} + +static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long mount_opt,unsigned long opt,const char *opt_name)
@@ -1902,6 +1915,8 @@ static int btrfs_get_tree_super(struct fs_context *fc)return ret; } +btrfs_clear_oneshot_options (fs_info); + fc->root =dget (s->s_root);return 0 ;
Signature · 1 line
2.41.0
PATCH v2 18/18 btrfs: set clear_cache if we use usebackuproot
In reply to Josef BacikWe're currently setting this when we try to load the roots and we see that usebackuproot is set. Instead set this at mount option parsing time.
--- fs/btrfs/disk-io.c | 3 --- fs/btrfs/super.c | 12 ++++++++++++ 2 files changed, 12 insertions(+), 3 deletions(-)
fs/btrfs/disk-io.c +0 -3
@@ -2614,9 +2614,6 @@ static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)*/ btrfs_set_super_log_root (sb,0 ); -/* We can't trust the free space cache either */ -btrfs_set_opt (fs_info->mount_opt,CLEAR_CACHE ); -btrfs_warn (fs_info,"try to load backup roots slot %d" , i); ret =read_backup_root (fs_info, i); backup_index = ret;
fs/btrfs/super.c +12 -0
@@ -459,6 +459,12 @@ static int btrfs_parse_param(struct fs_context *fc,btrfs_warn (NULL ,"'recovery' is deprecated, use 'rescue=usebackuproot' instead" );btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); + +/* +* If we're loading the backup roots we can't trust the +* space cache. +*/ +btrfs_set_opt (ctx->mount_opt,CLEAR_CACHE ); }break ;case Opt_nologreplay:
@@ -557,6 +563,12 @@ static int btrfs_parse_param(struct fs_context *fc,btrfs_warn (NULL ,"'usebackuproot' is deprecated, use 'rescue=usebackuproot' instead" );btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); + +/* +* If we're loading the backup roots we can't trust the space +* cache. +*/ +btrfs_set_opt (ctx->mount_opt,CLEAR_CACHE );break ;case Opt_skip_balance:btrfs_set_opt (ctx->mount_opt,SKIP_BALANCE );
Signature · 1 line
2.41.0
Quoted 74 lines · Josef Bacik
v1->v2:
- Fixed up some nits and paste errors.
- Fixed build failure with !ZONED.
- Fixed accidentally droppingBINARY_MOUNTDATAflag.
- Added Reviewed-by's collected up to this point.These have run through our CI a few times, they haven't introduced any regressions.
--- Original email ---
Hello,These patches convert us to use the new mount API. Christian tried to do this a few months ago, but ran afoul of our preference to have a bunch of small changes. I started this series before I knew he had tried to convert us, so there's a fair bit that's different, but I did copy his approach for the remount bit. I've linked to the original patch where I took inspiration, Christian let me know if you want some other annotation for credit, I wasn't really sure the best way to do that.
There are a few preparatory patches in the beginning, and then cleanups at the end. I took each call back one at a time to try and make it as small as possible. The resulting code is less, but the diffstat shows more insertions that deletions. This is because there are some big comment blocks around some of the more subtle things that we're doing to hopefully make it more clear.
This is currently running through our CI. I thought it was fine last week but we had a bunch of new failures when I finished up the remount behavior. However today I discovered this was a regression in btrfs-progs, and I'm re-running the tests with the fixes. If anything major breaks in the CI I'll resend with fixes, but I'm pretty sure these patches will pass without issue.
I utilized
__maybe_unusedliberally to make sure everything compiled while applied. The only "big" patch is where I went and removed the old API. If requested I can break that up a bit more, but I didn't think it was necessary. I did make sure to keep it in its own patch, so the switch to the new mount API path only has things we need to support the new mount API, and then the next patch removes the old code. Thanks,Josef
Christian Brauner (1):
fs: indicate request originates from old mount apiJosef Bacik (17):
btrfs: split out the mount option validation code into its own helper
btrfs: set default compress type atbtrfs_init_fs_infotime
btrfs: move space cache settings intoopen_ctree
btrfs: do not allow free space tree rebuild on extent tree v2
btrfs: split outro->rwandrw->rohelpers into their own functions
btrfs: add a NOSPACECACHE mount option flag
btrfs: addfs_parameterdefinitions
btrfs: addparse_paramcallback for the new mount api
btrfs: add fs context handling functions
btrfs: add reconfigure callback forfs_context
btrfs: addget_treecallback for new mount API
btrfs: handle thero->rwtransition for mounting different subovls
btrfs: switch to the new mount API
btrfs: move the device specific mount options tosuper.c
btrfs: remove old mount API code
btrfs: move one shot mount option clearing tosuper.c
btrfs: setclear_cacheif we use usebackuprootfs/btrfs/disk-io.c | 76 +- fs/btrfs/disk-io.h | 1 - fs/btrfs/fs.h | 15 +- fs/btrfs/super.c | 2421 +++++++++++++++++++++++--------------------- fs/btrfs/super.h | 5 +- fs/btrfs/zoned.c | 16 +- fs/btrfs/zoned.h | 6 +- fs/namespace.c | 11 + 8 files changed, 1317 insertions(+), 1234 deletions(-)
Quoted 3 lines
--
2.41.0
The series looks reasonable to me. I do appreciate the extra effort in the documents and references to give me context when looking through it all.
Signature · 1 line
真実はいつも一つ!/ Always, there's only one truth!
Looks good from what I can tell,
Quoted 12 lines · Josef Bacik
v1->v2:
- Fixed up some nits and paste errors.
- Fixed build failure with !ZONED.
- Fixed accidentally droppingBINARY_MOUNTDATAflag.
- Added Reviewed-by's collected up to this point.These have run through our CI a few times, they haven't introduced any regressions.
--- Original email ---
Hello,
Quoted 7 lines
These patches convert us to use the new mount API. Christian tried to do this a few months ago, but ran afoul of our preference to have a bunch of small changes. I started this series before I knew he had tried to convert us, so there's a fair bit that's different, but I did copy his approach for the remount bit. I've linked to the original patch where I took inspiration, Christian let me know if you want some other annotation for credit, I wasn't really sure the best way to do that.
Thank you for pointing out the work that I did and for building on the bits of it that you could reuse. That's enough credit for me.
Thanks for converting btrfs and I hope we can get this merged soon. This was the last really major filesystems that hadn't been converted yet so I'm very glad to see this done.
Re: [PATCH v2 02/18] btrfs: split out the mount option validation code into its own helper
In reply to Josef BacikQuoted 24 lines
fs/btrfs/super.c +23
-0+static bool check_options (struct btrfs_fs_info *info,unsigned long flags) +{ +if (!(flags &SB_RDONLY ) && + (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" ))) +return false; + +if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,CLEAR_CACHE )) { +btrfs_err (info,"cannot disable free space tree" ); +return false; + } +if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE )) { +btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); +return false; + } + +if (btrfs_check_mountopts_zoned (info)) +return false; +
<snip>
Quoted 22 lines
fs/btrfs/super.c +1
-19-check: -/* We're read-only, don't have to check. */ -if (new_flags &SB_RDONLY ) - goto out; - -if (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" )) - ret = -EINVAL ; out: -if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,CLEAR_CACHE )) { -btrfs_err (info,"cannot disable free space tree" ); +if (!ret && !check_options (info, new_flags)) ret = -EINVAL ; - } -if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE )) { -btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); - ret = -EINVAL ; - }
fs/btrfs/super.c int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · line 813
Quoted 10 lines
fs/btrfs/super.c +0
-8-if (!ret) - ret =btrfs_check_mountopts_zoned (info); -if (!ret && !remounting) { -if (btrfs_test_opt (info,SPACE_CACHE )) -btrfs_info (info,"disk space caching is enabled" ); -if (btrfs_test_opt (info,FREE_SPACE_TREE )) -btrfs_info (info,"using free space tree" ); - }return ret; }
Before this patch, we verified all the above checks simultaneously. Now, for each error, we return without checking the rest. As a result, if there are multiple failures in the above checks, we report them sequentially. This is not a bug, but the optimization we had earlier has been traded off for cleaner code.
IMO it is good to keep the optimization.
Thanks, Anand
Re: [PATCH v2 02/18] btrfs: split out the mount option validation code into its own helper
Quoted 62 lines · Anand Jain
Quoted 24 lines
fs/btrfs/super.c +23
-0+static bool check_options (struct btrfs_fs_info *info,unsigned long flags) +{ +if (!(flags &SB_RDONLY ) && + (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || +check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" ))) +return false; + +if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE ) && + !btrfs_test_opt (info,CLEAR_CACHE )) { +btrfs_err (info,"cannot disable free space tree" ); +return false; + } +if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && + !btrfs_test_opt (info,FREE_SPACE_TREE )) { +btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); +return false; + } + +if (btrfs_check_mountopts_zoned (info)) +return false; +<snip>
Quoted 22 lines
fs/btrfs/super.c +1
-19-check: -/* We're read-only, don't have to check. */ -if (new_flags &SB_RDONLY ) - goto out; - -if (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" )) - ret = -EINVAL ; out: -if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,CLEAR_CACHE )) { -btrfs_err (info,"cannot disable free space tree" ); +if (!ret && !check_options (info, new_flags)) ret = -EINVAL ; - } -if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE )) { -btrfs_err (info,"cannot disable free space tree with block-group-tree feature" ); - ret = -EINVAL ; - }fs/btrfs/super.c int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · line 813
Quoted 10 lines
fs/btrfs/super.c +0
-8-if (!ret) - ret =btrfs_check_mountopts_zoned (info); -if (!ret && !remounting) { -if (btrfs_test_opt (info,SPACE_CACHE )) -btrfs_info (info,"disk space caching is enabled" ); -if (btrfs_test_opt (info,FREE_SPACE_TREE )) -btrfs_info (info,"using free space tree" ); - }return ret; }
Quoted 6 lines
Before this patch, we verified all the above checks simultaneously. Now, for each error, we return without checking the rest. As a result, if there are multiple failures in the above checks, we report them sequentially. This is not a bug, but the optimization we had earlier has been traded off for cleaner code.
IMO it is good to keep the optimization.
I would not say it's cleaner code, it's doing something else than before. I think we should keep the behaviour 1:1 unless there's a reason for that, the changelog does not say.
Re: [PATCH v2 08/18] btrfs: add fs_parameter definitions
In reply to Josef BacikQuoted 106 lines · Josef Bacik
In order to convert to the new mount api we have to change how we do the mount option parsing. For now we're going to duplicate these helpers to make it easier to follow, and then remove the old code once everything is in place. This patch contains the re-definiton of all of our mount options into the new
fs_parameter_specformat.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/super.c | 128 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 127 insertions(+), 1 deletion(-)fs/btrfs/super.c +72
-1@@ -27,6 +27,7 @@#include <linux/crc32c.h> #include <linux/btrfs.h> #include <linux/security.h> +#include <linux/fs_parser.h> #include "messages.h" #include "delayed-inode.h" #include "ctree.h" @@ -132,7 +133,7 @@ enum {/* Debugging options */ Opt_enospc_debug, Opt_noenospc_debug,#ifdef CONFIG_BTRFS_DEBUG - Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, + Opt_fragment, Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, #endif #ifdef CONFIG_BTRFS_FS_REF_VERIFY Opt_ref_verify,@@ -222,6 +223,131 @@ static const match_table_t rescue_tokens = { {Opt_err, NULL}, }; +enum { + Opt_fatal_errors_panic, + Opt_fatal_errors_bug, +}; + +static const struct constant_table btrfs_parameter_fatal_errors[] = { + {"panic" , Opt_fatal_errors_panic }, + {"bug" , Opt_fatal_errors_bug }, + {} +}; + +enum { + Opt_discard_sync, + Opt_discard_async, +}; + +static const struct constant_table btrfs_parameter_discard[] = { + {"sync" , Opt_discard_sync }, + {"async" , Opt_discard_async }, + {} +}; + +enum { + Opt_space_cache_v1, + Opt_space_cache_v2, +}; + +static const struct constant_table btrfs_parameter_space_cache[] = { + {"v1" , Opt_space_cache_v1 }, + {"v2" , Opt_space_cache_v2 }, + {} +}; + +enum { + Opt_rescue_usebackuproot, + Opt_rescue_nologreplay, + Opt_rescue_ignorebadroots, + Opt_rescue_ignoredatacsums, + Opt_rescue_parameter_all, +}; + +static const struct constant_table btrfs_parameter_rescue[] = { + {"usebackuproot" , Opt_rescue_usebackuproot }, + {"nologreplay" , Opt_rescue_nologreplay }, + {"ignorebadroots" , Opt_rescue_ignorebadroots }, + {"ibadroots" , Opt_rescue_ignorebadroots }, + {"ignoredatacsums" , Opt_rescue_ignoredatacsums }, + {"idatacsums" , Opt_rescue_ignoredatacsums }, + {"all" , Opt_rescue_parameter_all }, + {} +}; + +#ifdef CONFIG_BTRFS_DEBUG +enum { + Opt_fragment_parameter_data, + Opt_fragment_parameter_metadata, + Opt_fragment_parameter_all, +}; + +static const struct constant_table btrfs_parameter_fragment[] = { + {"data" , Opt_fragment_parameter_data }, + {"metadata" , Opt_fragment_parameter_metadata }, + {"all" , Opt_fragment_parameter_all }, + {} +}; +#endif + +static const struct fs_parameter_spec btrfs_fs_parameters[]__maybe_unused = { +fsparam_flag_no ("acl" , Opt_acl), + fsparam_flag("clear_cache", Opt_clear_cache),
fs/btrfs/super.c static const match_table_t rescue_tokens = { · line 305
Quoted 10 lines
fs/btrfs/super.c +10
-0+fsparam_u32 ("commit" , Opt_commit_interval), +fsparam_flag ("compress" , Opt_compress), +fsparam_string ("compress" , Opt_compress_type), +fsparam_flag ("compress-force" , Opt_compress_force), +fsparam_string ("compress-force" , Opt_compress_force_type), +fsparam_flag ("degraded" , Opt_degraded), +fsparam_string ("device" , Opt_device), +fsparam_enum ("fatal_errors" , Opt_fatal_errors, btrfs_parameter_fatal_errors), +fsparam_flag_no ("flushoncommit" , Opt_flushoncommit), + fsparam_flag_no("inode_cache", Opt_inode_cache),
I think it's a good opportunity to remove this option completely, its functionality is gone since 5.11, that's eough time. I'm fine with removing it both before or after the API switch.
Quoted 23 lines
fs/btrfs/super.c +23
-0+fsparam_string ("max_inline" , Opt_max_inline), +fsparam_flag_no ("barrier" , Opt_barrier), +fsparam_flag_no ("datacow" , Opt_datacow), +fsparam_flag_no ("datasum" , Opt_datasum), +fsparam_flag_no ("autodefrag" , Opt_defrag), +fsparam_flag_no ("discard" , Opt_discard), +fsparam_enum ("discard" , Opt_discard_mode, btrfs_parameter_discard), +fsparam_u32 ("metadata_ratio" , Opt_ratio), +fsparam_flag ("rescan_uuid_tree" , Opt_rescan_uuid_tree), +fsparam_flag ("skip_balance" , Opt_skip_balance), +fsparam_flag_no ("space_cache" , Opt_space_cache), +fsparam_enum ("space_cache" , Opt_space_cache_version, btrfs_parameter_space_cache), +fsparam_flag_no ("ssd" , Opt_ssd), +fsparam_flag_no ("ssd_spread" , Opt_ssd_spread), +fsparam_string ("subvol" , Opt_subvol), +fsparam_flag ("subvol=" , Opt_subvol_empty), +fsparam_u64 ("subvolid" , Opt_subvolid), +fsparam_u32 ("thread_pool" , Opt_thread_pool), +fsparam_flag_no ("treelog" , Opt_treelog), +fsparam_flag ("user_subvol_rm_allowed" , Opt_user_subvol_rm_allowed), + +/* Rescue options */ + fsparam_enum("rescue", Opt_rescue, btrfs_parameter_rescue),
fs/btrfs/super.c static const match_table_t rescue_tokens = { · line 338
Quoted 10 lines
fs/btrfs/super.c +10
-0+/* Deprecated, with alias rescue=nologreplay */ +__fsparam (NULL ,"nologreplay" , Opt_nologreplay, fs_param_deprecated, +NULL ), +/* Deprecated, with alias rescue=usebackuproot */ +__fsparam (NULL ,"usebackuproot" , Opt_usebackuproot, fs_param_deprecated, +NULL ), + +/* Deprecated options */ +__fsparam (NULL ,"recovery" , Opt_recovery, + fs_param_neg_with_no|fs_param_deprecated, NULL),
Same here, 'recovery' obsoleted by the rescue options in 4.5.
Quoted 18 lines
fs/btrfs/super.c +12
-0+ +/* Debugging options */ + fsparam_flag_no("enospc_debug", Opt_enospc_debug), +#ifdef CONFIG_BTRFS_DEBUG + fsparam_enum("fragment", Opt_fragment, btrfs_parameter_fragment), +#endif +#ifdef CONFIG_BTRFS_FS_REF_VERIFY + fsparam_flag("ref_verify", Opt_ref_verify), +#endif + {} +}; +static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long opt,const char *opt_name) {Signature · 1 line
2.41.0
Re: [PATCH v2 09/18] btrfs: add parse_param callback for the new mount api
In reply to Josef BacikQuoted 56 lines · Josef Bacik
The
parse_paramcallback handles one parameter at a time, take our existing mount option parsing loop and adjust it to handle one parameter at a time, and tie it into thefs_context_operations.Create a
btrfs_fs_contextobject that will store the various mount properties, we'll house this infc->fs_private. This is necessary to separate because remounting will use ->reconfigure, and we'll get a new copy of the parsed parameters, so we can no longer directly mess with thefs_infoin this stage.In the future we'll add this to the
btrfs_fs_infoand update the users to use the new context object instead.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/super.c | 390 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 390 insertions(+)fs/btrfs/super.c +23
-0@@ -84,6 +84,19 @@ static void btrfs_put_super(struct super_block *sb)close_ctree (btrfs_sb (sb)); } +/* Store the mount options related information. */ +struct btrfs_fs_context { +char *subvol_name; +u64 subvol_objectid; +u64 max_inline; +u32 commit_interval; +u32 metadata_ratio; +u32 thread_pool_size; +unsigned long mount_opt; +unsigned long compress_type:4 ; +unsigned int compress_level; +}; +enum { Opt_acl, Opt_noacl, Opt_clear_cache,@@ -348,6 +361,379 @@ static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { {} }; +static int btrfs_parse_param (struct fs_context *fc, +struct fs_parameter *param) +{ +struct btrfs_fs_context *ctx = fc->fs_private; +struct fs_parse_result result; +int opt; + + opt =fs_parse (fc, btrfs_fs_parameters, param, &result); +if (opt <0 ) +return opt;
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 383
Quoted 10 lines
fs/btrfs/super.c +10
-0+ +switch (opt) { +case Opt_degraded: +btrfs_set_opt (ctx->mount_opt,DEGRADED ); +break ; +case Opt_subvol_empty: +/* +* This exists because we used to allow it on accident, so we're +* keeping it to maintain ABI. See +* 37becec95ac31b209eb1c8e096f1093a7db00f32.
Please use the full patch reference 37becec95ac3 ("Btrfs: allow empty subvol= again"), the subject itself explains why it's here.
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 395
Quoted 12 lines
fs/btrfs/super.c +12
-0+*/ +break ; +case Opt_subvol: +kfree (ctx->subvol_name); + ctx->subvol_name =kstrdup (param->string,GFP_KERNEL ); +if (!ctx->subvol_name) +return -ENOMEM ; +break ; +case Opt_subvolid: + ctx->subvol_objectid = result.uint_64; + +/* subvoldi=0 means give me the original fs_tree. */
subvolid=0
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 405
Quoted 10 lines
fs/btrfs/super.c +10
-0+if (!ctx->subvol_objectid) + ctx->subvol_objectid =BTRFS_FS_TREE_OBJECTID ; +break ; +case Opt_device: { +struct btrfs_device *device; +blk_mode_t mode =sb_open_mode (fc->sb_flags); + +mutex_lock (&uuid_mutex); + device =btrfs_scan_one_device (param->string, mode, false); +mutex_unlock (&uuid_mutex);
So this changes how the device option and scan works. At this point the option is in the simple lock/unlock sequence, while currently it's scanning all devices under in one lock and then also opens all the devices. This prevents any other scan to interrupt that so it's either scanned right before (and filling the list) or after (which is a no-op).
Now it's open to the races, I haven't evaluated if this could be a problem or not.
Quoted 28 lines
fs/btrfs/super.c +28
-0+if (IS_ERR (device)) +return PTR_ERR (device); +break ; + } +case Opt_datasum: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + } +break ; +case Opt_datacow: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); +btrfs_set_opt (ctx->mount_opt,NODATACOW ); +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); + } +break ; +case Opt_compress_force: +case Opt_compress_force_type: +btrfs_set_opt (ctx->mount_opt,FORCE_COMPRESS ); + fallthrough; +case Opt_compress: +case Opt_compress_type:
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 443
Quoted 10 lines
fs/btrfs/super.c +10
-0+if (opt == Opt_compress || + opt == Opt_compress_force || +strncmp (param->string,"zlib" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZLIB ; + ctx->compress_level =BTRFS_ZLIB_DEFAULT_LEVEL ; +/* +* args[0] contains uninitialized data since +* for these tokens we don't expect any +* parameter. +*/
Please reformat/realign comments that you copy or move
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 449
Quoted 6 lines
fs/btrfs/super.c +6
-0+if (opt != Opt_compress && + opt != Opt_compress_force) + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZLIB , + param->string +4 );
This does not need to do newline after "("
Quoted 5 lines
fs/btrfs/super.c +5
-0+btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"lzo" ,3 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_LZO ;
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 464
Quoted 10 lines
fs/btrfs/super.c +10
-0+ ctx->compress_level =0 ; +btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"zstd" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZSTD ; + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZSTD , + param->string +4 );
Same
Quoted 35 lines
fs/btrfs/super.c +35
-0+btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"no" ,2 ) ==0 ) { + ctx->compress_level =0 ; + ctx->compress_type =0 ; +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); + }else { +btrfs_err (NULL ,"unrecognized compression value %s" , + param->string); +return -EINVAL ; + } +break ; +case Opt_ssd: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSSD ); +btrfs_clear_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_ssd_spread: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_set_opt (ctx->mount_opt,SSD_SPREAD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_barrier: +if (result.negated)
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 509
Quoted 10 lines
fs/btrfs/super.c +10
-0+btrfs_set_opt (ctx->mount_opt,NOBARRIER ); + else + btrfs_clear_opt(ctx->mount_opt, NOBARRIER); +break ; +case Opt_thread_pool: +if (result.uint_32 ==0 ) { +btrfs_err (NULL ,"invalid value 0 for thread_pool" ); +return -EINVAL ; + } + ctx->thread_pool_size = result.uint_32;
It's not in current code but we should eventually clamp the value, num_online_cpus or similar.
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 512
Quoted 3 lines
fs/btrfs/super.c +3
-0+break ; +case Opt_max_inline: + ctx->max_inline =memparse (param->string,NULL );
This does not match, the max_inline value is adjusted as
if (info->max_inline) {
info->max_inline = min_t(u64,
info->max_inline,
info->sectorsize);
}and it should be validated at the time we parse it, like other options.
Quoted 140 lines
fs/btrfs/super.c +140
-0+break ; +case Opt_acl: +if (result.negated) { + fc->sb_flags &= ~SB_POSIXACL ; + }else { +#ifdef CONFIG_BTRFS_FS_POSIX_ACL + fc->sb_flags |=SB_POSIXACL ; +#else +btrfs_err (NULL ,"support for ACL not compiled in!" ); + ret = -EINVAL ; + goto out; +#endif + } +/* +* VFS limits the ability to toggle ACL on and off via remount, +* despite every file system allowing this. This seems to be an +* oversight since we all do, but it'll fail if we're +* remounting. So don't set the mask here, we'll check it in +* btrfs_reconfigure and do the toggling ourselves. +*/ +if (fc->purpose !=FS_CONTEXT_FOR_RECONFIGURE ) + fc->sb_flags_mask |=SB_POSIXACL ; +break ; +case Opt_treelog: +if (result.negated) +btrfs_set_opt (ctx->mount_opt,NOTREELOG ); +else +btrfs_clear_opt (ctx->mount_opt,NOTREELOG ); +break ; +case Opt_recovery: +/* +* -o recovery used to be an alias for usebackuproot, and then +* norecovery was an alias for nologreplay, hence the different +* behaviors for negated and not. +*/ +if (result.negated) { +btrfs_warn (NULL , +"'norecovery' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); + }else { +btrfs_warn (NULL , +"'recovery' is deprecated, use 'rescue=usebackuproot' instead" ); +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); + } +break ; +case Opt_nologreplay: +btrfs_warn (NULL , +"'nologreplay' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +case Opt_flushoncommit: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,FLUSHONCOMMIT ); +else +btrfs_set_opt (ctx->mount_opt,FLUSHONCOMMIT ); +break ; +case Opt_ratio: + ctx->metadata_ratio = result.uint_32; +break ; +case Opt_discard: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,NODISCARD ); + }else { +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); + } +break ; +case Opt_discard_mode: +switch (result.uint_32) { +case Opt_discard_sync: +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +break ; +case Opt_discard_async: +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_ASYNC ); +break ; +default : +btrfs_err (NULL ,"unrecognized discard mode value %s" , + param->key); +return -EINVAL ; + } +btrfs_clear_opt (ctx->mount_opt,NODISCARD ); +break ; +case Opt_space_cache: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSPACECACHE ); +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); + }else { +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); + } +break ; +case Opt_space_cache_version: +switch (result.uint_32) { +case Opt_space_cache_v1: +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +case Opt_space_cache_v2: +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_set_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +default : +btrfs_err (NULL ,"unrecognized space_cache value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_rescan_uuid_tree: +btrfs_set_opt (ctx->mount_opt,RESCAN_UUID_TREE ); +break ; +case Opt_inode_cache: +btrfs_warn (NULL , +"the 'inode_cache' option is deprecated and has no effect since 5.11" ); +break ; +case Opt_clear_cache: +btrfs_set_opt (ctx->mount_opt,CLEAR_CACHE ); +break ; +case Opt_user_subvol_rm_allowed: +btrfs_set_opt (ctx->mount_opt,USER_SUBVOL_RM_ALLOWED ); +break ; +case Opt_enospc_debug: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,ENOSPC_DEBUG ); +else +btrfs_set_opt (ctx->mount_opt,ENOSPC_DEBUG ); +break ; +case Opt_defrag: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,AUTO_DEFRAG ); +else +btrfs_set_opt (ctx->mount_opt,AUTO_DEFRAG ); +break ; +case Opt_usebackuproot: +btrfs_warn (NULL , +"'usebackuproot' is deprecated, use 'rescue=usebackuproot' instead" );
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 662
Quoted 10 lines
fs/btrfs/super.c +10
-0+btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); +break ; +case Opt_skip_balance: +btrfs_set_opt (ctx->mount_opt,SKIP_BALANCE ); +break ; +case Opt_fatal_errors: +switch (result.uint_32) { +case Opt_fatal_errors_panic: +btrfs_set_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR );
Lines can be joined
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 666
Quoted 4 lines
fs/btrfs/super.c +4
-0+break ; +case Opt_fatal_errors_bug: +btrfs_clear_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR );
Same
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 677
Quoted 11 lines
fs/btrfs/super.c +11
-0+break ; +default : +btrfs_err (NULL ,"unrecognized fatal_errors value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_commit_interval: + ctx->commit_interval = result.uint_32; +if (!ctx->commit_interval) + ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ;
And the value of commit_interval is also adjusted in current code, this should be done here as well.
Quoted 26 lines
fs/btrfs/super.c +26
-0+break ; +case Opt_rescue: +switch (result.uint_32) { +case Opt_rescue_usebackuproot: +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); +break ; +case Opt_rescue_nologreplay: +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +case Opt_rescue_ignorebadroots: +btrfs_set_opt (ctx->mount_opt,IGNOREBADROOTS ); +break ; +case Opt_rescue_ignoredatacsums: +btrfs_set_opt (ctx->mount_opt,IGNOREDATACSUMS ); +break ; +case Opt_rescue_parameter_all: +btrfs_set_opt (ctx->mount_opt,IGNOREDATACSUMS ); +btrfs_set_opt (ctx->mount_opt,IGNOREBADROOTS ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +default : +btrfs_info (NULL ,"unrecognized rescue option '%s'" , + param->key); +return -EINVAL ; + } +break ;
Re: [PATCH v2 11/18] btrfs: add reconfigure callback for fs_context
In reply to Josef BacikQuoted 157 lines · Josef Bacik
This is what is used to remount the file system with the new mount API. Because the mount options are parsed separately and one at a time I've added a helper to emit the mount options after the fact once the mount is configured, this matches the dmesg output for what happens with the old mount API.
Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/super.c | 243 +++++++++++++++++++++++++++++++++++++++++++---- fs/btrfs/zoned.c | 16 ++-- fs/btrfs/zoned.h | 6 +- 3 files changed, 236 insertions(+), 29 deletions(-)fs/btrfs/super.c +83
-13@@ -734,10 +734,11 @@ static int btrfs_parse_param(struct fs_context *fc,return 0 ; } -static bool check_ro_option (struct btrfs_fs_info *fs_info,unsigned long opt, +static bool check_ro_option (struct btrfs_fs_info *fs_info, +unsigned long mount_opt,unsigned long opt,const char *opt_name) { -if (fs_info->mount_opt & opt) { +if (mount_opt & opt) {btrfs_err (fs_info,"%s must be used with ro mount option" , opt_name);return true;@@ -745,33 +746,34 @@ static bool check_ro_option(struct btrfs_fs_info *fs_info, unsigned long opt,return false; } -static bool check_options (struct btrfs_fs_info *info,unsigned long flags) +static bool check_options (struct btrfs_fs_info *info,unsigned long *mount_opt, +unsigned long flags) {if (!(flags &SB_RDONLY ) && - (check_ro_option (info,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || -check_ro_option (info,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" ))) + (check_ro_option (info, *mount_opt,BTRFS_MOUNT_NOLOGREPLAY ,"nologreplay" ) || +check_ro_option (info, *mount_opt,BTRFS_MOUNT_IGNOREBADROOTS ,"ignorebadroots" ) || +check_ro_option (info, *mount_opt,BTRFS_MOUNT_IGNOREDATACSUMS ,"ignoredatacsums" )))return false;if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE ) && - !btrfs_test_opt (info,CLEAR_CACHE )) { + !btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE ) && + !btrfs_raw_test_opt (*mount_opt,CLEAR_CACHE )) {btrfs_err (info,"cannot disable free space tree" );return false; }if (btrfs_fs_compat_ro (info,BLOCK_GROUP_TREE ) && - !btrfs_test_opt (info,FREE_SPACE_TREE )) { + !btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE )) {btrfs_err (info,"cannot disable free space tree with block-group-tree feature" );return false; } -if (btrfs_check_mountopts_zoned (info)) +if (btrfs_check_mountopts_zoned (info, mount_opt))return false;if (!test_bit (BTRFS_FS_STATE_REMOUNTING , &info->fs_state)) { -if (btrfs_test_opt (info,SPACE_CACHE )) +if (btrfs_raw_test_opt (*mount_opt,SPACE_CACHE ))btrfs_info (info,"disk space caching is enabled" ); -if (btrfs_test_opt (info,FREE_SPACE_TREE )) +if (btrfs_raw_test_opt (*mount_opt,FREE_SPACE_TREE ))btrfs_info (info,"using free space tree" ); }@@ -1337,7 +1339,7 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options, } } out: -if (!ret && !check_options (info, new_flags)) +if (!ret && !check_options (info, &info->mount_opt, new_flags)) ret = -EINVAL ;return ret; }@@ -2377,6 +2379,203 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)return ret; } +static void btrfs_ctx_to_info (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *ctx) +{ + fs_info->max_inline = ctx->max_inline; + fs_info->commit_interval = ctx->commit_interval; + fs_info->metadata_ratio = ctx->metadata_ratio; + fs_info->thread_pool_size = ctx->thread_pool_size; + fs_info->mount_opt = ctx->mount_opt; + fs_info->compress_type = ctx->compress_type; + fs_info->compress_level = ctx->compress_level; +} + +static void btrfs_info_to_ctx (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *ctx) +{ + ctx->max_inline = fs_info->max_inline; + ctx->commit_interval = fs_info->commit_interval; + ctx->metadata_ratio = fs_info->metadata_ratio; + ctx->thread_pool_size = fs_info->thread_pool_size; + ctx->mount_opt = fs_info->mount_opt; + ctx->compress_type = fs_info->compress_type; + ctx->compress_level = fs_info->compress_level; +} + +#define btrfs_info_if_set(fs_info, old_ctx, opt, fmt, args...) \ +do { \ + if ((!old_ctx || !btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ + btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ + btrfs_info(fs_info, fmt, ##args); \ +} while (0) + +#define btrfs_info_if_unset(fs_info, old_ctx, opt, fmt, args...) \ +do { \ + if ((old_ctx && btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ + !btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ + btrfs_info(fs_info, fmt, ##args); \ +} while (0) + +static void btrfs_emit_options (struct btrfs_fs_info *fs_info, +struct btrfs_fs_context *old_ctx) +{ +btrfs_info_if_set (fs_info, old_ctx,NODATASUM ,"setting nodatasum" ); +btrfs_info_if_set (fs_info, old_ctx,DEGRADED , +"allowing degraded mounts" ); +btrfs_info_if_set (fs_info, old_ctx,NODATASUM ,"setting nodatasum" ); +btrfs_info_if_set (fs_info, old_ctx,SSD ,"enabling ssd optimizations" ); +btrfs_info_if_set (fs_info, old_ctx,SSD_SPREAD , +"using spread ssd allocation scheme" ); +btrfs_info_if_set (fs_info, old_ctx,NOBARRIER ,"turning off barriers" ); +btrfs_info_if_set (fs_info, old_ctx,NOTREELOG ,"disabling tree log" ); +btrfs_info_if_set (fs_info, old_ctx,NOLOGREPLAY , +"disabling log replay at mount time" ); +btrfs_info_if_set (fs_info, old_ctx,FLUSHONCOMMIT , +"turning on flush-on-commit" ); +btrfs_info_if_set (fs_info, old_ctx,DISCARD_SYNC , +"turning on sync discard" ); +btrfs_info_if_set (fs_info, old_ctx,DISCARD_ASYNC , +"turning on async discard" ); +btrfs_info_if_set (fs_info, old_ctx,FREE_SPACE_TREE , +"enabling free space tree" ); +btrfs_info_if_set (fs_info, old_ctx,SPACE_CACHE , +"enabling disk space caching" ); +btrfs_info_if_set (fs_info, old_ctx,CLEAR_CACHE , +"force clearing of disk cache" ); +btrfs_info_if_set (fs_info, old_ctx,AUTO_DEFRAG , +"enabling auto defrag" ); +btrfs_info_if_set (fs_info, old_ctx,FRAGMENT_DATA , +"fragmenting data" );
fs/btrfs/super.c static int btrfs_remount(struct super_block *sb, int *flags, char *data) · line 2459
Quoted 10 lines
fs/btrfs/super.c +10
-0+btrfs_info_if_set (fs_info, old_ctx,FRAGMENT_METADATA , +"fragmenting metadata" ); +btrfs_info_if_set (fs_info, old_ctx,REF_VERIFY , +"doing ref verification" ); +btrfs_info_if_set (fs_info, old_ctx,USEBACKUPROOT , +"trying to use backup root at mount time" ); +btrfs_info_if_set (fs_info, old_ctx,IGNOREBADROOTS , +"ignoring bad roots" ); +btrfs_info_if_set (fs_info, old_ctx,IGNOREDATACSUMS , +"ignoring data csums" );
I think we can format this on >80 char lines, it would look better IMHO. If fs_info and old_ctx are named shorter then more of the string fits.
Quoted 5 lines
fs/btrfs/super.c +5
-0+btrfs_info_if_unset (fs_info, old_ctx,NODATACOW ,"setting datacow" ); +btrfs_info_if_unset (fs_info, old_ctx,SSD ,"not using ssd optimizations" ); +btrfs_info_if_unset (fs_info, old_ctx,SSD_SPREAD , +"not using spread ssd allocation scheme" ); + btrfs_info_if_unset(fs_info, old_ctx, NOBARRIER,
fs/btrfs/super.c static int btrfs_remount(struct super_block *sb, int *flags, char *data) · line 2475
Quoted 10 lines
fs/btrfs/super.c +10
-0+ "turning off barriers"); +btrfs_info_if_unset (fs_info, old_ctx,NOTREELOG ,"enabling tree log" ); +btrfs_info_if_unset (fs_info, old_ctx,SPACE_CACHE , +"disabling disk space caching" ); +btrfs_info_if_unset (fs_info, old_ctx,FREE_SPACE_TREE , +"disabling free space tree" ); +btrfs_info_if_unset (fs_info, old_ctx,AUTO_DEFRAG , +"disabling auto defrag" ); +btrfs_info_if_unset (fs_info, old_ctx,COMPRESS , +"use no compression" );
Same
Quoted 11 lines
fs/btrfs/super.c +11
-0+ +/* Did the compression settings change? */ +if (btrfs_test_opt (fs_info,COMPRESS ) && + (!old_ctx || + old_ctx->compress_type != fs_info->compress_type || + old_ctx->compress_level != fs_info->compress_level || + (!btrfs_raw_test_opt (old_ctx->mount_opt,FORCE_COMPRESS ) && +btrfs_raw_test_opt (fs_info->mount_opt,FORCE_COMPRESS )))) { +char *compress_type ="none" ; + +switch (fs_info->compress_type) {
fs/btrfs/super.c static int btrfs_remount(struct super_block *sb, int *flags, char *data) · line 2496
Quoted 10 lines
fs/btrfs/super.c +10
-0+case BTRFS_COMPRESS_ZLIB : + compress_type ="zlib" ; +break ; +case BTRFS_COMPRESS_LZO : + compress_type ="lzo" ; +break ; +case BTRFS_COMPRESS_ZSTD : + compress_type ="zstd" ; +break ; + }
We have btrfs_compress_type2str()
Quoted 10 lines
fs/btrfs/super.c +10
-0+ +btrfs_info (fs_info,"%s %s compression, level %d" , +btrfs_test_opt (fs_info,FORCE_COMPRESS ) ?"force" :"use" , + compress_type, fs_info->compress_level); + } + +if (fs_info->max_inline !=BTRFS_DEFAULT_MAX_INLINE ) +btrfs_info (fs_info,"max_inline at %llu" , + fs_info->max_inline); +}
Re: [PATCH v2 12/18] btrfs: add get_tree callback for new mount API
In reply to Josef BacikQuoted 35 lines · Josef Bacik
This is the actual mounting callback for the new mount API. Implement this using our current fill super as a guideline, making the appropriate adjustments for the new mount API.
Our old mount operation had two
fs_types, one to handle the actual opening, and the one that we called to handle the actual opening and then did the subvol lookup for returning the actual root dentry. This is mirrored here, but simply with different behaviors for ->get_tree. We use the existence of ->s_fs_info to tell which part we're in. The initial call allocates thefs_info, then callmount_fc()with a duplicated fc to do the actualopen_ctreepart. Then we take that vfsmount and use it to look up our subvolume that we're mounting and return that as ours_root. This idea was taken from Christians attempt to convert us to the new mount api.References: https://lore.kernel.org/all/[email protected]/
Reviewed-by Christian Brauner <[email protected]>Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/super.c | 210 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 206 insertions(+), 4 deletions(-)fs/btrfs/super.c +1
-0@@ -95,6 +95,7 @@ struct btrfs_fs_context {unsigned long mount_opt; unsigned long compress_type:4;unsigned int compress_level; +refcount_t refs; };enum {
fs/btrfs/super.c static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) · line 2839
Quoted 6 lines
fs/btrfs/super.c +3
-0@@ -2833,6 +2834,181 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)return 0 ; } +static int btrfs_fc_test_super (struct super_block *s,struct fs_context *fc) +{ +struct btrfs_fs_info *p = fc->s_fs_info;
That's a confusing variable name
fs/btrfs/super.c static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) · line 2852
Quoted 13 lines
fs/btrfs/super.c +13
-0+struct btrfs_fs_info *fs_info =btrfs_sb (s); + +return fs_info->fs_devices == p->fs_devices; +} + +static int btrfs_get_tree_super (struct fs_context *fc) +{ +struct btrfs_fs_info *fs_info = fc->s_fs_info; +struct btrfs_fs_context *ctx = fc->fs_private; +struct btrfs_fs_devices *fs_devices =NULL ; +struct block_device *bdev; +struct btrfs_device *device; +struct super_block *s;
Please use 'sb' for super block.
Quoted 12 lines
fs/btrfs/super.c +12
-0+blk_mode_t mode =sb_open_mode (fc->sb_flags); +int ret; + +btrfs_ctx_to_info (fs_info, ctx); +mutex_lock (&uuid_mutex); + +/* +* With 'true' passed to btrfs_scan_one_device() (mount time) we expect +* either a valid device or an error. +*/ + device =btrfs_scan_one_device (fc->source, mode, true); +ASSERT (device !=NULL );
fs/btrfs/super.c static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) · line 2874
Quoted 10 lines
fs/btrfs/super.c +10
-0+if (IS_ERR (device)) { +mutex_unlock (&uuid_mutex); +return PTR_ERR (device); + } + + fs_devices = device->fs_devices; + fs_info->fs_devices = fs_devices; + + ret =btrfs_open_devices (fs_devices, mode, &btrfs_fs_type); +mutex_unlock (&uuid_mutex);
Regarding the previous comments about mount and scanning, here the device is scanned and opened in one go, so all the other devices are expected to be scanned independently from before.
This is not a prolbem, although it allows to something race in between the mount option scanning and here and call 'forget' on the devices. We've seen udev to race with mkfs to register the device, which is not a problem here, but if there's something calling 'forget' automatically then it will be.
Since systemd started to mess with background mounts and scans we can never ber sure what's going to happen when triggered by system events.
Quoted 9 lines
fs/btrfs/super.c +9
-0+if (ret) +return ret; + +if (!(fc->sb_flags &SB_RDONLY ) && fs_devices->rw_devices ==0 ) { + ret = -EACCES ; + goto error; + } + + bdev = fs_devices->latest_dev->bdev;
fs/btrfs/super.c static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) · line 2893
Quoted 10 lines
fs/btrfs/super.c +10
-0+ +/* +* If successful, this will transfer the fs_info into the super block, +* and fc->s_fs_info will be NULL. However if there's an existing +* super, we'll still have fc->s_fs_info populated. If we error +* completely out it'll be cleaned up when we drop the fs_context, +* otherwise it's tied to the lifetime of the super_block. +* +* Adding this comment because I was horribly confused about the error +* handling from here on out.
The last sentence does not need to be there, that we add comments to avoid confusion is kind of implicit.
Quoted 4 lines
fs/btrfs/super.c +4
-0+*/ + s =sget_fc (fc, btrfs_fc_test_super, set_anon_super_fc); +if (IS_ERR (s)) { + ret =PTR_ERR (s);
fs/btrfs/super.c static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) · line 2907
Quoted 10 lines
fs/btrfs/super.c +10
-0+ goto error; + } + +if (s->s_root) { +btrfs_close_devices (fs_devices); +if ((fc->sb_flags ^ s->s_flags) &SB_RDONLY ) + ret = -EBUSY ; + }else { +snprintf (s->s_id,sizeof (s->s_id),"%pg" , bdev); +shrinker_debugfs_rename (&s->s_shrink,"sb-btrfs:%s" , s->s_id);
In 6.7-rc1 there's a change do allocate shrinkers dynamically so this will need to be adjusted
shrinker_debugfs_rename(s->s_shrink, ...
Quoted 16 lines
fs/btrfs/super.c +16
-0+btrfs_sb (s)->bdev_holder = &btrfs_fs_type; + ret =btrfs_fill_super (s, fs_devices,NULL ); + } + +if (ret) { +deactivate_locked_super (s); +return ret; + } + + fc->root =dget (s->s_root); +return 0 ; + +error: +btrfs_close_devices (fs_devices); +return ret; +}
Re: [PATCH v2 04/18] btrfs: move space cache settings into open_ctree
In reply to Josef BacikQuoted 77 lines
fs/btrfs/disk-io.c +6
-11@@ -3287,6 +3287,12 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device fs_info->csums_per_leaf =BTRFS_MAX_ITEM_SIZE (fs_info) / fs_info->csum_size; fs_info->stripesize = stripesize; +/* +* Handle the space caching options appropriately now that we have the +* super loaded and validated. +*/ +btrfs_set_free_space_cache_settings (fs_info); + ret =btrfs_parse_options (fs_info, options, sb->s_flags);if (ret) goto fail_alloc;@@ -3298,17 +3304,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (sectorsize <PAGE_SIZE ) {struct btrfs_subpage_info *subpage_info; -/* -* V1 space cache has some hardcoded PAGE_SIZE usage, and is -* going to be deprecated. -* -* Force to use v2 cache for subpage case. -*/ -btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); -btrfs_set_and_info (fs_info,FREE_SPACE_TREE , -"forcing free space tree for sector size %u with page size %lu" , - sectorsize,PAGE_SIZE ); -btrfs_warn (fs_info,"read-write for sector size %u with page size %lu is experimental" , sectorsize,PAGE_SIZE );fs/btrfs/super.c +25
-5@@ -266,6 +266,31 @@ static bool check_options(struct btrfs_fs_info *info, unsigned long flags)return true; } +void btrfs_set_free_space_cache_settings (struct btrfs_fs_info *fs_info) +{ +if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) +btrfs_set_opt (fs_info->mount_opt,FREE_SPACE_TREE ); +else if (btrfs_free_space_cache_v1_active (fs_info)) { +if (btrfs_is_zoned (fs_info)) { +btrfs_info (fs_info, +"zoned: clearing existing space cache" ); +btrfs_set_super_cache_generation (fs_info->super_copy,0 ); + }else { +btrfs_set_opt (fs_info->mount_opt,SPACE_CACHE ); + } + } + +if (fs_info->sectorsize <PAGE_SIZE ) { +btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); +if (!btrfs_test_opt (fs_info,FREE_SPACE_TREE )) { +btrfs_info (fs_info, +"forcing free space tree for sector size %u with page size %lu" , + fs_info->sectorsize,PAGE_SIZE ); +btrfs_set_opt (fs_info->mount_opt,FREE_SPACE_TREE ); + } + } +} +static int parse_rescue_options (struct btrfs_fs_info *info,const char *options) {char *opts;@@ -345,18 +370,6 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,bool saved_compress_force;int no_compress =0 ; -if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE )) -btrfs_set_opt (info->mount_opt,FREE_SPACE_TREE ); -else if (btrfs_free_space_cache_v1_active (info)) { -if (btrfs_is_zoned (info)) { - btrfs_info(info,
fs/btrfs/super.c int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · line 375
Quoted 10 lines
fs/btrfs/super.c +0
-7- "zoned: clearing existing space cache"); -btrfs_set_super_cache_generation (info->super_copy,0 ); - }else { -btrfs_set_opt (info->mount_opt,SPACE_CACHE ); - } - } -/* * Even the options are empty, we still need to do extra check * against new flags
btrfs_remount() calls btrfs_parse_options(), which previously handled space cache/tree flags set/reset. However, with the move of this functionality to a separate function, btrfs_set_free_space_cache_settings(), the btrfs_remount() thread no longer has the space cache/tree flags set/reset. The changelog provides no explanation for this change. Could this be a bug?
Thanks, Anand
Re: [PATCH v2 05/18] btrfs: do not allow free space tree rebuild on extent tree v2
In reply to Josef BacikQuoted 17 lines · Josef Bacik
We currently don't allow these options to be set if we're extent tree v2 via the mount option parsing. However when we switch to the new mount API we'll no longer have the super block loaded, so won't be able to make this distinction at mount option parsing time. Address this by checking for extent tree v2 at the point where we make the decision to rebuild the free space tree.
Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/disk-io.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/disk-io.c +0
-0
fs/btrfs/disk-io.c int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info) · line 2958
Quoted 9 lines
fs/btrfs/disk-io.c +2
-1@@ -2951,7 +2951,8 @@ int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)bool rebuild_free_space_tree = false;if (btrfs_test_opt (fs_info,CLEAR_CACHE ) && -btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) { +btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && + !btrfs_fs_incompat (fs_info,EXTENT_TREE_V2 )) { rebuild_free_space_tree = true; }else if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && !btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID )) {
If there is v3 you can consider to add a comment similar to that is in btrfs_parse_options().
Also, IMO, it is a good idea to include a btrfs_info() statement to indicate that the clear_cache option is ignored.
--------------------
case Opt_clear_cache:
/*
* We cannot clear the free space tree with
extent tree
* v2, ignore this option.
*/
if (btrfs_fs_incompat(info, EXTENT_TREE_V2))
break;
btrfs_set_and_info(info, CLEAR_CACHE,
"force clearing of disk cache");
break;--------------------
Thanks, Anand
Re: [PATCH v2 05/18] btrfs: do not allow free space tree rebuild on extent tree v2
Quoted 20 lines · Anand Jain
Quoted 19 lines · Josef Bacik
We currently don't allow these options to be set if we're extent tree v2 via the mount option parsing. However when we switch to the new mount API we'll no longer have the super block loaded, so won't be able to make this distinction at mount option parsing time. Address this by checking for extent tree v2 at the point where we make the decision to rebuild the free space tree.
Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/disk-io.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/btrfs/disk-io.c +0
-0@@ -2951,7 +2951,8 @@ int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)bool rebuild_free_space_tree = false;
Quoted 12 lines
fs/btrfs/disk-io.c int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info) · line 2958
Quoted 7 lines
fs/btrfs/disk-io.c +2
-1if (btrfs_test_opt (fs_info,CLEAR_CACHE ) && -btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) { +btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && + !btrfs_fs_incompat (fs_info,EXTENT_TREE_V2 )) { rebuild_free_space_tree = true; }else if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE ) && !btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE_VALID )) {If there is v3 you can consider to add a comment similar to that is in
btrfs_parse_options().
Also, IMO, it is a good idea to include abtrfs_info()statement to indicate that theclear_cacheoption is ignored.
Agreed, we have a lot of verbosity around the mount options, if some option combination is invalid or not working as expected a message should pe printed.
Re: [PATCH v2 04/18] btrfs: move space cache settings into open_ctree
In reply to Anand JainQuoted 85 lines · Anand Jain
Quoted 73 lines
fs/btrfs/disk-io.c +6
-11@@ -3287,6 +3287,12 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device fs_info->csums_per_leaf =BTRFS_MAX_ITEM_SIZE (fs_info) / fs_info->csum_size; fs_info->stripesize = stripesize; +/* +* Handle the space caching options appropriately now that we have the +* super loaded and validated. +*/ +btrfs_set_free_space_cache_settings (fs_info); + ret =btrfs_parse_options (fs_info, options, sb->s_flags);if (ret) goto fail_alloc;@@ -3298,17 +3304,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_deviceif (sectorsize <PAGE_SIZE ) {struct btrfs_subpage_info *subpage_info; -/* -* V1 space cache has some hardcoded PAGE_SIZE usage, and is -* going to be deprecated. -* -* Force to use v2 cache for subpage case. -*/ -btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); -btrfs_set_and_info (fs_info,FREE_SPACE_TREE , -"forcing free space tree for sector size %u with page size %lu" , - sectorsize,PAGE_SIZE ); -btrfs_warn (fs_info,"read-write for sector size %u with page size %lu is experimental" , sectorsize,PAGE_SIZE );fs/btrfs/super.c +25
-5@@ -266,6 +266,31 @@ static bool check_options(struct btrfs_fs_info *info, unsigned long flags)return true; } +void btrfs_set_free_space_cache_settings (struct btrfs_fs_info *fs_info) +{ +if (btrfs_fs_compat_ro (fs_info,FREE_SPACE_TREE )) +btrfs_set_opt (fs_info->mount_opt,FREE_SPACE_TREE ); +else if (btrfs_free_space_cache_v1_active (fs_info)) { +if (btrfs_is_zoned (fs_info)) { +btrfs_info (fs_info, +"zoned: clearing existing space cache" ); +btrfs_set_super_cache_generation (fs_info->super_copy,0 ); + }else { +btrfs_set_opt (fs_info->mount_opt,SPACE_CACHE ); + } + } + +if (fs_info->sectorsize <PAGE_SIZE ) { +btrfs_clear_opt (fs_info->mount_opt,SPACE_CACHE ); +if (!btrfs_test_opt (fs_info,FREE_SPACE_TREE )) { +btrfs_info (fs_info, +"forcing free space tree for sector size %u with page size %lu" , + fs_info->sectorsize,PAGE_SIZE ); +btrfs_set_opt (fs_info->mount_opt,FREE_SPACE_TREE ); + } + } +} +static int parse_rescue_options (struct btrfs_fs_info *info,const char *options) {char *opts;@@ -345,18 +370,6 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,bool saved_compress_force;int no_compress =0 ; -if (btrfs_fs_compat_ro (info,FREE_SPACE_TREE )) -btrfs_set_opt (info->mount_opt,FREE_SPACE_TREE ); -else if (btrfs_free_space_cache_v1_active (info)) { -if (btrfs_is_zoned (info)) { - btrfs_info(info,fs/btrfs/super.c int btrfs_parse_options(struct btrfs_fs_info *info, char *options, · line 374
Quoted 10 lines
fs/btrfs/super.c +0
-7- "zoned: clearing existing space cache"); -btrfs_set_super_cache_generation (info->super_copy,0 ); - }else { -btrfs_set_opt (info->mount_opt,SPACE_CACHE ); - } - } -/* * Even the options are empty, we still need to do extra check * against new flags
Quoted 7 lines
btrfs_remount()callsbtrfs_parse_options(), which previously handled space cache/tree flags set/reset. However, with the move of this functionality to a separate function,btrfs_set_free_space_cache_settings(), thebtrfs_remount()thread no longer has the space cache/tree flags set/reset. The changelog provides no explanation for this change. Could this be a bug?
All this bit does is set the mount_opt's based on the current state of the file system, so if we're mounting with no "-o space_cache=*" option, we'll derive it from wether FREE_SPACE_TREE is set or btrfs_free_space_cache_v1_active() returns true.
So in your case if we mounted -o nospace_cache then we'll have cleared the v1_active bit and this won't do anything and we'll get -o nospace_cache again. The same goes for the free space tree, we're only allowed to change the disk option for this in certain cases. And in those cases it'll clear the compat flag.
But this is definitely subtle, I'll expand the changelog. Thanks,
Josef
Re: [PATCH v2 09/18] btrfs: add parse_param callback for the new mount api
In reply to David SterbaQuoted 103 lines · David Sterba
Quoted 56 lines · Josef Bacik
The
parse_paramcallback handles one parameter at a time, take our existing mount option parsing loop and adjust it to handle one parameter at a time, and tie it into thefs_context_operations.Create a
btrfs_fs_contextobject that will store the various mount properties, we'll house this infc->fs_private. This is necessary to separate because remounting will use ->reconfigure, and we'll get a new copy of the parsed parameters, so we can no longer directly mess with thefs_infoin this stage.In the future we'll add this to the
btrfs_fs_infoand update the users to use the new context object instead.Signed-off-by Josef Bacik <[email protected]>--- fs/btrfs/super.c | 390 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 390 insertions(+)fs/btrfs/super.c +23
-0@@ -84,6 +84,19 @@ static void btrfs_put_super(struct super_block *sb)close_ctree (btrfs_sb (sb)); } +/* Store the mount options related information. */ +struct btrfs_fs_context { +char *subvol_name; +u64 subvol_objectid; +u64 max_inline; +u32 commit_interval; +u32 metadata_ratio; +u32 thread_pool_size; +unsigned long mount_opt; +unsigned long compress_type:4 ; +unsigned int compress_level; +}; +enum { Opt_acl, Opt_noacl, Opt_clear_cache,@@ -348,6 +361,379 @@ static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { {} }; +static int btrfs_parse_param (struct fs_context *fc, +struct fs_parameter *param) +{ +struct btrfs_fs_context *ctx = fc->fs_private; +struct fs_parse_result result; +int opt; + + opt =fs_parse (fc, btrfs_fs_parameters, param, &result); +if (opt <0 ) +return opt;fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 383
Quoted 10 lines
fs/btrfs/super.c +10
-0+ +switch (opt) { +case Opt_degraded: +btrfs_set_opt (ctx->mount_opt,DEGRADED ); +break ; +case Opt_subvol_empty: +/* +* This exists because we used to allow it on accident, so we're +* keeping it to maintain ABI. See +* 37becec95ac31b209eb1c8e096f1093a7db00f32. Please use the full patch reference
37becec95ac3("Btrfs: allow empty subvol= again"), the subject itself explains why it's here.fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 395
Quoted 12 lines
fs/btrfs/super.c +12
-0+*/ +break ; +case Opt_subvol: +kfree (ctx->subvol_name); + ctx->subvol_name =kstrdup (param->string,GFP_KERNEL ); +if (!ctx->subvol_name) +return -ENOMEM ; +break ; +case Opt_subvolid: + ctx->subvol_objectid = result.uint_64; + +/* subvoldi=0 means give me the original fs_tree. */ subvolid=0
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 405
Quoted 10 lines
fs/btrfs/super.c +10
-0+if (!ctx->subvol_objectid) + ctx->subvol_objectid =BTRFS_FS_TREE_OBJECTID ; +break ; +case Opt_device: { +struct btrfs_device *device; +blk_mode_t mode =sb_open_mode (fc->sb_flags); + +mutex_lock (&uuid_mutex); + device =btrfs_scan_one_device (param->string, mode, false); +mutex_unlock (&uuid_mutex);So this changes how the device option and scan works. At this point the option is in the simple lock/unlock sequence, while currently it's scanning all devices under in one lock and then also opens all the devices. This prevents any other scan to interrupt that so it's either scanned right before (and filling the list) or after (which is a no-op).
Quoted 3 lines
Now it's open to the races, I haven't evaluated if this could be a problem or not.
Udev has been scanning our devices ahead of time for years, this is exactly how it exists currently. I don't think anybody is actually using -o device=<whatever>, but if they are this gives them the same behavior that most people get with the udev rule and mount /dev/oneofthedisks /foo.
If we're really worried about it however I could allocate the strings and attach them to the context here, and then at mount time scan them all to give us the same behavior as we had before.
Quoted 123 lines
Quoted 28 lines
fs/btrfs/super.c +28
-0+if (IS_ERR (device)) +return PTR_ERR (device); +break ; + } +case Opt_datasum: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + } +break ; +case Opt_datacow: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); +btrfs_set_opt (ctx->mount_opt,NODATACOW ); +btrfs_set_opt (ctx->mount_opt,NODATASUM ); + }else { +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); + } +break ; +case Opt_compress_force: +case Opt_compress_force_type: +btrfs_set_opt (ctx->mount_opt,FORCE_COMPRESS ); + fallthrough; +case Opt_compress: +case Opt_compress_type:fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 443
Quoted 10 lines
fs/btrfs/super.c +10
-0+if (opt == Opt_compress || + opt == Opt_compress_force || +strncmp (param->string,"zlib" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZLIB ; + ctx->compress_level =BTRFS_ZLIB_DEFAULT_LEVEL ; +/* +* args[0] contains uninitialized data since +* for these tokens we don't expect any +* parameter. +*/ Please reformat/realign comments that you copy or move
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 449
Quoted 6 lines
fs/btrfs/super.c +6
-0+if (opt != Opt_compress && + opt != Opt_compress_force) + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZLIB , + param->string +4 );This does not need to do newline after "("
Quoted 5 lines
fs/btrfs/super.c +5
-0+btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"lzo" ,3 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_LZO ;fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 464
Quoted 10 lines
fs/btrfs/super.c +10
-0+ ctx->compress_level =0 ; +btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"zstd" ,4 ) ==0 ) { + ctx->compress_type =BTRFS_COMPRESS_ZSTD ; + ctx->compress_level = +btrfs_compress_str2level ( +BTRFS_COMPRESS_ZSTD , + param->string +4 );Same
Quoted 35 lines
fs/btrfs/super.c +35
-0+btrfs_set_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,NODATACOW ); +btrfs_clear_opt (ctx->mount_opt,NODATASUM ); + }else if (strncmp (param->string,"no" ,2 ) ==0 ) { + ctx->compress_level =0 ; + ctx->compress_type =0 ; +btrfs_clear_opt (ctx->mount_opt,COMPRESS ); +btrfs_clear_opt (ctx->mount_opt,FORCE_COMPRESS ); + }else { +btrfs_err (NULL ,"unrecognized compression value %s" , + param->string); +return -EINVAL ; + } +break ; +case Opt_ssd: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSSD ); +btrfs_clear_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_ssd_spread: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,SSD_SPREAD ); + }else { +btrfs_set_opt (ctx->mount_opt,SSD ); +btrfs_set_opt (ctx->mount_opt,SSD_SPREAD ); +btrfs_clear_opt (ctx->mount_opt,NOSSD ); + } +break ; +case Opt_barrier: +if (result.negated)fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 509
Quoted 10 lines
fs/btrfs/super.c +10
-0+btrfs_set_opt (ctx->mount_opt,NOBARRIER ); + else + btrfs_clear_opt(ctx->mount_opt, NOBARRIER); +break ; +case Opt_thread_pool: +if (result.uint_32 ==0 ) { +btrfs_err (NULL ,"invalid value 0 for thread_pool" ); +return -EINVAL ; + } + ctx->thread_pool_size = result.uint_32;It's not in current code but we should eventually clamp the value,
num_online_cpusor similar.fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 512
Quoted 3 lines
fs/btrfs/super.c +3
-0+break ; +case Opt_max_inline: + ctx->max_inline =memparse (param->string,NULL );This does not match, the
max_inlinevalue is adjusted as
Quoted 8 lines
if (info->max_inline) { info->max_inline = min_t(u64, info->max_inline, info->sectorsize); }and it should be validated at the time we parse it, like other options.
We can't do that with the current scheme, tho I did miss clam'ing it. I've added the clamping part to the patch where we flip over to using the new mount API.
Quoted 160 lines
Quoted 140 lines
fs/btrfs/super.c +140
-0+break ; +case Opt_acl: +if (result.negated) { + fc->sb_flags &= ~SB_POSIXACL ; + }else { +#ifdef CONFIG_BTRFS_FS_POSIX_ACL + fc->sb_flags |=SB_POSIXACL ; +#else +btrfs_err (NULL ,"support for ACL not compiled in!" ); + ret = -EINVAL ; + goto out; +#endif + } +/* +* VFS limits the ability to toggle ACL on and off via remount, +* despite every file system allowing this. This seems to be an +* oversight since we all do, but it'll fail if we're +* remounting. So don't set the mask here, we'll check it in +* btrfs_reconfigure and do the toggling ourselves. +*/ +if (fc->purpose !=FS_CONTEXT_FOR_RECONFIGURE ) + fc->sb_flags_mask |=SB_POSIXACL ; +break ; +case Opt_treelog: +if (result.negated) +btrfs_set_opt (ctx->mount_opt,NOTREELOG ); +else +btrfs_clear_opt (ctx->mount_opt,NOTREELOG ); +break ; +case Opt_recovery: +/* +* -o recovery used to be an alias for usebackuproot, and then +* norecovery was an alias for nologreplay, hence the different +* behaviors for negated and not. +*/ +if (result.negated) { +btrfs_warn (NULL , +"'norecovery' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); + }else { +btrfs_warn (NULL , +"'recovery' is deprecated, use 'rescue=usebackuproot' instead" ); +btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); + } +break ; +case Opt_nologreplay: +btrfs_warn (NULL , +"'nologreplay' is deprecated, use 'rescue=nologreplay' instead" ); +btrfs_set_opt (ctx->mount_opt,NOLOGREPLAY ); +break ; +case Opt_flushoncommit: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,FLUSHONCOMMIT ); +else +btrfs_set_opt (ctx->mount_opt,FLUSHONCOMMIT ); +break ; +case Opt_ratio: + ctx->metadata_ratio = result.uint_32; +break ; +case Opt_discard: +if (result.negated) { +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,NODISCARD ); + }else { +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); + } +break ; +case Opt_discard_mode: +switch (result.uint_32) { +case Opt_discard_sync: +btrfs_clear_opt (ctx->mount_opt,DISCARD_ASYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_SYNC ); +break ; +case Opt_discard_async: +btrfs_clear_opt (ctx->mount_opt,DISCARD_SYNC ); +btrfs_set_opt (ctx->mount_opt,DISCARD_ASYNC ); +break ; +default : +btrfs_err (NULL ,"unrecognized discard mode value %s" , + param->key); +return -EINVAL ; + } +btrfs_clear_opt (ctx->mount_opt,NODISCARD ); +break ; +case Opt_space_cache: +if (result.negated) { +btrfs_set_opt (ctx->mount_opt,NOSPACECACHE ); +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); + }else { +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); + } +break ; +case Opt_space_cache_version: +switch (result.uint_32) { +case Opt_space_cache_v1: +btrfs_set_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_clear_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +case Opt_space_cache_v2: +btrfs_clear_opt (ctx->mount_opt,SPACE_CACHE ); +btrfs_set_opt (ctx->mount_opt,FREE_SPACE_TREE ); +break ; +default : +btrfs_err (NULL ,"unrecognized space_cache value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_rescan_uuid_tree: +btrfs_set_opt (ctx->mount_opt,RESCAN_UUID_TREE ); +break ; +case Opt_inode_cache: +btrfs_warn (NULL , +"the 'inode_cache' option is deprecated and has no effect since 5.11" ); +break ; +case Opt_clear_cache: +btrfs_set_opt (ctx->mount_opt,CLEAR_CACHE ); +break ; +case Opt_user_subvol_rm_allowed: +btrfs_set_opt (ctx->mount_opt,USER_SUBVOL_RM_ALLOWED ); +break ; +case Opt_enospc_debug: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,ENOSPC_DEBUG ); +else +btrfs_set_opt (ctx->mount_opt,ENOSPC_DEBUG ); +break ; +case Opt_defrag: +if (result.negated) +btrfs_clear_opt (ctx->mount_opt,AUTO_DEFRAG ); +else +btrfs_set_opt (ctx->mount_opt,AUTO_DEFRAG ); +break ; +case Opt_usebackuproot: +btrfs_warn (NULL , +"'usebackuproot' is deprecated, use 'rescue=usebackuproot' instead" );fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 662
Quoted 10 lines
fs/btrfs/super.c +10
-0+btrfs_set_opt (ctx->mount_opt,USEBACKUPROOT ); +break ; +case Opt_skip_balance: +btrfs_set_opt (ctx->mount_opt,SKIP_BALANCE ); +break ; +case Opt_fatal_errors: +switch (result.uint_32) { +case Opt_fatal_errors_panic: +btrfs_set_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR );Lines can be joined
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 666
Quoted 4 lines
fs/btrfs/super.c +4
-0+break ; +case Opt_fatal_errors_bug: +btrfs_clear_opt (ctx->mount_opt, +PANIC_ON_FATAL_ERROR );Same
Quoted 15 lines
fs/btrfs/super.c static const struct fs_parameter_spec btrfs_fs_parameters[] __maybe_unused = { · line 677
Quoted 11 lines
fs/btrfs/super.c +11
-0+break ; +default : +btrfs_err (NULL ,"unrecognized fatal_errors value %s" , + param->key); +return -EINVAL ; + } +break ; +case Opt_commit_interval: + ctx->commit_interval = result.uint_32; +if (!ctx->commit_interval) + ctx->commit_interval =BTRFS_DEFAULT_COMMIT_INTERVAL ;And the value of
commit_intervalis also adjusted in current code, this should be done here as well.
It isn't adjusted, we just yell if it's above 300. If you do -o commit_interval=0 it wants the default interval, which is what I've handled here. Thanks,
Josef