| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <202207271931.UabOC5c3-lkp@intel.com>
Date: Wed, 27 Jul 2022 20:02:20 +0800
From: kernel test robot <lkp@...el.com>
To: David Sterba <dsterba@...e.com>
Cc: kbuild-all@...ts.01.org, linux-kernel@...r.kernel.org
Subject: [kdave-btrfs-devel:dev/async-discard-on 164/164]
fs/btrfs/super.c:918:41: error: 'fs_info' undeclared; did you mean
'qc_info'?
tree: https://github.com/kdave/btrfs-devel.git dev/async-discard-on
head: 3ee5caaf11a2ab543b93da9bf106e7ba9d9cd530
commit: 3ee5caaf11a2ab543b93da9bf106e7ba9d9cd530 [164/164] auto enable discard=async
config: arc-randconfig-r043-20220724 (https://download.01.org/0day-ci/archive/20220727/202207271931.UabOC5c3-lkp@intel.com/config)
compiler: arc-elf-gcc (GCC) 12.1.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/kdave/btrfs-devel/commit/3ee5caaf11a2ab543b93da9bf106e7ba9d9cd530
git remote add kdave-btrfs-devel https://github.com/kdave/btrfs-devel.git
git fetch --no-tags kdave-btrfs-devel dev/async-discard-on
git checkout 3ee5caaf11a2ab543b93da9bf106e7ba9d9cd530
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=arc SHELL=/bin/bash fs/
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp@...el.com>
All errors (new ones prefixed by >>):
In file included from fs/btrfs/delayed-inode.h:17,
from fs/btrfs/super.c:29:
fs/btrfs/super.c: In function 'btrfs_parse_options':
>> fs/btrfs/super.c:918:41: error: 'fs_info' undeclared (first use in this function); did you mean 'qc_info'?
918 | btrfs_clear_opt(fs_info->mount_opt, NODISCARD);
| ^~~~~~~
fs/btrfs/ctree.h:1512:43: note: in definition of macro 'btrfs_clear_opt'
1512 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
| ^
fs/btrfs/super.c:918:41: note: each undeclared identifier is reported only once for each function it appears in
918 | btrfs_clear_opt(fs_info->mount_opt, NODISCARD);
| ^~~~~~~
fs/btrfs/ctree.h:1512:43: note: in definition of macro 'btrfs_clear_opt'
1512 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
| ^
--
In file included from fs/btrfs/disk-io.c:22:
fs/btrfs/disk-io.c: In function 'open_ctree':
>> fs/btrfs/disk-io.c:3777:15: error: implicit declaration of function 'btrfs_test_opt' [-Werror=implicit-function-declaration]
3777 | btrfs_test_opt(fs_info, NODISCARD))) &&
| ^~~~~~~~~~~~~~
fs/btrfs/ctree.h:1516:56: note: in definition of macro 'btrfs_test_opt'
1516 | BTRFS_MOUNT_##opt)
| ^~~
>> fs/btrfs/disk-io.c:3777:39: error: 'NODISCARD' undeclared (first use in this function); did you mean 'BLKDISCARD'?
3777 | btrfs_test_opt(fs_info, NODISCARD))) &&
| ^~~~~~~~~
fs/btrfs/ctree.h:1516:56: note: in definition of macro 'btrfs_test_opt'
1516 | BTRFS_MOUNT_##opt)
| ^~~
fs/btrfs/disk-io.c:3777:39: note: each undeclared identifier is reported only once for each function it appears in
3777 | btrfs_test_opt(fs_info, NODISCARD))) &&
| ^~~~~~~~~
fs/btrfs/ctree.h:1516:56: note: in definition of macro 'btrfs_test_opt'
1516 | BTRFS_MOUNT_##opt)
| ^~~
>> fs/btrfs/ctree.h:1512:46: error: invalid operands to binary & (have 'struct btrfs_fs_info *' and 'unsigned int')
1512 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
| ^~
fs/btrfs/disk-io.c:3781:15: note: in expansion of macro 'btrfs_clear_opt'
3781 | btrfs_clear_opt(fs_info, NODISCARD);
| ^~~~~~~~~~~~~~~
cc1: some warnings being treated as errors
vim +918 fs/btrfs/super.c
610
611 /*
612 * Regular mount options parser. Everything that is needed only when
613 * reading in a new superblock is parsed here.
614 * XXX JDM: This needs to be cleaned up for remount.
615 */
616 int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
617 unsigned long new_flags)
618 {
619 substring_t args[MAX_OPT_ARGS];
620 char *p, *num;
621 int intarg;
622 int ret = 0;
623 char *compress_type;
624 bool compress_force = false;
625 enum btrfs_compression_type saved_compress_type;
626 int saved_compress_level;
627 bool saved_compress_force;
628 int no_compress = 0;
629
630 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
631 btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
632 else if (btrfs_free_space_cache_v1_active(info)) {
633 if (btrfs_is_zoned(info)) {
634 btrfs_info(info,
635 "zoned: clearing existing space cache");
636 btrfs_set_super_cache_generation(info->super_copy, 0);
637 } else {
638 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
639 }
640 }
641
642 /*
643 * Even the options are empty, we still need to do extra check
644 * against new flags
645 */
646 if (!options)
647 goto check;
648
649 while ((p = strsep(&options, ",")) != NULL) {
650 int token;
651 if (!*p)
652 continue;
653
654 token = match_token(p, tokens, args);
655 switch (token) {
656 case Opt_degraded:
657 btrfs_info(info, "allowing degraded mounts");
658 btrfs_set_opt(info->mount_opt, DEGRADED);
659 break;
660 case Opt_subvol:
661 case Opt_subvol_empty:
662 case Opt_subvolid:
663 case Opt_device:
664 /*
665 * These are parsed by btrfs_parse_subvol_options or
666 * btrfs_parse_device_options and can be ignored here.
667 */
668 break;
669 case Opt_nodatasum:
670 btrfs_set_and_info(info, NODATASUM,
671 "setting nodatasum");
672 break;
673 case Opt_datasum:
674 if (btrfs_test_opt(info, NODATASUM)) {
675 if (btrfs_test_opt(info, NODATACOW))
676 btrfs_info(info,
677 "setting datasum, datacow enabled");
678 else
679 btrfs_info(info, "setting datasum");
680 }
681 btrfs_clear_opt(info->mount_opt, NODATACOW);
682 btrfs_clear_opt(info->mount_opt, NODATASUM);
683 break;
684 case Opt_nodatacow:
685 if (!btrfs_test_opt(info, NODATACOW)) {
686 if (!btrfs_test_opt(info, COMPRESS) ||
687 !btrfs_test_opt(info, FORCE_COMPRESS)) {
688 btrfs_info(info,
689 "setting nodatacow, compression disabled");
690 } else {
691 btrfs_info(info, "setting nodatacow");
692 }
693 }
694 btrfs_clear_opt(info->mount_opt, COMPRESS);
695 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
696 btrfs_set_opt(info->mount_opt, NODATACOW);
697 btrfs_set_opt(info->mount_opt, NODATASUM);
698 break;
699 case Opt_datacow:
700 btrfs_clear_and_info(info, NODATACOW,
701 "setting datacow");
702 break;
703 case Opt_compress_force:
704 case Opt_compress_force_type:
705 compress_force = true;
706 fallthrough;
707 case Opt_compress:
708 case Opt_compress_type:
709 saved_compress_type = btrfs_test_opt(info,
710 COMPRESS) ?
711 info->compress_type : BTRFS_COMPRESS_NONE;
712 saved_compress_force =
713 btrfs_test_opt(info, FORCE_COMPRESS);
714 saved_compress_level = info->compress_level;
715 if (token == Opt_compress ||
716 token == Opt_compress_force ||
717 strncmp(args[0].from, "zlib", 4) == 0) {
718 compress_type = "zlib";
719
720 info->compress_type = BTRFS_COMPRESS_ZLIB;
721 info->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL;
722 /*
723 * args[0] contains uninitialized data since
724 * for these tokens we don't expect any
725 * parameter.
726 */
727 if (token != Opt_compress &&
728 token != Opt_compress_force)
729 info->compress_level =
730 btrfs_compress_str2level(
731 BTRFS_COMPRESS_ZLIB,
732 args[0].from + 4);
733 btrfs_set_opt(info->mount_opt, COMPRESS);
734 btrfs_clear_opt(info->mount_opt, NODATACOW);
735 btrfs_clear_opt(info->mount_opt, NODATASUM);
736 no_compress = 0;
737 } else if (strncmp(args[0].from, "lzo", 3) == 0) {
738 compress_type = "lzo";
739 info->compress_type = BTRFS_COMPRESS_LZO;
740 info->compress_level = 0;
741 btrfs_set_opt(info->mount_opt, COMPRESS);
742 btrfs_clear_opt(info->mount_opt, NODATACOW);
743 btrfs_clear_opt(info->mount_opt, NODATASUM);
744 btrfs_set_fs_incompat(info, COMPRESS_LZO);
745 no_compress = 0;
746 } else if (strncmp(args[0].from, "zstd", 4) == 0) {
747 compress_type = "zstd";
748 info->compress_type = BTRFS_COMPRESS_ZSTD;
749 info->compress_level =
750 btrfs_compress_str2level(
751 BTRFS_COMPRESS_ZSTD,
752 args[0].from + 4);
753 btrfs_set_opt(info->mount_opt, COMPRESS);
754 btrfs_clear_opt(info->mount_opt, NODATACOW);
755 btrfs_clear_opt(info->mount_opt, NODATASUM);
756 btrfs_set_fs_incompat(info, COMPRESS_ZSTD);
757 no_compress = 0;
758 } else if (strncmp(args[0].from, "no", 2) == 0) {
759 compress_type = "no";
760 info->compress_level = 0;
761 info->compress_type = 0;
762 btrfs_clear_opt(info->mount_opt, COMPRESS);
763 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
764 compress_force = false;
765 no_compress++;
766 } else {
767 btrfs_err(info, "unrecognized compression value %s",
768 args[0].from);
769 ret = -EINVAL;
770 goto out;
771 }
772
773 if (compress_force) {
774 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
775 } else {
776 /*
777 * If we remount from compress-force=xxx to
778 * compress=xxx, we need clear FORCE_COMPRESS
779 * flag, otherwise, there is no way for users
780 * to disable forcible compression separately.
781 */
782 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
783 }
784 if (no_compress == 1) {
785 btrfs_info(info, "use no compression");
786 } else if ((info->compress_type != saved_compress_type) ||
787 (compress_force != saved_compress_force) ||
788 (info->compress_level != saved_compress_level)) {
789 btrfs_info(info, "%s %s compression, level %d",
790 (compress_force) ? "force" : "use",
791 compress_type, info->compress_level);
792 }
793 compress_force = false;
794 break;
795 case Opt_ssd:
796 btrfs_set_and_info(info, SSD,
797 "enabling ssd optimizations");
798 btrfs_clear_opt(info->mount_opt, NOSSD);
799 break;
800 case Opt_ssd_spread:
801 btrfs_set_and_info(info, SSD,
802 "enabling ssd optimizations");
803 btrfs_set_and_info(info, SSD_SPREAD,
804 "using spread ssd allocation scheme");
805 btrfs_clear_opt(info->mount_opt, NOSSD);
806 break;
807 case Opt_nossd:
808 btrfs_set_opt(info->mount_opt, NOSSD);
809 btrfs_clear_and_info(info, SSD,
810 "not using ssd optimizations");
811 fallthrough;
812 case Opt_nossd_spread:
813 btrfs_clear_and_info(info, SSD_SPREAD,
814 "not using spread ssd allocation scheme");
815 break;
816 case Opt_barrier:
817 btrfs_clear_and_info(info, NOBARRIER,
818 "turning on barriers");
819 break;
820 case Opt_nobarrier:
821 btrfs_set_and_info(info, NOBARRIER,
822 "turning off barriers");
823 break;
824 case Opt_thread_pool:
825 ret = match_int(&args[0], &intarg);
826 if (ret) {
827 btrfs_err(info, "unrecognized thread_pool value %s",
828 args[0].from);
829 goto out;
830 } else if (intarg == 0) {
831 btrfs_err(info, "invalid value 0 for thread_pool");
832 ret = -EINVAL;
833 goto out;
834 }
835 info->thread_pool_size = intarg;
836 break;
837 case Opt_max_inline:
838 num = match_strdup(&args[0]);
839 if (num) {
840 info->max_inline = memparse(num, NULL);
841 kfree(num);
842
843 if (info->max_inline) {
844 info->max_inline = min_t(u64,
845 info->max_inline,
846 info->sectorsize);
847 }
848 btrfs_info(info, "max_inline at %llu",
849 info->max_inline);
850 } else {
851 ret = -ENOMEM;
852 goto out;
853 }
854 break;
855 case Opt_acl:
856 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
857 info->sb->s_flags |= SB_POSIXACL;
858 break;
859 #else
860 btrfs_err(info, "support for ACL not compiled in!");
861 ret = -EINVAL;
862 goto out;
863 #endif
864 case Opt_noacl:
865 info->sb->s_flags &= ~SB_POSIXACL;
866 break;
867 case Opt_notreelog:
868 btrfs_set_and_info(info, NOTREELOG,
869 "disabling tree log");
870 break;
871 case Opt_treelog:
872 btrfs_clear_and_info(info, NOTREELOG,
873 "enabling tree log");
874 break;
875 case Opt_norecovery:
876 case Opt_nologreplay:
877 btrfs_warn(info,
878 "'nologreplay' is deprecated, use 'rescue=nologreplay' instead");
879 btrfs_set_and_info(info, NOLOGREPLAY,
880 "disabling log replay at mount time");
881 break;
882 case Opt_flushoncommit:
883 btrfs_set_and_info(info, FLUSHONCOMMIT,
884 "turning on flush-on-commit");
885 break;
886 case Opt_noflushoncommit:
887 btrfs_clear_and_info(info, FLUSHONCOMMIT,
888 "turning off flush-on-commit");
889 break;
890 case Opt_ratio:
891 ret = match_int(&args[0], &intarg);
892 if (ret) {
893 btrfs_err(info, "unrecognized metadata_ratio value %s",
894 args[0].from);
895 goto out;
896 }
897 info->metadata_ratio = intarg;
898 btrfs_info(info, "metadata ratio %u",
899 info->metadata_ratio);
900 break;
901 case Opt_discard:
902 case Opt_discard_mode:
903 if (token == Opt_discard ||
904 strcmp(args[0].from, "sync") == 0) {
905 btrfs_clear_opt(info->mount_opt, DISCARD_ASYNC);
906 btrfs_set_and_info(info, DISCARD_SYNC,
907 "turning on sync discard");
908 } else if (strcmp(args[0].from, "async") == 0) {
909 btrfs_clear_opt(info->mount_opt, DISCARD_SYNC);
910 btrfs_set_and_info(info, DISCARD_ASYNC,
911 "turning on async discard");
912 } else {
913 btrfs_err(info, "unrecognized discard mode value %s",
914 args[0].from);
915 ret = -EINVAL;
916 goto out;
917 }
> 918 btrfs_clear_opt(fs_info->mount_opt, NODISCARD);
919 break;
920 case Opt_nodiscard:
921 btrfs_clear_and_info(info, DISCARD_SYNC,
922 "turning off discard");
923 btrfs_clear_and_info(info, DISCARD_ASYNC,
924 "turning off async discard");
925 btrfs_set_opt(fs_info->mount_opt, NODISCARD);
926 break;
927 case Opt_space_cache:
928 case Opt_space_cache_version:
929 /*
930 * We already set FREE_SPACE_TREE above because we have
931 * compat_ro(FREE_SPACE_TREE) set, and we aren't going
932 * to allow v1 to be set for extent tree v2, simply
933 * ignore this setting if we're extent tree v2.
934 */
935 if (btrfs_fs_incompat(info, EXTENT_TREE_V2))
936 break;
937 if (token == Opt_space_cache ||
938 strcmp(args[0].from, "v1") == 0) {
939 btrfs_clear_opt(info->mount_opt,
940 FREE_SPACE_TREE);
941 btrfs_set_and_info(info, SPACE_CACHE,
942 "enabling disk space caching");
943 } else if (strcmp(args[0].from, "v2") == 0) {
944 btrfs_clear_opt(info->mount_opt,
945 SPACE_CACHE);
946 btrfs_set_and_info(info, FREE_SPACE_TREE,
947 "enabling free space tree");
948 } else {
949 btrfs_err(info, "unrecognized space_cache value %s",
950 args[0].from);
951 ret = -EINVAL;
952 goto out;
953 }
954 break;
955 case Opt_rescan_uuid_tree:
956 btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
957 break;
958 case Opt_no_space_cache:
959 /*
960 * We cannot operate without the free space tree with
961 * extent tree v2, ignore this option.
962 */
963 if (btrfs_fs_incompat(info, EXTENT_TREE_V2))
964 break;
965 if (btrfs_test_opt(info, SPACE_CACHE)) {
966 btrfs_clear_and_info(info, SPACE_CACHE,
967 "disabling disk space caching");
968 }
969 if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
970 btrfs_clear_and_info(info, FREE_SPACE_TREE,
971 "disabling free space tree");
972 }
973 break;
974 case Opt_inode_cache:
975 case Opt_noinode_cache:
976 btrfs_warn(info,
977 "the 'inode_cache' option is deprecated and has no effect since 5.11");
978 break;
979 case Opt_clear_cache:
980 /*
981 * We cannot clear the free space tree with extent tree
982 * v2, ignore this option.
983 */
984 if (btrfs_fs_incompat(info, EXTENT_TREE_V2))
985 break;
986 btrfs_set_and_info(info, CLEAR_CACHE,
987 "force clearing of disk cache");
988 break;
989 case Opt_user_subvol_rm_allowed:
990 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
991 break;
992 case Opt_enospc_debug:
993 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
994 break;
995 case Opt_noenospc_debug:
996 btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
997 break;
998 case Opt_defrag:
999 btrfs_set_and_info(info, AUTO_DEFRAG,
1000 "enabling auto defrag");
1001 break;
1002 case Opt_nodefrag:
1003 btrfs_clear_and_info(info, AUTO_DEFRAG,
1004 "disabling auto defrag");
1005 break;
1006 case Opt_recovery:
1007 case Opt_usebackuproot:
1008 btrfs_warn(info,
1009 "'%s' is deprecated, use 'rescue=usebackuproot' instead",
1010 token == Opt_recovery ? "recovery" :
1011 "usebackuproot");
1012 btrfs_info(info,
1013 "trying to use backup root at mount time");
1014 btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
1015 break;
1016 case Opt_skip_balance:
1017 btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
1018 break;
1019 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1020 case Opt_check_integrity_including_extent_data:
1021 btrfs_info(info,
1022 "enabling check integrity including extent data");
1023 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY_DATA);
1024 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
1025 break;
1026 case Opt_check_integrity:
1027 btrfs_info(info, "enabling check integrity");
1028 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
1029 break;
1030 case Opt_check_integrity_print_mask:
1031 ret = match_int(&args[0], &intarg);
1032 if (ret) {
1033 btrfs_err(info,
1034 "unrecognized check_integrity_print_mask value %s",
1035 args[0].from);
1036 goto out;
1037 }
1038 info->check_integrity_print_mask = intarg;
1039 btrfs_info(info, "check_integrity_print_mask 0x%x",
1040 info->check_integrity_print_mask);
1041 break;
1042 #else
1043 case Opt_check_integrity_including_extent_data:
1044 case Opt_check_integrity:
1045 case Opt_check_integrity_print_mask:
1046 btrfs_err(info,
1047 "support for check_integrity* not compiled in!");
1048 ret = -EINVAL;
1049 goto out;
1050 #endif
1051 case Opt_fatal_errors:
1052 if (strcmp(args[0].from, "panic") == 0) {
1053 btrfs_set_opt(info->mount_opt,
1054 PANIC_ON_FATAL_ERROR);
1055 } else if (strcmp(args[0].from, "bug") == 0) {
1056 btrfs_clear_opt(info->mount_opt,
1057 PANIC_ON_FATAL_ERROR);
1058 } else {
1059 btrfs_err(info, "unrecognized fatal_errors value %s",
1060 args[0].from);
1061 ret = -EINVAL;
1062 goto out;
1063 }
1064 break;
1065 case Opt_commit_interval:
1066 intarg = 0;
1067 ret = match_int(&args[0], &intarg);
1068 if (ret) {
1069 btrfs_err(info, "unrecognized commit_interval value %s",
1070 args[0].from);
1071 ret = -EINVAL;
1072 goto out;
1073 }
1074 if (intarg == 0) {
1075 btrfs_info(info,
1076 "using default commit interval %us",
1077 BTRFS_DEFAULT_COMMIT_INTERVAL);
1078 intarg = BTRFS_DEFAULT_COMMIT_INTERVAL;
1079 } else if (intarg > 300) {
1080 btrfs_warn(info, "excessive commit interval %d",
1081 intarg);
1082 }
1083 info->commit_interval = intarg;
1084 break;
1085 case Opt_rescue:
1086 ret = parse_rescue_options(info, args[0].from);
1087 if (ret < 0) {
1088 btrfs_err(info, "unrecognized rescue value %s",
1089 args[0].from);
1090 goto out;
1091 }
1092 break;
1093 #ifdef CONFIG_BTRFS_DEBUG
1094 case Opt_fragment_all:
1095 btrfs_info(info, "fragmenting all space");
1096 btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
1097 btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
1098 break;
1099 case Opt_fragment_metadata:
1100 btrfs_info(info, "fragmenting metadata");
1101 btrfs_set_opt(info->mount_opt,
1102 FRAGMENT_METADATA);
1103 break;
1104 case Opt_fragment_data:
1105 btrfs_info(info, "fragmenting data");
1106 btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
1107 break;
1108 #endif
1109 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
1110 case Opt_ref_verify:
1111 btrfs_info(info, "doing ref verification");
1112 btrfs_set_opt(info->mount_opt, REF_VERIFY);
1113 break;
1114 #endif
1115 case Opt_err:
1116 btrfs_err(info, "unrecognized mount option '%s'", p);
1117 ret = -EINVAL;
1118 goto out;
1119 default:
1120 break;
1121 }
1122 }
1123 check:
1124 /* We're read-only, don't have to check. */
1125 if (new_flags & SB_RDONLY)
1126 goto out;
1127
1128 if (check_ro_option(info, BTRFS_MOUNT_NOLOGREPLAY, "nologreplay") ||
1129 check_ro_option(info, BTRFS_MOUNT_IGNOREBADROOTS, "ignorebadroots") ||
1130 check_ro_option(info, BTRFS_MOUNT_IGNOREDATACSUMS, "ignoredatacsums"))
1131 ret = -EINVAL;
1132 out:
1133 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) &&
1134 !btrfs_test_opt(info, FREE_SPACE_TREE) &&
1135 !btrfs_test_opt(info, CLEAR_CACHE)) {
1136 btrfs_err(info, "cannot disable free space tree");
1137 ret = -EINVAL;
1138
1139 }
1140 if (!ret)
1141 ret = btrfs_check_mountopts_zoned(info);
1142 if (!ret && btrfs_test_opt(info, SPACE_CACHE))
1143 btrfs_info(info, "disk space caching is enabled");
1144 if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
1145 btrfs_info(info, "using free space tree");
1146 return ret;
1147 }
1148
--
0-DAY CI Kernel Test Service
https://01.org/lkp
Powered by blists - more mailing lists