btrfs: Cleanup the btrfs_parse_options for remount.

Since remount will pending the new mount options to the original mount
options, which will make btrfs_parse_options check the old options then
new options, causing some stupid output like "enabling XXX" following by
"disable XXX".

This patch will add extra check before every btrfs_info to skip the
output from old options checking.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>

1 files changed, 77 insertions, 60 deletions

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 362aef44a17b..c02f63356895 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -383,6 +383,20 @@ static match_table_t tokens = {
         {Opt_err, NULL},
 };
 
+#define btrfs_set_and_info(root, opt, fmt, args...)                     \
+{                                                                       \
+        if (!btrfs_test_opt(root, opt))                                 \
+                btrfs_info(root->fs_info, fmt, ##args);                 \
+        btrfs_set_opt(root->fs_info->mount_opt, opt);                   \
+}
+
+#define btrfs_clear_and_info(root, opt, fmt, args...)                   \
+{                                                                       \
+        if (btrfs_test_opt(root, opt))                                  \
+                btrfs_info(root->fs_info, fmt, ##args);                 \
+        btrfs_clear_opt(root->fs_info->mount_opt, opt);                 \
+}
+
 /*
  * Regular mount options parser.  Everything that is needed only when
  * reading in a new superblock is parsed here.
@@ -398,6 +412,7 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
         int ret = 0;
         char *compress_type;
         bool compress_force = false;
+        bool compress = false;
 
         cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
         if (cache_gen)
@@ -437,24 +452,28 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                          */
                         break;
                 case Opt_nodatasum:
-                        btrfs_info(root->fs_info, "setting nodatasum");
-                        btrfs_set_opt(info->mount_opt, NODATASUM);
+                        btrfs_set_and_info(root, NODATASUM,
+                                           "setting nodatasum");
                         break;
                 case Opt_datasum:
-                        if (btrfs_test_opt(root, NODATACOW))
-                                btrfs_info(root->fs_info, "setting datasum, datacow enabled");
-                        else
-                                btrfs_info(root->fs_info, "setting datasum");
+                        if (btrfs_test_opt(root, NODATASUM)) {
+                                if (btrfs_test_opt(root, NODATACOW))
+                                        btrfs_info(root->fs_info, "setting datasum, datacow enabled");
+                                else
+                                        btrfs_info(root->fs_info, "setting datasum");
+                        }
                         btrfs_clear_opt(info->mount_opt, NODATACOW);
                         btrfs_clear_opt(info->mount_opt, NODATASUM);
                         break;
                 case Opt_nodatacow:
-                        if (!btrfs_test_opt(root, COMPRESS) ||
-                                !btrfs_test_opt(root, FORCE_COMPRESS)) {
+                        if (!btrfs_test_opt(root, NODATACOW)) {
+                                if (!btrfs_test_opt(root, COMPRESS) ||
+                                    !btrfs_test_opt(root, FORCE_COMPRESS)) {
                                         btrfs_info(root->fs_info,
-                                                "setting nodatacow, compression disabled");
-                        } else {
-                                btrfs_info(root->fs_info, "setting nodatacow");
+                                                   "setting nodatacow, compression disabled");
+                                } else {
+                                        btrfs_info(root->fs_info, "setting nodatacow");
+                                }
                         }
                         btrfs_clear_opt(info->mount_opt, COMPRESS);
                         btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
@@ -462,9 +481,8 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_set_opt(info->mount_opt, NODATASUM);
                         break;
                 case Opt_datacow:
-                        if (btrfs_test_opt(root, NODATACOW))
-                                btrfs_info(root->fs_info, "setting datacow");
-                        btrfs_clear_opt(info->mount_opt, NODATACOW);
+                        btrfs_clear_and_info(root, NODATACOW,
+                                             "setting datacow");
                         break;
                 case Opt_compress_force:
                 case Opt_compress_force_type:
@@ -472,6 +490,7 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         /* Fallthrough */
                 case Opt_compress:
                 case Opt_compress_type:
+                        compress = true;
                         if (token == Opt_compress ||
                             token == Opt_compress_force ||
                             strcmp(args[0].from, "zlib") == 0) {
@@ -498,37 +517,36 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         }
 
                         if (compress_force) {
-                                btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
-                                btrfs_info(root->fs_info, "force %s compression",
-                                        compress_type);
-                        } else if (btrfs_test_opt(root, COMPRESS)) {
-                                pr_info("btrfs: use %s compression\n",
-                                        compress_type);
+                                btrfs_set_and_info(root, FORCE_COMPRESS,
+                                                   "force %s compression",
+                                                   compress_type);
+                        } else if (compress) {
+                                if (!btrfs_test_opt(root, COMPRESS))
+                                        btrfs_info(root->fs_info,
+                                                   "btrfs: use %s compression\n",
+                                                   compress_type);
                         }
                         break;
                 case Opt_ssd:
-                        btrfs_info(root->fs_info, "use ssd allocation scheme");
-                        btrfs_set_opt(info->mount_opt, SSD);
+                        btrfs_set_and_info(root, SSD,
+                                           "use ssd allocation scheme");
                         break;
                 case Opt_ssd_spread:
-                        btrfs_info(root->fs_info, "use spread ssd allocation scheme");
-                        btrfs_set_opt(info->mount_opt, SSD);
-                        btrfs_set_opt(info->mount_opt, SSD_SPREAD);
+                        btrfs_set_and_info(root, SSD_SPREAD,
+                                           "use spread ssd allocation scheme");
                         break;
                 case Opt_nossd:
-                        btrfs_info(root->fs_info, "not using ssd allocation scheme");
-                        btrfs_set_opt(info->mount_opt, NOSSD);
+                        btrfs_clear_and_info(root, NOSSD,
+                                             "not using ssd allocation scheme");
                         btrfs_clear_opt(info->mount_opt, SSD);
-                        btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
                         break;
                 case Opt_barrier:
-                        if (btrfs_test_opt(root, NOBARRIER))
-                                btrfs_info(root->fs_info, "turning on barriers");
-                        btrfs_clear_opt(info->mount_opt, NOBARRIER);
+                        btrfs_clear_and_info(root, NOBARRIER,
+                                             "turning on barriers");
                         break;
                 case Opt_nobarrier:
-                        btrfs_info(root->fs_info, "turning off barriers");
-                        btrfs_set_opt(info->mount_opt, NOBARRIER);
+                        btrfs_set_and_info(root, NOBARRIER,
+                                           "turning off barriers");
                         break;
                 case Opt_thread_pool:
                         ret = match_int(&args[0], &intarg);
@@ -580,22 +598,20 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         root->fs_info->sb->s_flags &= ~MS_POSIXACL;
                         break;
                 case Opt_notreelog:
-                        btrfs_info(root->fs_info, "disabling tree log");
-                        btrfs_set_opt(info->mount_opt, NOTREELOG);
+                        btrfs_set_and_info(root, NOTREELOG,
+                                           "disabling tree log");
                         break;
                 case Opt_treelog:
-                        if (btrfs_test_opt(root, NOTREELOG))
-                                btrfs_info(root->fs_info, "enabling tree log");
-                        btrfs_clear_opt(info->mount_opt, NOTREELOG);
+                        btrfs_clear_and_info(root, NOTREELOG,
+                                             "enabling tree log");
                         break;
                 case Opt_flushoncommit:
-                        btrfs_info(root->fs_info, "turning on flush-on-commit");
-                        btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
+                        btrfs_set_and_info(root, FLUSHONCOMMIT,
+                                           "turning on flush-on-commit");
                         break;
                 case Opt_noflushoncommit:
-                        if (btrfs_test_opt(root, FLUSHONCOMMIT))
-                                btrfs_info(root->fs_info, "turning off flush-on-commit");
-                        btrfs_clear_opt(info->mount_opt, FLUSHONCOMMIT);
+                        btrfs_clear_and_info(root, FLUSHONCOMMIT,
+                                             "turning off flush-on-commit");
                         break;
                 case Opt_ratio:
                         ret = match_int(&args[0], &intarg);
@@ -611,33 +627,35 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         }
                         break;
                 case Opt_discard:
-                        btrfs_set_opt(info->mount_opt, DISCARD);
+                        btrfs_set_and_info(root, DISCARD,
+                                           "turning on discard");
                         break;
                 case Opt_nodiscard:
-                        btrfs_clear_opt(info->mount_opt, DISCARD);
+                        btrfs_clear_and_info(root, DISCARD,
+                                             "turning off discard");
                         break;
                 case Opt_space_cache:
-                        btrfs_set_opt(info->mount_opt, SPACE_CACHE);
+                        btrfs_set_and_info(root, SPACE_CACHE,
+                                           "enabling disk space caching");
                         break;
                 case Opt_rescan_uuid_tree:
                         btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
                         break;
                 case Opt_no_space_cache:
-                        btrfs_info(root->fs_info, "disabling disk space caching");
-                        btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
+                        btrfs_clear_and_info(root, SPACE_CACHE,
+                                             "disabling disk space caching");
                         break;
                 case Opt_inode_cache:
-                        btrfs_info(root->fs_info, "enabling inode map caching");
-                        btrfs_set_opt(info->mount_opt, CHANGE_INODE_CACHE);
+                        btrfs_set_and_info(root, CHANGE_INODE_CACHE,
+                                           "enabling inode map caching");
                         break;
                 case Opt_noinode_cache:
-                        if (btrfs_test_opt(root, CHANGE_INODE_CACHE))
-                                btrfs_info(root->fs_info, "disabling inode map caching");
-                        btrfs_clear_opt(info->mount_opt, CHANGE_INODE_CACHE);
+                        btrfs_clear_and_info(root, CHANGE_INODE_CACHE,
+                                             "disabling inode map caching");
                         break;
                 case Opt_clear_cache:
-                        btrfs_info(root->fs_info, "force clearing of disk cache");
-                        btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
+                        btrfs_set_and_info(root, CLEAR_CACHE,
+                                           "force clearing of disk cache");
                         break;
                 case Opt_user_subvol_rm_allowed:
                         btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
@@ -649,13 +667,12 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
                         break;
                 case Opt_defrag:
-                        btrfs_info(root->fs_info, "enabling auto defrag");
-                        btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
+                        btrfs_set_and_info(root, AUTO_DEFRAG,
+                                           "enabling auto defrag");
                         break;
                 case Opt_nodefrag:
-                        if (btrfs_test_opt(root, AUTO_DEFRAG))
-                                btrfs_info(root->fs_info, "disabling auto defrag");
-                        btrfs_clear_opt(info->mount_opt, AUTO_DEFRAG);
+                        btrfs_clear_and_info(root, AUTO_DEFRAG,
+                                             "disabling auto defrag");
                         break;
                 case Opt_recovery:
                         btrfs_info(root->fs_info, "enabling auto recovery");