btrfs: move fs wide helpers out of ctree.h

We have several fs wide related helpers in ctree.h.  The bulk of these
are the incompat flag test helpers, but there are things such as
btrfs_fs_closing() and the read only helpers that also aren't directly
related to the ctree code.  Move these into a fs.h header, which will
serve as the location for file system wide related helpers.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Anand Jain <anand.jain@oracle.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index fa9ddcc..eebb45c 100644 (file)
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -31,7 +31,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
           backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \
           uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \
           block-rsv.o delalloc-space.o block-group.o discard.o reflink.o \
-          subpage.o tree-mod-log.o extent-io-tree.o
+          subpage.o tree-mod-log.o extent-io-tree.o fs.o
 
 btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
 btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 232f494..f76db31 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -15,6 +15,7 @@
 #include "locking.h"
 #include "misc.h"
 #include "tree-mod-log.h"
+#include "fs.h"
 
 /* Just arbitrary numbers so we can be sure one of these happened. */
 #define BACKREF_FOUND_SHARED     6

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index 47461fd..bf8d1e1 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -17,6 +17,7 @@
 #include "discard.h"
 #include "raid56.h"
 #include "zoned.h"
+#include "fs.h"
 
 #ifdef CONFIG_BTRFS_DEBUG
 int btrfs_should_fragment_free_space(struct btrfs_block_group *block_group)

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 3485f60..1b2a1dc 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2857,44 +2857,6 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
                        struct btrfs_root *root,
                        struct extent_buffer *node,
                        struct extent_buffer *parent);
-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.
-        */
-       if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
-               if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
-                       return 2;
-               return 1;
-       }
-       return 0;
-}
-
-/*
- * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
- * anything except sleeping. This function is used to check the status of
- * the fs.
- * We check for BTRFS_FS_STATE_RO to avoid races with a concurrent remount,
- * since setting and checking for SB_RDONLY in the superblock's flags is not
- * atomic.
- */
-static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
-{
-       return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||
-               btrfs_fs_closing(fs_info);
-}
-
-static inline void btrfs_set_sb_rdonly(struct super_block *sb)
-{
-       sb->s_flags |= SB_RDONLY;
-       set_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
-}
-
-static inline void btrfs_clear_sb_rdonly(struct super_block *sb)
-{
-       sb->s_flags &= ~SB_RDONLY;
-       clear_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
-}
 
 /* root-item.c */
 int btrfs_add_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
@@ -3529,132 +3491,6 @@ do {                                                                    \
 } while (0)
 
 
