bcachefs: less pointer chasing

15 files changed, 111 insertions, 106 deletions

diff --git a/fs/bcachefs/alloc.c b/fs/bcachefs/alloc.c
index 13b7a3e50cd0..16bdc48c759e 100644
--- a/fs/bcachefs/alloc.c
+++ b/fs/bcachefs/alloc.c
@@ -132,8 +132,7 @@ static unsigned bch_alloc_val_u64s(const struct bch_alloc *a)
 	return DIV_ROUND_UP(bytes, sizeof(u64));
 }
 
-static const char *bch2_alloc_invalid(const struct bch_fs *c,
-				      struct bkey_s_c k)
+const char *bch2_alloc_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	if (k.k->p.inode >= c->sb.nr_devices ||
 	    !c->devs[k.k->p.inode])
@@ -154,8 +153,8 @@ static const char *bch2_alloc_invalid(const struct bch_fs *c,
 	return NULL;
 }
 
-static void bch2_alloc_to_text(struct bch_fs *c, char *buf,
-			       size_t size, struct bkey_s_c k)
+void bch2_alloc_to_text(struct bch_fs *c, char *buf,
+			size_t size, struct bkey_s_c k)
 {
 	buf[0] = '\0';
 
@@ -165,11 +164,6 @@ static void bch2_alloc_to_text(struct bch_fs *c, char *buf,
 	}
 }
 
