bcachefs: bkey_format_processed

This patch makes no functional changes; we're just introducing a new
type to be used for a new and improved __bch2_bkey_unpack_key().

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

14 files changed, 97 insertions, 99 deletions

diff --git a/fs/bcachefs/bkey.c b/fs/bcachefs/bkey.c
index da269cdecca8..6d3a1c096f1d 100644
--- a/fs/bcachefs/bkey.c
+++ b/fs/bcachefs/bkey.c
@@ -17,6 +17,13 @@
 
 const struct bkey_format bch2_bkey_format_current = BKEY_FORMAT_CURRENT;
 
+struct bkey_format_processed bch2_bkey_format_postprocess(const struct bkey_format f)
+{
+	return (struct bkey_format_processed) {
+		.f = f,
+	};
+}
+
 void bch2_bkey_packed_to_binary_text(struct printbuf *out,
 				     const struct bkey_format *f,
 				     const struct bkey_packed *k)
@@ -59,7 +66,7 @@ void bch2_bkey_packed_to_binary_text(struct printbuf *out,
 
 static void bch2_bkey_pack_verify(const struct bkey_packed *packed,
 				  const struct bkey *unpacked,
-				  const struct bkey_format *format)
+				  const struct bkey_format_processed *format)
 {
 	struct bkey tmp;
 
@@ -74,12 +81,12 @@ static void bch2_bkey_pack_verify(const struct bkey_packed *packed,
 		struct printbuf buf = PRINTBUF;
 
 		prt_printf(&buf, "keys differ: format u64s %u fields %u %u %u %u %u\n",
-		      format->key_u64s,
-		      format->bits_per_field[0],
-		      format->bits_per_field[1],
-		      format->bits_per_field[2],
-		      format->bits_per_field[3],
-		      format->bits_per_field[4]);
+		      format->f.key_u64s,
+		      format->f.bits_per_field[0],
+		      format->f.bits_per_field[1],
+		      format->f.bits_per_field[2],
+		      format->f.bits_per_field[3],
+		      format->f.bits_per_field[4]);
 
 		prt_printf(&buf, "compiled unpack: ");
 		bch2_bkey_to_text(&buf, unpacked);
@@ -106,7 +113,7 @@ static void bch2_bkey_pack_verify(const struct bkey_packed *packed,
 #else
 static inline void bch2_bkey_pack_verify(const struct bkey_packed *packed,
 					const struct bkey *unpacked,
-					const struct bkey_format *format) {}
+					const struct bkey_format_processed *format) {}
 #endif
 
 struct pack_state {
@@ -262,9 +269,10 @@ bool bch2_bkey_transform(const struct bkey_format *out_f,
 	return true;
 }
 
-struct bkey __bch2_bkey_unpack_key(const struct bkey_format *format,
-			      const struct bkey_packed *in)
+struct bkey __bch2_bkey_unpack_key(const struct bkey_format_processed *format_p,
+				   const struct bkey_packed *in)
 {
+	const struct bkey_format *format = &format_p->f;
 	struct unpack_state state = unpack_state_init(format, in);
 	struct bkey out;
 
@@ -286,9 +294,10 @@ struct bkey __bch2_bkey_unpack_key(const struct bkey_format *format,
 	return out;
 }
 
-struct bpos __bkey_unpack_pos(const struct bkey_format *format,
-				     const struct bkey_packed *in)
+struct bpos __bkey_unpack_pos(const struct bkey_format_processed *format_p,
+			      const struct bkey_packed *in)
 {
+	const struct bkey_format *format = &format_p->f;
 	struct unpack_state state = unpack_state_init(format, in);
 	struct bpos out;
 
@@ -307,13 +316,13 @@ struct bpos __bkey_unpack_pos(const struct bkey_format *format,
  * bch2_bkey_pack_key -- pack just the key, not the value
  */
 bool bch2_bkey_pack_key(struct bkey_packed *out, const struct bkey *in,
-		   const struct bkey_format *format)
+			const struct bkey_format_processed *format)
 {
-	struct pack_state state = pack_state_init(format, out);
+	struct pack_state state = pack_state_init(&format->f, out);
 	u64 *w = out->_data;
 
 	EBUG_ON((void *) in == (void *) out);
-	EBUG_ON(format->nr_fields != BKEY_NR_FIELDS);
+	EBUG_ON(format->f.nr_fields != BKEY_NR_FIELDS);
 	EBUG_ON(in->format != KEY_FORMAT_CURRENT);
 
 	*w = 0;
@@ -322,7 +331,7 @@ bool bch2_bkey_pack_key(struct bkey_packed *out, const struct bkey *in,
 	bkey_fields()
 #undef x
 	pack_state_finish(&state, out);
-	out->u64s	= format->key_u64s + in->u64s - BKEY_U64s;
+	out->u64s	= format->f.key_u64s + in->u64s - BKEY_U64s;
 	out->format	= KEY_FORMAT_LOCAL_BTREE;
 	out->needs_whiteout = in->needs_whiteout;
 	out->type	= in->type;
@@ -335,7 +344,7 @@ bool bch2_bkey_pack_key(struct bkey_packed *out, const struct bkey *in,
  * bch2_bkey_unpack -- unpack the key and the value
  */
 void bch2_bkey_unpack(const struct btree *b, struct bkey_i *dst,
-		 const struct bkey_packed *src)
+		      const struct bkey_packed *src)
 {
 	__bkey_unpack_key(b, &dst->k, src);
 
@@ -348,17 +357,17 @@ void bch2_bkey_unpack(const struct btree *b, struct bkey_i *dst,
  * bch2_bkey_pack -- pack the key and the value
  */
 bool bch2_bkey_pack(struct bkey_packed *out, const struct bkey_i *in,
-	       const struct bkey_format *format)
+		    const struct bkey_format_processed *format)
 {
 	struct bkey_packed tmp;
 
 	if (!bch2_bkey_pack_key(&tmp, &in->k, format))
 		return false;
 
-	memmove_u64s((u64 *) out + format->key_u64s,
+	memmove_u64s((u64 *) out + format->f.key_u64s,
 		     &in->v,
 		     bkey_val_u64s(&in->k));
-	memcpy_u64s_small(out, &tmp, format->key_u64s);
+	memcpy_u64s_small(out, &tmp, format->f.key_u64s);
 
 	return true;
 }
@@ -399,7 +408,7 @@ static bool bkey_packed_successor(struct bkey_packed *out,
 				  const struct btree *b,
 				  struct bkey_packed k)
 {
-	const struct bkey_format *f = &b->format;
+	const struct bkey_format *f = &b->format.f;
 	unsigned nr_key_bits = b->nr_key_bits;
 	unsigned first_bit, offset;
 	u64 *p;
@@ -447,7 +456,7 @@ enum bkey_pack_pos_ret bch2_bkey_pack_pos_lossy(struct bkey_packed *out,
 					   struct bpos in,
 					   const struct btree *b)
 {
-	const struct bkey_format *f = &b->format;
+	const struct bkey_format *f = &b->format.f;
 	struct pack_state state = pack_state_init(f, out);
 	u64 *w = out->_data;
 #ifdef CONFIG_BCACHEFS_DEBUG
@@ -647,8 +656,8 @@ unsigned bch2_bkey_greatest_differing_bit(const struct btree *b,
 					  const struct bkey_packed *l_k,
 					  const struct bkey_packed *r_k)
 {
-	const u64 *l = high_word(&b->format, l_k);
-	const u64 *r = high_word(&b->format, r_k);
+	const u64 *l = high_word(&b->format.f, l_k);
+	const u64 *r = high_word(&b->format.f, r_k);
 	unsigned nr_key_bits = b->nr_key_bits;
 	unsigned word_bits = 64 - high_bit_offset;
 	u64 l_v, r_v;
@@ -689,7 +698,7 @@ unsigned bch2_bkey_greatest_differing_bit(const struct btree *b,
 __pure
 unsigned bch2_bkey_ffs(const struct btree *b, const struct bkey_packed *k)
 {
-	const u64 *p = high_word(&b->format, k);
+	const u64 *p = high_word(&b->format.f, k);
 	unsigned nr_key_bits = b->nr_key_bits;
 	unsigned ret = 0, offset;
 
@@ -789,19 +798,20 @@ void bch2_bkey_pack_test(void)
 	struct bkey t = KEY(4134ULL, 1250629070527416633ULL, 0);
 	struct bkey_packed p;
 
-	struct bkey_format test_format = {
-		.key_u64s	= 3,
-		.nr_fields	= BKEY_NR_FIELDS,
-		.bits_per_field = {
-			13,
-			64,
-			32,
-		},
-	};
+	struct bkey_format_processed test_format =
+		bch2_bkey_format_postprocess((struct bkey_format) {
+			.key_u64s	= 3,
+			.nr_fields	= BKEY_NR_FIELDS,
+			.bits_per_field = {
+				13,
+				64,
+				32,
+			},
+		});
 
 	struct unpack_state in_s =
 		unpack_state_init(&bch2_bkey_format_current, (void *) &t);
-	struct pack_state out_s = pack_state_init(&test_format, &p);
+	struct pack_state out_s = pack_state_init(&test_format.f, &p);
 	unsigned i;
 
 	for (i = 0; i < out_s.format->nr_fields; i++) {
diff --git a/fs/bcachefs/bkey.h b/fs/bcachefs/bkey.h
index 7c198bcc90c9..97da5a5b1175 100644
--- a/fs/bcachefs/bkey.h
+++ b/fs/bcachefs/bkey.h
@@ -9,6 +9,8 @@
 #include "util.h"
 #include "vstructs.h"
 
+struct bkey_format_processed bch2_bkey_format_postprocess(const struct bkey_format);
+
 void bch2_bkey_packed_to_binary_text(struct printbuf *,
 				     const struct bkey_format *,
 				     const struct bkey_packed *);
@@ -345,34 +347,34 @@ static inline struct bpos bkey_start_pos(const struct bkey *k)
 
 /* Packed helpers */
 
-static inline unsigned bkeyp_key_u64s(const struct bkey_format *format,
+static inline unsigned bkeyp_key_u64s(const struct bkey_format_processed *format,
 				      const struct bkey_packed *k)
 {
-	unsigned ret = bkey_packed(k) ? format->key_u64s : BKEY_U64s;
+	unsigned ret = bkey_packed(k) ? format->f.key_u64s : BKEY_U64s;
 
 	EBUG_ON(k->u64s < ret);
 	return ret;
 }
 
-static inline unsigned bkeyp_key_bytes(const struct bkey_format *format,
+static inline unsigned bkeyp_key_bytes(const struct bkey_format_processed *format,
 				       const struct bkey_packed *k)
 {
 	return bkeyp_key_u64s(format, k) * sizeof(u64);
 }
 
-static inline unsigned bkeyp_val_u64s(const struct bkey_format *format,
+static inline unsigned bkeyp_val_u64s(const struct bkey_format_processed *format,
 				      const struct bkey_packed *k)
 {
 	return k->u64s - bkeyp_key_u64s(format, k);
 }
 
-static inline size_t bkeyp_val_bytes(const struct bkey_format *format,
+static inline size_t bkeyp_val_bytes(const struct bkey_format_processed *format,
 				     const struct bkey_packed *k)
 {
 	return bkeyp_val_u64s(format, k) * sizeof(u64);
 }
 
-static inline void set_bkeyp_val_u64s(const struct bkey_format *format,
+static inline void set_bkeyp_val_u64s(const struct bkey_format_processed *format,
 				      struct bkey_packed *k, unsigned val_u64s)
 {
 	k->u64s = bkeyp_key_u64s(format, k) + val_u64s;
@@ -388,14 +390,14 @@ bool bch2_bkey_transform(const struct bkey_format *,
 			 const struct bkey_format *,
 			 const struct bkey_packed *);
 
-struct bkey __bch2_bkey_unpack_key(const struct bkey_format *,
+struct bkey __bch2_bkey_unpack_key(const struct bkey_format_processed *,
 				   const struct bkey_packed *);
 
-struct bpos __bkey_unpack_pos(const struct bkey_format *,
+struct bpos __bkey_unpack_pos(const struct bkey_format_processed *,
 			      const struct bkey_packed *);
 
 bool bch2_bkey_pack_key(struct bkey_packed *, const struct bkey *,
-		   const struct bkey_format *);
+			const struct bkey_format_processed *);
 
 enum bkey_pack_pos_ret {
 	BKEY_PACK_POS_EXACT,
@@ -413,9 +415,9 @@ static inline bool bkey_pack_pos(struct bkey_packed *out, struct bpos in,
 }
 
 void bch2_bkey_unpack(const struct btree *, struct bkey_i *,
-		 const struct bkey_packed *);
+		      const struct bkey_packed *);
 bool bch2_bkey_pack(struct bkey_packed *, const struct bkey_i *,
-	       const struct bkey_format *);
+		    const struct bkey_format_processed *);
 
 typedef void (*compiled_unpack_fn)(struct bkey *, const struct bkey_packed *);
 
diff --git a/fs/bcachefs/bkey_cmp.h b/fs/bcachefs/bkey_cmp.h
index 5f42a6e69360..f8f194d9a56c 100644
--- a/fs/bcachefs/bkey_cmp.h
+++ b/fs/bcachefs/bkey_cmp.h
@@ -90,7 +90,7 @@ int __bch2_bkey_cmp_packed_format_checked_inlined(const struct bkey_packed *l,
 					  const struct bkey_packed *r,
 					  const struct btree *b)
 {
-	const struct bkey_format *f = &b->format;
+	const struct bkey_format *f = &b->format.f;
 	int ret;
 
 	EBUG_ON(!bkey_packed(l) || !bkey_packed(r));
diff --git a/fs/bcachefs/bkey_methods.c b/fs/bcachefs/bkey_methods.c
index 79f3fbe925d5..bf22912b1237 100644
--- a/fs/bcachefs/bkey_methods.c
+++ b/fs/bcachefs/bkey_methods.c
@@ -427,9 +427,10 @@ void bch2_bkey_renumber(enum btree_node_type btree_node_type,
 void __bch2_bkey_compat(unsigned level, enum btree_id btree_id,
 			unsigned version, unsigned big_endian,
 			int write,
-			struct bkey_format *f,
+			struct btree *b,
 			struct bkey_packed *k)
 {
+	struct bkey_format_processed *f = b ? &b->format : NULL;
 	const struct bkey_ops *ops;
 	struct bkey uk;
 	struct bkey_s u;
@@ -444,7 +445,7 @@ void __bch2_bkey_compat(unsigned level, enum btree_id btree_id,
 	switch (!write ? i : nr_compat - 1 - i) {
 	case 0:
 		if (big_endian != CPU_BIG_ENDIAN)
-			bch2_bkey_swab_key(f, k);
+			bch2_bkey_swab_key(&f->f, k);
 		break;
 	case 1:
 		if (version < bcachefs_metadata_version_bkey_renumber)
@@ -457,14 +458,14 @@ void __bch2_bkey_compat(unsigned level, enum btree_id btree_id,
 				struct bkey_i *u = packed_to_bkey(k);
 
 				swap(u->k.p.inode, u->k.p.offset);
-			} else if (f->bits_per_field[BKEY_FIELD_INODE] &&
-				   f->bits_per_field[BKEY_FIELD_OFFSET]) {
-				struct bkey_format tmp = *f, *in = f, *out = &tmp;
+			} else if (f->f.bits_per_field[BKEY_FIELD_INODE] &&
+				   f->f.bits_per_field[BKEY_FIELD_OFFSET]) {
+				struct bkey_format_processed tmp = *f, *in = f, *out = &tmp;
 
-				swap(tmp.bits_per_field[BKEY_FIELD_INODE],
-				     tmp.bits_per_field[BKEY_FIELD_OFFSET]);
-				swap(tmp.field_offset[BKEY_FIELD_INODE],
-				     tmp.field_offset[BKEY_FIELD_OFFSET]);
+				swap(tmp.f.bits_per_field[BKEY_FIELD_INODE],
+				     tmp.f.bits_per_field[BKEY_FIELD_OFFSET]);
+				swap(tmp.f.field_offset[BKEY_FIELD_INODE],
+				     tmp.f.field_offset[BKEY_FIELD_OFFSET]);
 
 				if (!write)
 					swap(in, out);
@@ -484,9 +485,9 @@ void __bch2_bkey_compat(unsigned level, enum btree_id btree_id,
 				u->k.p.snapshot = write
 					? 0 : U32_MAX;
 			} else {
-				u64 min_packed = f->field_offset[BKEY_FIELD_SNAPSHOT];
+				u64 min_packed = f->f.field_offset[BKEY_FIELD_SNAPSHOT];
 				u64 max_packed = min_packed +
-					~(~0ULL << f->bits_per_field[BKEY_FIELD_SNAPSHOT]);
+					~(~0ULL << f->f.bits_per_field[BKEY_FIELD_SNAPSHOT]);
 
 				uk = __bch2_bkey_unpack_key(f, k);
 				uk.p.snapshot = write
diff --git a/fs/bcachefs/bkey_methods.h b/fs/bcachefs/bkey_methods.h
index a65756e306b0..be0728f1b78a 100644
--- a/fs/bcachefs/bkey_methods.h
+++ b/fs/bcachefs/bkey_methods.h
@@ -161,18 +161,18 @@ static inline int bch2_trans_mark_new(struct btree_trans *trans,
 void bch2_bkey_renumber(enum btree_node_type, struct bkey_packed *, int);
 
 void __bch2_bkey_compat(unsigned, enum btree_id, unsigned, unsigned,
-			int, struct bkey_format *, struct bkey_packed *);
+			int, struct btree *, struct bkey_packed *);
 
 static inline void bch2_bkey_compat(unsigned level, enum btree_id btree_id,
 			       unsigned version, unsigned big_endian,
 			       int write,
-			       struct bkey_format *f,
+			       struct btree *b,
 			       struct bkey_packed *k)
 {
 	if (version < bcachefs_metadata_version_current ||
 	    big_endian != CPU_BIG_ENDIAN)
 		__bch2_bkey_compat(level, btree_id, version,
-				   big_endian, write, f, k);
+				   big_endian, write, b, k);
 
 }
 
diff --git a/fs/bcachefs/bkey_sort.c b/fs/bcachefs/bkey_sort.c
index b9aa027c881b..70f78fb6bd9b 100644
--- a/fs/bcachefs/bkey_sort.c
+++ b/fs/bcachefs/bkey_sort.c
@@ -125,7 +125,7 @@ bch2_sort_repack(struct bset *dst, struct btree *src,
 		 struct bkey_format *out_f,
 		 bool filter_whiteouts)
 {
-	struct bkey_format *in_f = &src->format;
+	struct bkey_format *in_f = &src->format.f;
 	struct bkey_packed *in, *out = vstruct_last(dst);
 	struct btree_nr_keys nr;
 	bool transform = memcmp(out_f, &src->format, sizeof(*out_f));
@@ -167,7 +167,7 @@ unsigned bch2_sort_keys(struct bkey_packed *dst,
 			struct sort_iter *iter,
 			bool filter_whiteouts)
 {
-	const struct bkey_format *f = &iter->b->format;
+	const struct bkey_format_processed *f = &iter->b->format;
 	struct bkey_packed *in, *next, *out = dst;
 
 	sort_iter_sort(iter, sort_keys_cmp);
diff --git a/fs/bcachefs/bset.c b/fs/bcachefs/bset.c
index 1f3d9863fbba..9e05e4e6e267 100644
--- a/fs/bcachefs/bset.c
+++ b/fs/bcachefs/bset.c
@@ -646,9 +646,9 @@ static inline void make_bfloat(struct btree *b, struct bset_tree *t,
 	 * (k->_data), to get the key bits starting at exponent:
 	 */
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-	shift = (int) (b->format.key_u64s * 64 - b->nr_key_bits) + exponent;
+	shift = (int) (b->format.f.key_u64s * 64 - b->nr_key_bits) + exponent;
 
-	EBUG_ON(shift + BKEY_MANTISSA_BITS > b->format.key_u64s * 64);
+	EBUG_ON(shift + BKEY_MANTISSA_BITS > b->format.f.key_u64s * 64);
 #else
 	shift = high_bit_offset +
 		b->nr_key_bits -
@@ -997,7 +997,7 @@ void bch2_bset_insert(struct btree *b,
 		      struct bkey_i *insert,
 		      unsigned clobber_u64s)
 {
-	struct bkey_format *f = &b->format;
+	struct bkey_format_processed *f = &b->format;
 	struct bset_tree *t = bset_tree_last(b);
 	struct bkey_packed packed, *src = bkey_to_packed(insert);
 
@@ -1095,7 +1095,7 @@ static inline bool bkey_mantissa_bits_dropped(const struct btree *b,
 					      unsigned idx)
 {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-	unsigned key_bits_start = b->format.key_u64s * 64 - b->nr_key_bits;
+	unsigned key_bits_start = b->format.f.key_u64s * 64 - b->nr_key_bits;
 
 	return f->exponent > key_bits_start;
 #else
diff --git a/fs/bcachefs/bset.h b/fs/bcachefs/bset.h
index 52dbeba8460c..83bf35cedc7d 100644
--- a/fs/bcachefs/bset.h
+++ b/fs/bcachefs/bset.h
@@ -238,7 +238,7 @@ static inline void bch2_bset_set_no_aux_tree(struct btree *b,
 static inline void btree_node_set_format(struct btree *b,
 					 struct bkey_format f)
 {
-	b->format	= f;
+	b->format	= bch2_bkey_format_postprocess(f);
 	b->nr_key_bits	= bkey_format_key_bits(&f);
 
 	bch2_bset_set_no_aux_tree(b, b->set);
diff --git a/fs/bcachefs/btree_cache.c b/fs/bcachefs/btree_cache.c
index a51587439c35..b1e3e302362d 100644
--- a/fs/bcachefs/btree_cache.c
+++ b/fs/bcachefs/btree_cache.c
@@ -1204,7 +1204,7 @@ wait_on_io:
 void bch2_btree_node_to_text(struct printbuf *out, struct bch_fs *c,
 			     const struct btree *b)
 {
-	const struct bkey_format *f = &b->format;
+	const struct bkey_format *f = &b->format.f;
 	struct bset_stats stats;
 
 	memset(&stats, 0, sizeof(stats));
diff --git a/fs/bcachefs/btree_io.c b/fs/bcachefs/btree_io.c
index decbbaace1ee..30c4cc654305 100644
--- a/fs/bcachefs/btree_io.c
+++ b/fs/bcachefs/btree_io.c
@@ -393,7 +393,7 @@ void bch2_btree_sort_into(struct bch_fs *c,
 
 	nr = bch2_sort_repack(btree_bset_first(dst),
 			src, &src_iter,
-			&dst->format,
+			&dst->format.f,
 			true);
 
 	bch2_time_stats_update(&c->times[BCH_TIME_btree_node_sort],
@@ -862,8 +862,7 @@ static int validate_bset_keys(struct bch_fs *c, struct btree *b,
 		/* XXX: validate k->u64s */
 		if (!write)
 			bch2_bkey_compat(b->c.level, b->c.btree_id, version,
-				    BSET_BIG_ENDIAN(i), write,
-				    &b->format, k);
+				    BSET_BIG_ENDIAN(i), write, b, k);
 
 		u = __bkey_disassemble(b, k, &tmp);
 
@@ -885,8 +884,7 @@ static int validate_bset_keys(struct bch_fs *c, struct btree *b,
 
 		if (write)
 			bch2_bkey_compat(b->c.level, b->c.btree_id, version,
-				    BSET_BIG_ENDIAN(i), write,
-				    &b->format, k);
+				    BSET_BIG_ENDIAN(i), write, b, k);
 
 		if (prev && bkey_iter_cmp(b, prev, k) > 0) {
 			struct bkey up = bkey_unpack_key(b, prev);
@@ -1935,7 +1933,7 @@ do_write:
 	BUG_ON(b->written & (block_sectors(c) - 1));
 	BUG_ON(bset_written(b, btree_bset_last(b)));
 	BUG_ON(le64_to_cpu(b->data->magic) != bset_magic(c));
-	BUG_ON(memcmp(&b->data->format, &b->format, sizeof(b->format)));
+	BUG_ON(memcmp(&b->data->format, &b->format.f, sizeof(b->format.f)));
 
 	bch2_sort_whiteouts(c, b);
 
diff --git a/fs/bcachefs/btree_types.h b/fs/bcachefs/btree_types.h
index 1fb087310e19..58ce60c37ecd 100644
--- a/fs/bcachefs/btree_types.h
+++ b/fs/bcachefs/btree_types.h
@@ -68,6 +68,10 @@ struct btree_bkey_cached_common {
 	bool			cached;
 };
 
+struct bkey_format_processed {
+	struct bkey_format	f;
+};
+
 struct btree {
 	struct btree_bkey_cached_common c;
 
@@ -80,7 +84,8 @@ struct btree {
 	u8			nr_key_bits;
 	u16			version_ondisk;
 
-	struct bkey_format	format;
+	struct bkey_format_processed
+				format;
 
 	struct btree_node	*data;
 	void			*aux_data;
diff --git a/fs/bcachefs/btree_update_interior.c b/fs/bcachefs/btree_update_interior.c
index 6ba0954e648e..153d15c7e8a4 100644
--- a/fs/bcachefs/btree_update_interior.c
+++ b/fs/bcachefs/btree_update_interior.c
@@ -128,7 +128,7 @@ static struct bkey_format bch2_btree_calc_format(struct btree *b)
 static size_t btree_node_u64s_with_format(struct btree *b,
 					  struct bkey_format *new_f)
 {
-	struct bkey_format *old_f = &b->format;
+	struct bkey_format *old_f = &b->format.f;
 
 	/* stupid integer promotion rules */
 	ssize_t delta =
@@ -393,7 +393,7 @@ static struct btree *bch2_btree_node_alloc_replacement(struct btree_update *as,
 	 * the btree node anymore, use the old format for now:
 	 */
 	if (!bch2_btree_node_format_fits(as->c, b, &format))
-		format = b->format;
+		format = b->format.f;
 
 	SET_BTREE_NODE_SEQ(n->data, BTREE_NODE_SEQ(b->data) + 1);
 
@@ -1406,8 +1406,8 @@ static void __btree_split_node(struct btree_update *as,
 		i = u64s >= n1_u64s;
 		u64s += k->u64s;
 
-		if (bch2_bkey_transform(&n[i]->format, out[i], bkey_packed(k)
-					? &b->format: &bch2_bkey_format_current, k))
+		if (bch2_bkey_transform(&n[i]->format.f, out[i], bkey_packed(k)
+					? &b->format.f : &bch2_bkey_format_current, k))
 			out[i]->format = KEY_FORMAT_LOCAL_BTREE;
 		else
 			bch2_bkey_unpack(b, (void *) out[i], k);
diff --git a/fs/bcachefs/extents.h b/fs/bcachefs/extents.h
index 31c8140950e0..b2420c169452 100644
--- a/fs/bcachefs/extents.h
+++ b/fs/bcachefs/extents.h
@@ -733,22 +733,4 @@ static inline void bch2_key_resize(struct bkey *k, unsigned new_size)
 	k->size = new_size;
 }
 
-/*
- * In extent_sort_fix_overlapping(), insert_fixup_extent(),
- * extent_merge_inline() - we're modifying keys in place that are packed. To do
- * that we have to unpack the key, modify the unpacked key - then this
- * copies/repacks the unpacked to the original as necessary.
- */
-static inline void extent_save(struct btree *b, struct bkey_packed *dst,
-			       struct bkey *src)
-{
-	struct bkey_format *f = &b->format;
-	struct bkey_i *dst_unpacked;
-
-	if ((dst_unpacked = packed_to_bkey(dst)))
-		dst_unpacked->k = *src;
-	else
-		BUG_ON(!bch2_bkey_pack_key(dst, src, f));
-}
-
 #endif /* _BCACHEFS_EXTENTS_H */
diff --git a/fs/bcachefs/move.c b/fs/bcachefs/move.c
index 2ec30a3fd193..f8083feea4ca 100644
--- a/fs/bcachefs/move.c
+++ b/fs/bcachefs/move.c
@@ -1002,7 +1002,7 @@ static bool rewrite_old_nodes_pred(struct bch_fs *c, void *arg,
 {
 	if (b->version_ondisk != c->sb.version ||
 	    btree_node_need_rewrite(b) ||
-	    bformat_needs_redo(&b->format)) {
+	    bformat_needs_redo(&b->format.f)) {
 		data_opts->target		= 0;
 		data_opts->extra_replicas	= 0;
 		data_opts->btree_insert_flags	= 0;