-/* compatibility and incompatibility defines */
-
-#define btrfs_set_fs_incompat(__fs_info, opt) \
-       __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
-                               #opt)
-
-static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
-                                          u64 flag, const char* name)
-{
-       struct btrfs_super_block *disk_super;
-       u64 features;
-
-       disk_super = fs_info->super_copy;
-       features = btrfs_super_incompat_flags(disk_super);
-       if (!(features & flag)) {
-               spin_lock(&fs_info->super_lock);
-               features = btrfs_super_incompat_flags(disk_super);
-               if (!(features & flag)) {
-                       features |= flag;
-                       btrfs_set_super_incompat_flags(disk_super, features);
-                       btrfs_info(fs_info,
-                               "setting incompat feature flag for %s (0x%llx)",
-                               name, flag);
-               }
-               spin_unlock(&fs_info->super_lock);
-       }
-}
-
-#define btrfs_clear_fs_incompat(__fs_info, opt) \
-       __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
-                                 #opt)
-
-static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
-                                            u64 flag, const char* name)
-{
-       struct btrfs_super_block *disk_super;
-       u64 features;
-
-       disk_super = fs_info->super_copy;
-       features = btrfs_super_incompat_flags(disk_super);
-       if (features & flag) {
-               spin_lock(&fs_info->super_lock);
-               features = btrfs_super_incompat_flags(disk_super);
-               if (features & flag) {
-                       features &= ~flag;
-                       btrfs_set_super_incompat_flags(disk_super, features);
-                       btrfs_info(fs_info,
-                               "clearing incompat feature flag for %s (0x%llx)",
-                               name, flag);
-               }
-               spin_unlock(&fs_info->super_lock);
-       }
-}
-
-#define btrfs_fs_incompat(fs_info, opt) \
-       __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
-
-static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
-{
-       struct btrfs_super_block *disk_super;
-       disk_super = fs_info->super_copy;
-       return !!(btrfs_super_incompat_flags(disk_super) & flag);
-}
-
-#define btrfs_set_fs_compat_ro(__fs_info, opt) \
-       __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
-                                #opt)
-
-static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
-                                           u64 flag, const char *name)
-{
-       struct btrfs_super_block *disk_super;
-       u64 features;
-
-       disk_super = fs_info->super_copy;
-       features = btrfs_super_compat_ro_flags(disk_super);
-       if (!(features & flag)) {
-               spin_lock(&fs_info->super_lock);
-               features = btrfs_super_compat_ro_flags(disk_super);
-               if (!(features & flag)) {
-                       features |= flag;
-                       btrfs_set_super_compat_ro_flags(disk_super, features);
-                       btrfs_info(fs_info,
-                               "setting compat-ro feature flag for %s (0x%llx)",
-                               name, flag);
-               }
-               spin_unlock(&fs_info->super_lock);
-       }
-}
-
-#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
-       __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
-                                  #opt)
-
-static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
-                                             u64 flag, const char *name)
-{
-       struct btrfs_super_block *disk_super;
-       u64 features;
-
-       disk_super = fs_info->super_copy;
-       features = btrfs_super_compat_ro_flags(disk_super);
-       if (features & flag) {
-               spin_lock(&fs_info->super_lock);
-               features = btrfs_super_compat_ro_flags(disk_super);
-               if (features & flag) {
-                       features &= ~flag;
-                       btrfs_set_super_compat_ro_flags(disk_super, features);
-                       btrfs_info(fs_info,
-                               "clearing compat-ro feature flag for %s (0x%llx)",
-                               name, flag);
-               }
-               spin_unlock(&fs_info->super_lock);
-       }
-}
-
-#define btrfs_fs_compat_ro(fs_info, opt) \
-       __btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
-
-static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
-{
-       struct btrfs_super_block *disk_super;
-       disk_super = fs_info->super_copy;
-       return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
-}
-
 /* acl.c */
 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
 struct posix_acl *btrfs_get_acl(struct inode *inode, int type, bool rcu);

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index cf59d8f..5e20b19 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -43,6 +43,7 @@
 #include "space-info.h"
 #include "zoned.h"
 #include "subpage.h"
+#include "fs.h"
 
 #define BTRFS_SUPER_FLAG_SUPP  (BTRFS_HEADER_FLAG_WRITTEN |\
                                 BTRFS_HEADER_FLAG_RELOC |\

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 2801c99..bc010db 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -36,6 +36,7 @@
 #include "rcu-string.h"
 #include "zoned.h"
 #include "dev-replace.h"
+#include "fs.h"
 
 #undef SCRAMBLE_DELAYED_REFS
 

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 6bb9fa9..824ff54 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -16,6 +16,7 @@
 #include "volumes.h"
 #include "print-tree.h"
 #include "compression.h"
+#include "fs.h"
 
 #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
                                   sizeof(struct btrfs_item) * 2) / \

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 19b41b5..a352c7c 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -30,6 +30,7 @@
 #include "delalloc-space.h"
 #include "reflink.h"
 #include "subpage.h"