-const struct bkey_ops bch2_bkey_alloc_ops = {
-	.key_invalid	= bch2_alloc_invalid,
-	.val_to_text	= bch2_alloc_to_text,
-};
-
 static inline unsigned get_alloc_field(const u8 **p, unsigned bytes)
 {
 	unsigned v;
diff --git a/fs/bcachefs/alloc.h b/fs/bcachefs/alloc.h
index c3faaf7a7c5b..372cc047e927 100644
--- a/fs/bcachefs/alloc.h
+++ b/fs/bcachefs/alloc.h
@@ -9,6 +9,14 @@ struct bch_dev;
 struct bch_fs;
 struct bch_devs_List;
 
+const char *bch2_alloc_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_alloc_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+
+#define bch2_bkey_alloc_ops (struct bkey_ops) {		\
+	.key_invalid	= bch2_alloc_invalid,		\
+	.val_to_text	= bch2_alloc_to_text,		\
+}
+
 struct dev_alloc_list {
 	unsigned	nr;
 	u8		devs[BCH_SB_MEMBERS_MAX];
@@ -129,6 +137,4 @@ int bch2_alloc_write(struct bch_fs *);
 int bch2_fs_allocator_start(struct bch_fs *);
 void bch2_fs_allocator_init(struct bch_fs *);
 
-extern const struct bkey_ops bch2_bkey_alloc_ops;
-
 #endif /* _BCACHEFS_ALLOC_H */
diff --git a/fs/bcachefs/bkey_methods.c b/fs/bcachefs/bkey_methods.c
index 84cdf66221cf..e4f62f905f11 100644
--- a/fs/bcachefs/bkey_methods.c
+++ b/fs/bcachefs/bkey_methods.c
@@ -10,20 +10,20 @@
 #include "quota.h"
 #include "xattr.h"
 
-const struct bkey_ops *bch2_bkey_ops[] = {
-	[BKEY_TYPE_EXTENTS]	= &bch2_bkey_extent_ops,
-	[BKEY_TYPE_INODES]	= &bch2_bkey_inode_ops,
-	[BKEY_TYPE_DIRENTS]	= &bch2_bkey_dirent_ops,
-	[BKEY_TYPE_XATTRS]	= &bch2_bkey_xattr_ops,
-	[BKEY_TYPE_ALLOC]	= &bch2_bkey_alloc_ops,
-	[BKEY_TYPE_QUOTAS]	= &bch2_bkey_quota_ops,
-	[BKEY_TYPE_BTREE]	= &bch2_bkey_btree_ops,
+const struct bkey_ops bch2_bkey_ops[] = {
+	[BKEY_TYPE_EXTENTS]	= bch2_bkey_extent_ops,
+	[BKEY_TYPE_INODES]	= bch2_bkey_inode_ops,
+	[BKEY_TYPE_DIRENTS]	= bch2_bkey_dirent_ops,
+	[BKEY_TYPE_XATTRS]	= bch2_bkey_xattr_ops,
+	[BKEY_TYPE_ALLOC]	= bch2_bkey_alloc_ops,
+	[BKEY_TYPE_QUOTAS]	= bch2_bkey_quota_ops,
+	[BKEY_TYPE_BTREE]	= bch2_bkey_btree_ops,
 };
 
 const char *bch2_bkey_val_invalid(struct bch_fs *c, enum bkey_type type,
 				  struct bkey_s_c k)
 {
-	const struct bkey_ops *ops = bch2_bkey_ops[type];
+	const struct bkey_ops *ops = &bch2_bkey_ops[type];
 
 	switch (k.k->type) {
 	case KEY_TYPE_DELETED:
@@ -51,7 +51,7 @@ const char *bch2_bkey_val_invalid(struct bch_fs *c, enum bkey_type type,
 const char *__bch2_bkey_invalid(struct bch_fs *c, enum bkey_type type,
 			      struct bkey_s_c k)
 {
-	const struct bkey_ops *ops = bch2_bkey_ops[type];
+	const struct bkey_ops *ops = &bch2_bkey_ops[type];
 
 	if (k.k->u64s < BKEY_U64s)
 		return "u64s too small";
@@ -100,7 +100,7 @@ const char *bch2_bkey_in_btree_node(struct btree *b, struct bkey_s_c k)
 void bch2_bkey_debugcheck(struct bch_fs *c, struct btree *b, struct bkey_s_c k)
 {
 	enum bkey_type type = btree_node_type(b);
-	const struct bkey_ops *ops = bch2_bkey_ops[type];
+	const struct bkey_ops *ops = &bch2_bkey_ops[type];
 	const char *invalid;
 
 	BUG_ON(!k.k->u64s);
@@ -141,7 +141,7 @@ int bch2_bkey_to_text(char *buf, size_t size, const struct bkey *k)
 int bch2_val_to_text(struct bch_fs *c, enum bkey_type type,
 		     char *buf, size_t size, struct bkey_s_c k)
 {
-	const struct bkey_ops *ops = bch2_bkey_ops[type];
+	const struct bkey_ops *ops = &bch2_bkey_ops[type];
 	char *out = buf, *end = buf + size;
 
 	switch (k.k->type) {
@@ -182,7 +182,7 @@ void bch2_bkey_swab(enum bkey_type type,
 		   const struct bkey_format *f,
 		   struct bkey_packed *k)
 {
-	const struct bkey_ops *ops = bch2_bkey_ops[type];
+	const struct bkey_ops *ops = &bch2_bkey_ops[type];
 
 	bch2_bkey_swab_key(f, k);
 
diff --git a/fs/bcachefs/bkey_methods.h b/fs/bcachefs/bkey_methods.h
index 59db3037e6dd..9e2c90d54e42 100644
--- a/fs/bcachefs/bkey_methods.h
+++ b/fs/bcachefs/bkey_methods.h
@@ -81,6 +81,6 @@ int bch2_bkey_val_to_text(struct bch_fs *, enum bkey_type,
 void bch2_bkey_swab(enum bkey_type, const struct bkey_format *,
 		    struct bkey_packed *);
 
-extern const struct bkey_ops *bch2_bkey_ops[];
+extern const struct bkey_ops bch2_bkey_ops[];
 
 #endif /* _BCACHEFS_BKEY_METHODS_H */
diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index e86c6bcea229..8854305d315e 100644
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -299,7 +299,7 @@ static inline enum bkey_type btree_node_type(struct btree *b)
 
 static inline const struct bkey_ops *btree_node_ops(struct btree *b)
 {
-	return bch2_bkey_ops[btree_node_type(b)];
+	return &bch2_bkey_ops[btree_node_type(b)];
 }
 
 static inline bool btree_node_has_ptrs(struct btree *b)
diff --git a/fs/bcachefs/dirent.c b/fs/bcachefs/dirent.c
index 6bdece3a7637..df9913f8967b 100644
--- a/fs/bcachefs/dirent.c
+++ b/fs/bcachefs/dirent.c
@@ -79,8 +79,7 @@ const struct bch_hash_desc bch2_dirent_hash_desc = {
 	.cmp_bkey	= dirent_cmp_bkey,
 };
 
-static const char *bch2_dirent_invalid(const struct bch_fs *c,
-				       struct bkey_s_c k)
+const char *bch2_dirent_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	struct bkey_s_c_dirent d;
 	unsigned len;
@@ -116,8 +115,8 @@ static const char *bch2_dirent_invalid(const struct bch_fs *c,
 	}
 }
 
-static void bch2_dirent_to_text(struct bch_fs *c, char *buf,
-				size_t size, struct bkey_s_c k)
+void bch2_dirent_to_text(struct bch_fs *c, char *buf,
+			 size_t size, struct bkey_s_c k)
 {
 	struct bkey_s_c_dirent d;
 	size_t n = 0;
@@ -136,11 +135,6 @@ static void bch2_dirent_to_text(struct bch_fs *c, char *buf,
 	}
 }
 
-const struct bkey_ops bch2_bkey_dirent_ops = {
-	.key_invalid	= bch2_dirent_invalid,
-	.val_to_text	= bch2_dirent_to_text,
-};
-
 static struct bkey_i_dirent *dirent_create_key(u8 type,
 				const struct qstr *name, u64 dst)
 {
diff --git a/fs/bcachefs/dirent.h b/fs/bcachefs/dirent.h
index 98405b5be2b8..5d066af18f95 100644
--- a/fs/bcachefs/dirent.h
+++ b/fs/bcachefs/dirent.h
@@ -4,7 +4,14 @@
 #include "str_hash.h"
 
 extern const struct bch_hash_desc bch2_dirent_hash_desc;
-extern const struct bkey_ops bch2_bkey_dirent_ops;
+
+const char *bch2_dirent_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_dirent_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+
+#define bch2_bkey_dirent_ops (struct bkey_ops) {	\
+	.key_invalid	= bch2_dirent_invalid,		\
+	.val_to_text	= bch2_dirent_to_text,		\
+}
 
 struct qstr;
 struct file;
diff --git a/fs/bcachefs/extents.c b/fs/bcachefs/extents.c
index 435f5b663427..c5d1e7cb539b 100644
--- a/fs/bcachefs/extents.c
+++ b/fs/bcachefs/extents.c
@@ -27,9 +27,6 @@
 
 #include <trace/events/bcachefs.h>
 
-static enum merge_result bch2_extent_merge(struct bch_fs *, struct btree *,
-					   struct bkey_i *, struct bkey_i *);
-
 static void sort_key_next(struct btree_node_iter_large *iter,
 			  struct btree *b,
 			  struct btree_node_iter_set *i)
@@ -459,13 +456,12 @@ static void bch2_extent_drop_stale(struct bch_fs *c, struct bkey_s_extent e)
 		bch2_extent_drop_redundant_crcs(e);
 }
 
-static bool bch2_ptr_normalize(struct bch_fs *c, struct btree *bk,
-			      struct bkey_s k)
+bool bch2_ptr_normalize(struct bch_fs *c, struct btree *b, struct bkey_s k)
 {
 	return bch2_extent_normalize(c, k);
 }
 
-static void bch2_ptr_swab(const struct bkey_format *f, struct bkey_packed *k)
+void bch2_ptr_swab(const struct bkey_format *f, struct bkey_packed *k)
 {
 	switch (k->type) {
 	case BCH_EXTENT:
@@ -648,8 +644,7 @@ use:
 
 /* Btree ptrs */
 
-static const char *bch2_btree_ptr_invalid(const struct bch_fs *c,
-					 struct bkey_s_c k)
+const char *bch2_btree_ptr_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	if (bkey_extent_is_cached(k.k))
 		return "cached";
@@ -691,8 +686,8 @@ static const char *bch2_btree_ptr_invalid(const struct bch_fs *c,
 	}
 }
 
-static void btree_ptr_debugcheck(struct bch_fs *c, struct btree *b,
-				 struct bkey_s_c k)
+void bch2_btree_ptr_debugcheck(struct bch_fs *c, struct btree *b,
+			       struct bkey_s_c k)
 {
 	struct bkey_s_c_extent e = bkey_s_c_to_extent(k);
 	const struct bch_extent_ptr *ptr;
@@ -747,8 +742,8 @@ err:
 		      mark.gen, (unsigned) mark.counter);
 }
 
-static void bch2_btree_ptr_to_text(struct bch_fs *c, char *buf,
-				  size_t size, struct bkey_s_c k)
+void bch2_btree_ptr_to_text(struct bch_fs *c, char *buf,
+			    size_t size, struct bkey_s_c k)
 {
 	char *out = buf, *end = buf + size;
 	const char *invalid;
@@ -776,13 +771,6 @@ bch2_btree_pick_ptr(struct bch_fs *c, const struct btree *b,
 	return pick;
 }
 
-const struct bkey_ops bch2_bkey_btree_ops = {
-	.key_invalid	= bch2_btree_ptr_invalid,
-	.key_debugcheck	= btree_ptr_debugcheck,
-	.val_to_text	= bch2_btree_ptr_to_text,
-	.swab		= bch2_ptr_swab,
-};
-
 /* Extents */
 
 static bool __bch2_cut_front(struct bpos where, struct bkey_s k)
@@ -1716,8 +1704,7 @@ bch2_insert_fixup_extent(struct btree_insert *trans,
 	return ret;
 }
 
-static const char *bch2_extent_invalid(const struct bch_fs *c,
-				       struct bkey_s_c k)
+const char *bch2_extent_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	if (bkey_val_u64s(k.k) > BKEY_EXTENT_VAL_U64s_MAX)
 		return "value too big";
@@ -1884,8 +1871,7 @@ bad_ptr:
 	return;
 }
 
-static void bch2_extent_debugcheck(struct bch_fs *c, struct btree *b,
-				   struct bkey_s_c k)
+void bch2_extent_debugcheck(struct bch_fs *c, struct btree *b, struct bkey_s_c k)
 {
 	switch (k.k->type) {
 	case BCH_EXTENT:
@@ -1899,8 +1885,8 @@ static void bch2_extent_debugcheck(struct bch_fs *c, struct btree *b,
 	}
 }
 
-static void bch2_extent_to_text(struct bch_fs *c, char *buf,
-				size_t size, struct bkey_s_c k)
+void bch2_extent_to_text(struct bch_fs *c, char *buf,
+			 size_t size, struct bkey_s_c k)
 {
 	char *out = buf, *end = buf + size;
 	const char *invalid;
@@ -2108,9 +2094,8 @@ void bch2_extent_pick_ptr(struct bch_fs *c, struct bkey_s_c k,
 	}
 }
 
-static enum merge_result bch2_extent_merge(struct bch_fs *c,
-					   struct btree *bk,
-					   struct bkey_i *l, struct bkey_i *r)
+enum merge_result bch2_extent_merge(struct bch_fs *c, struct btree *b,
+				    struct bkey_i *l, struct bkey_i *r)
 {
 	struct bkey_s_extent el, er;
 	union bch_extent_entry *en_l, *en_r;
@@ -2429,13 +2414,3 @@ int bch2_check_range_allocated(struct bch_fs *c, struct bpos pos, u64 size)
 
 	return ret;
 }
-
-const struct bkey_ops bch2_bkey_extent_ops = {
-	.key_invalid	= bch2_extent_invalid,
-	.key_debugcheck	= bch2_extent_debugcheck,
-	.val_to_text	= bch2_extent_to_text,
-	.swab		= bch2_ptr_swab,
-	.key_normalize	= bch2_ptr_normalize,
-	.key_merge	= bch2_extent_merge,
-	.is_extents	= true,
-};
diff --git a/fs/bcachefs/extents.h b/fs/bcachefs/extents.h
index 376e51c93816..8dc15484f485 100644
--- a/fs/bcachefs/extents.h
+++ b/fs/bcachefs/extents.h
@@ -15,6 +15,36 @@ struct extent_insert_hook;
 struct bch_devs_mask;
 union bch_extent_crc;
 
+const char *bch2_btree_ptr_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_btree_ptr_debugcheck(struct bch_fs *, struct btree *,
+			       struct bkey_s_c);
+void bch2_btree_ptr_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_ptr_swab(const struct bkey_format *, struct bkey_packed *);
+
+#define bch2_bkey_btree_ops (struct bkey_ops) {			\
+	.key_invalid	= bch2_btree_ptr_invalid,		\
+	.key_debugcheck	= bch2_btree_ptr_debugcheck,		\
+	.val_to_text	= bch2_btree_ptr_to_text,		\
+	.swab		= bch2_ptr_swab,			\
+}
+
+const char *bch2_extent_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_extent_debugcheck(struct bch_fs *, struct btree *, struct bkey_s_c);
+void bch2_extent_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+bool bch2_ptr_normalize(struct bch_fs *, struct btree *, struct bkey_s);
+enum merge_result bch2_extent_merge(struct bch_fs *, struct btree *,
+				    struct bkey_i *, struct bkey_i *);
+
+#define bch2_bkey_extent_ops (struct bkey_ops) {		\
+	.key_invalid	= bch2_extent_invalid,			\
+	.key_debugcheck	= bch2_extent_debugcheck,		\
+	.val_to_text	= bch2_extent_to_text,			\
+	.swab		= bch2_ptr_swab,			\
+	.key_normalize	= bch2_ptr_normalize,			\
+	.key_merge	= bch2_extent_merge,			\
+	.is_extents	= true,					\
+}
+
 struct btree_nr_keys bch2_key_sort_fix_overlapping(struct bset *,
 						  struct btree *,
 						  struct btree_node_iter_large *);
@@ -23,9 +53,6 @@ struct btree_nr_keys bch2_extent_sort_fix_overlapping(struct bch_fs *c,
 						     struct btree *,
 						     struct btree_node_iter_large *);
 
-extern const struct bkey_ops bch2_bkey_btree_ops;
-extern const struct bkey_ops bch2_bkey_extent_ops;
-
 struct extent_pick_ptr
 bch2_btree_pick_ptr(struct bch_fs *, const struct btree *,
 		    struct bch_devs_mask *avoid);
diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index 797aa2a981e3..3ae5ac975dfb 100644
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -175,8 +175,7 @@ int bch2_inode_unpack(struct bkey_s_c_inode inode,
 	return 0;
 }
 
-static const char *bch2_inode_invalid(const struct bch_fs *c,
-				      struct bkey_s_c k)
+const char *bch2_inode_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	if (k.k->p.offset)
 		return "nonzero offset";
@@ -224,8 +223,8 @@ static const char *bch2_inode_invalid(const struct bch_fs *c,
 	}
 }
 
-static void bch2_inode_to_text(struct bch_fs *c, char *buf,
-			       size_t size, struct bkey_s_c k)
+void bch2_inode_to_text(struct bch_fs *c, char *buf,
+			size_t size, struct bkey_s_c k)
 {
 	char *out = buf, *end = out + size;
 	struct bkey_s_c_inode inode;
@@ -247,11 +246,6 @@ static void bch2_inode_to_text(struct bch_fs *c, char *buf,
 	}
 }
 
-const struct bkey_ops bch2_bkey_inode_ops = {
-	.key_invalid	= bch2_inode_invalid,
-	.val_to_text	= bch2_inode_to_text,
-};
-
 void bch2_inode_init(struct bch_fs *c, struct bch_inode_unpacked *inode_u,
 		     uid_t uid, gid_t gid, umode_t mode, dev_t rdev,
 		     struct bch_inode_unpacked *parent)
diff --git a/fs/bcachefs/inode.h b/fs/bcachefs/inode.h
index 5c7aeadcb1a6..26461063f774 100644
--- a/fs/bcachefs/inode.h
+++ b/fs/bcachefs/inode.h
@@ -5,7 +5,13 @@
 
 #include <linux/math64.h>
 
-extern const struct bkey_ops bch2_bkey_inode_ops;
+const char *bch2_inode_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_inode_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+
+#define bch2_bkey_inode_ops (struct bkey_ops) {		\
+	.key_invalid	= bch2_inode_invalid,		\
+	.val_to_text	= bch2_inode_to_text,		\
+}
 
 struct bch_inode_unpacked {
 	u64			bi_inum;
diff --git a/fs/bcachefs/quota.c b/fs/bcachefs/quota.c
index d28f1333e693..35dce874de10 100644
--- a/fs/bcachefs/quota.c
+++ b/fs/bcachefs/quota.c
@@ -4,7 +4,7 @@
 #include "quota.h"
 #include "super-io.h"
 
-static const char *bch2_quota_invalid(const struct bch_fs *c, struct bkey_s_c k)
+const char *bch2_quota_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	struct bkey_s_c_quota dq;
 
@@ -30,8 +30,8 @@ static const char * const bch2_quota_counters[] = {
 	"inodes",
 };
 
-static void bch2_quota_to_text(struct bch_fs *c, char *buf,
-			       size_t size, struct bkey_s_c k)
+void bch2_quota_to_text(struct bch_fs *c, char *buf,
+			size_t size, struct bkey_s_c k)
 {
 	char *out = buf, *end= buf + size;
 	struct bkey_s_c_quota dq;
@@ -50,11 +50,6 @@ static void bch2_quota_to_text(struct bch_fs *c, char *buf,
 	}
 }
 
-const struct bkey_ops bch2_bkey_quota_ops = {
-	.key_invalid	= bch2_quota_invalid,
-	.val_to_text	= bch2_quota_to_text,
-};
-
 #ifdef CONFIG_BCACHEFS_QUOTA
 
 #include <linux/cred.h>
diff --git a/fs/bcachefs/quota.h b/fs/bcachefs/quota.h
index 509b7f0e069d..5289e13ba233 100644
--- a/fs/bcachefs/quota.h
+++ b/fs/bcachefs/quota.h
@@ -3,7 +3,13 @@
 
 #include "quota_types.h"
 
-extern const struct bkey_ops bch2_bkey_quota_ops;
+const char *bch2_quota_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_quota_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+
+#define bch2_bkey_quota_ops (struct bkey_ops) {		\
+	.key_invalid	= bch2_quota_invalid,		\
+	.val_to_text	= bch2_quota_to_text,		\
+}
 
 enum quota_acct_mode {
 	BCH_QUOTA_PREALLOC,
diff --git a/fs/bcachefs/xattr.c b/fs/bcachefs/xattr.c
index 81e942e5039c..79a98f757cc9 100644
--- a/fs/bcachefs/xattr.c
+++ b/fs/bcachefs/xattr.c
@@ -86,8 +86,7 @@ const struct bch_hash_desc bch2_xattr_hash_desc = {
 	.cmp_bkey	= xattr_cmp_bkey,
 };
 
-static const char *bch2_xattr_invalid(const struct bch_fs *c,
-				     struct bkey_s_c k)
+const char *bch2_xattr_invalid(const struct bch_fs *c, struct bkey_s_c k)
 {
 	const struct xattr_handler *handler;
 	struct bkey_s_c_xattr xattr;
@@ -126,8 +125,8 @@ static const char *bch2_xattr_invalid(const struct bch_fs *c,
 	}
 }
 
-static void bch2_xattr_to_text(struct bch_fs *c, char *buf,
-			      size_t size, struct bkey_s_c k)
+void bch2_xattr_to_text(struct bch_fs *c, char *buf,
+			size_t size, struct bkey_s_c k)
 {
 	const struct xattr_handler *handler;
 	struct bkey_s_c_xattr xattr;
@@ -159,11 +158,6 @@ static void bch2_xattr_to_text(struct bch_fs *c, char *buf,
 	}
 }
 
-const struct bkey_ops bch2_bkey_xattr_ops = {
-	.key_invalid	= bch2_xattr_invalid,
-	.val_to_text	= bch2_xattr_to_text,
-};
-
 int bch2_xattr_get(struct bch_fs *c, struct bch_inode_info *inode,
 		  const char *name, void *buffer, size_t size, int type)
 {
diff --git a/fs/bcachefs/xattr.h b/fs/bcachefs/xattr.h
index 9c815a2d7f52..a58e7e303421 100644
--- a/fs/bcachefs/xattr.h
+++ b/fs/bcachefs/xattr.h
@@ -4,7 +4,14 @@
 #include "str_hash.h"
 
 extern const struct bch_hash_desc bch2_xattr_hash_desc;
-extern const struct bkey_ops bch2_bkey_xattr_ops;
+
+const char *bch2_xattr_invalid(const struct bch_fs *, struct bkey_s_c);
+void bch2_xattr_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+
+#define bch2_bkey_xattr_ops (struct bkey_ops) {		\
+	.key_invalid	= bch2_xattr_invalid,		\
+	.val_to_text	= bch2_xattr_to_text,		\
+}
 
 struct dentry;
 struct xattr_handler;