+#include "fs.h"
 
 static struct kmem_cache *btrfs_inode_defrag_cachep;
 /*

diff --git a/fs/btrfs/free-space-tree.c b/fs/btrfs/free-space-tree.c
index 367bcfc..bfc21eb 100644 (file)
--- a/fs/btrfs/free-space-tree.c
+++ b/fs/btrfs/free-space-tree.c
@@ -11,6 +11,7 @@
 #include "free-space-tree.h"
 #include "transaction.h"
 #include "block-group.h"
+#include "fs.h"
 
 static int __add_block_group_free_space(struct btrfs_trans_handle *trans,
                                        struct btrfs_block_group *block_group,

diff --git a/fs/btrfs/fs.c b/fs/btrfs/fs.c
new file mode 100644 (file)
index 0000000..d4ba948
--- /dev/null
+++ b/fs/btrfs/fs.c
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "ctree.h"
+#include "fs.h"
+
+void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
+                            const char *name)
+{
+       struct btrfs_super_block *disk_super;
+       u64 features;
+
+       disk_super = fs_info->super_copy;
+       features = btrfs_super_incompat_flags(disk_super);
+       if (!(features & flag)) {
+               spin_lock(&fs_info->super_lock);
+               features = btrfs_super_incompat_flags(disk_super);
+               if (!(features & flag)) {
+                       features |= flag;
+                       btrfs_set_super_incompat_flags(disk_super, features);
+                       btrfs_info(fs_info,
+                               "setting incompat feature flag for %s (0x%llx)",
+                               name, flag);
+               }
+               spin_unlock(&fs_info->super_lock);
+       }
+}
+
+void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
+                              const char *name)
+{
+       struct btrfs_super_block *disk_super;
+       u64 features;
+
+       disk_super = fs_info->super_copy;
+       features = btrfs_super_incompat_flags(disk_super);
+       if (features & flag) {
+               spin_lock(&fs_info->super_lock);
+               features = btrfs_super_incompat_flags(disk_super);
+               if (features & flag) {
+                       features &= ~flag;
+                       btrfs_set_super_incompat_flags(disk_super, features);
+                       btrfs_info(fs_info,
+                               "clearing incompat feature flag for %s (0x%llx)",
+                               name, flag);
+               }
+               spin_unlock(&fs_info->super_lock);
+       }
+}
+
+void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
+                             const char *name)
+{
+       struct btrfs_super_block *disk_super;
+       u64 features;
+
+       disk_super = fs_info->super_copy;
+       features = btrfs_super_compat_ro_flags(disk_super);
+       if (!(features & flag)) {
+               spin_lock(&fs_info->super_lock);
+               features = btrfs_super_compat_ro_flags(disk_super);
+               if (!(features & flag)) {
+                       features |= flag;
+                       btrfs_set_super_compat_ro_flags(disk_super, features);
+                       btrfs_info(fs_info,
+                               "setting compat-ro feature flag for %s (0x%llx)",
+                               name, flag);
+               }
+               spin_unlock(&fs_info->super_lock);
+       }
+}
+
+void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
+                               const char *name)
+{
+       struct btrfs_super_block *disk_super;
+       u64 features;
+
+       disk_super = fs_info->super_copy;
+       features = btrfs_super_compat_ro_flags(disk_super);
+       if (features & flag) {
+               spin_lock(&fs_info->super_lock);
+               features = btrfs_super_compat_ro_flags(disk_super);
+               if (features & flag) {
+                       features &= ~flag;
+                       btrfs_set_super_compat_ro_flags(disk_super, features);
+                       btrfs_info(fs_info,
+                               "clearing compat-ro feature flag for %s (0x%llx)",
+                               name, flag);
+               }
+               spin_unlock(&fs_info->super_lock);
+       }
+}

diff --git a/fs/btrfs/fs.h b/fs/btrfs/fs.h
new file mode 100644 (file)
index 0000000..8eda9ce
--- /dev/null
+++ b/fs/btrfs/fs.h
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef BTRFS_FS_H
+#define BTRFS_FS_H
+
+/* Compatibility and incompatibility defines */
+void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
+                            const char *name);
+void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
+                              const char *name);
+void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
+                             const char *name);
+void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
+                               const char *name);
+
+#define btrfs_set_fs_incompat(__fs_info, opt)                          \
+       __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, #opt)
+
+#define btrfs_clear_fs_incompat(__fs_info, opt)                                \
+       __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, #opt)
+
+#define btrfs_fs_incompat(fs_info, opt)                                        \
+       __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
+
+#define btrfs_set_fs_compat_ro(__fs_info, opt)                         \
+       __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, #opt)
+
+#define btrfs_clear_fs_compat_ro(__fs_info, opt)                       \
+       __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, #opt)
+
+#define btrfs_fs_compat_ro(fs_info, opt)                               \
+       __btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
+
+static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
+{
+       struct btrfs_super_block *disk_super;
+       disk_super = fs_info->super_copy;
+       return !!(btrfs_super_incompat_flags(disk_super) & flag);
+}
+
+static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
+{
+       struct btrfs_super_block *disk_super;
+       disk_super = fs_info->super_copy;
+       return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
+}
+
+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. */
+       if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
+               if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
+                       return 2;
+               return 1;
+       }
+       return 0;
+}
+
+/*
+ * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
+ * anything except sleeping. This function is used to check the status of
+ * the fs.
+ * We check for BTRFS_FS_STATE_RO to avoid races with a concurrent remount,
+ * since setting and checking for SB_RDONLY in the superblock's flags is not
+ * atomic.
+ */
+static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
+{
+       return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||
+               btrfs_fs_closing(fs_info);
+}
+
+static inline void btrfs_set_sb_rdonly(struct super_block *sb)
+{
+       sb->s_flags |= SB_RDONLY;
+       set_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
+}
+
+static inline void btrfs_clear_sb_rdonly(struct super_block *sb)
+{
+       sb->s_flags &= ~SB_RDONLY;
+       clear_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
+}
+
+#endif

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 50584b9..60b3162 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -55,6 +55,7 @@
 #include "zoned.h"
 #include "subpage.h"
 #include "inode-item.h"
+#include "fs.h"
 
 struct btrfs_iget_args {
        u64 ino;

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index a482739..564a4ae 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -50,6 +50,7 @@
 #include "delalloc-space.h"
 #include "block-group.h"
 #include "subpage.h"
+#include "fs.h"
 
 #ifdef CONFIG_64BIT
 /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI

diff --git a/fs/btrfs/props.c b/fs/btrfs/props.c
index e042893..d2c699c 100644 (file)
--- a/fs/btrfs/props.c
+++ b/fs/btrfs/props.c
@@ -11,6 +11,7 @@
 #include "xattr.h"
 #include "compression.h"
 #include "space-info.h"
+#include "fs.h"
 
 #define BTRFS_PROP_HANDLERS_HT_BITS 8
 static DEFINE_HASHTABLE(prop_handlers_ht, BTRFS_PROP_HANDLERS_HT_BITS);

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index b74105a..e87a2f0 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -24,6 +24,7 @@
 #include "block-group.h"
 #include "sysfs.h"
 #include "tree-mod-log.h"
+#include "fs.h"
 
 /*
  * Helpers to access qgroup reservation

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 216a448..977afbb 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -28,6 +28,7 @@
 #include "zoned.h"
 #include "inode-item.h"
 #include "space-info.h"
+#include "fs.h"
 
 /*
  * Relocation overview

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index cdda4b2..6871c1c 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -21,6 +21,7 @@
 #include "raid56.h"
 #include "block-group.h"
 #include "zoned.h"
+#include "fs.h"
 
 /*
  * This is only the first step towards a full-features scrub. It reads all

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index af2e133..af1538c 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -10,6 +10,7 @@
 #include "transaction.h"
 #include "block-group.h"
 #include "zoned.h"
+#include "fs.h"
 
 /*
  * HOW DOES SPACE RESERVATION WORK

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 42e0d2f..ef646a1 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -49,6 +49,7 @@
 #include "discard.h"
 #include "qgroup.h"
 #include "raid56.h"
+#include "fs.h"
 #define CREATE_TRACE_POINTS
 #include <trace/events/btrfs.h>
 

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index ae7d4ac..bae77fb 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -23,6 +23,7 @@
 #include "block-group.h"
 #include "space-info.h"
 #include "zoned.h"
+#include "fs.h"
 
 static struct kmem_cache *btrfs_trans_handle_cachep;
 

diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c
index 43f905a..862d677 100644 (file)
--- a/fs/btrfs/tree-checker.c
+++ b/fs/btrfs/tree-checker.c
@@ -25,6 +25,7 @@
 #include "volumes.h"
 #include "misc.h"
 #include "btrfs_inode.h"
+#include "fs.h"
 
 /*
  * Error message should follow the following format:

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index c3cf3da..e294c38 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -21,6 +21,7 @@
 #include "space-info.h"
 #include "zoned.h"
 #include "inode-item.h"
+#include "fs.h"
 
 #define MAX_CONFLICT_INODES 10
 

diff --git a/fs/btrfs/uuid-tree.c b/fs/btrfs/uuid-tree.c
index b458452..2d7eb29 100644 (file)
--- a/fs/btrfs/uuid-tree.c
+++ b/fs/btrfs/uuid-tree.c
@@ -9,6 +9,7 @@
 #include "transaction.h"
 #include "disk-io.h"
 #include "print-tree.h"
+#include "fs.h"
 
 
 static void btrfs_uuid_to_key(u8 *uuid, u8 type, struct btrfs_key *key)

diff --git a/fs/btrfs/verity.c b/fs/btrfs/verity.c
index ee00e33..ab0b39b 100644 (file)
--- a/fs/btrfs/verity.c
+++ b/fs/btrfs/verity.c
@@ -15,6 +15,7 @@
 #include "transaction.h"
 #include "disk-io.h"
 #include "locking.h"
+#include "fs.h"
 
 /*
  * Implementation of the interface defined in struct fsverity_operations.

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 796e9f5..d65d5d7 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -33,6 +33,7 @@
 #include "block-group.h"
 #include "discard.h"
 #include "zoned.h"
+#include "fs.h"
 
 static struct bio_set btrfs_bioset;
 

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index c9e2b0c..2a7d856 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -15,6 +15,7 @@
 #include "transaction.h"
 #include "dev-replace.h"
 #include "space-info.h"
+#include "fs.h"
 
 /* Maximum number of zones to report per blkdev_report_zones() call */
 #define BTRFS_REPORT_NR_ZONES   4096