bcache: Drop btree_node_iter->b, btree_node_iter->size

Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>

5 files changed, 103 insertions, 98 deletions

diff --git a/drivers/md/bcache/bset.c b/drivers/md/bcache/bset.c
index 04a0cfa31087..00d34daf5199 100644
--- a/drivers/md/bcache/bset.c
+++ b/drivers/md/bcache/bset.c
@@ -828,7 +828,7 @@ void bch_bset_insert(struct btree_keys *b,
 		 * key comes after the key being modified, so the iter will have
 		 * advanced past it.
 		 */
-		bch_btree_node_iter_sort(iter);
+		bch_btree_node_iter_sort(iter, b);
 		return;
 	}
 
@@ -870,7 +870,7 @@ void bch_bset_insert(struct btree_keys *b,
 	bch_bset_fix_lookup_table(b, t, where);
 	bch_btree_node_iter_fix(iter, where);
 
-	bch_btree_node_iter_verify(b, iter);
+	bch_btree_node_iter_verify(iter, b);
 }
 EXPORT_SYMBOL(bch_bset_insert);
 
@@ -1042,10 +1042,11 @@ static struct bkey_packed *bch_bset_search(struct btree_keys *b,
 /* Btree node iterator */
 
 static inline bool btree_node_iter_cmp(struct btree_node_iter *iter,
+				       struct btree_keys *b,
 				       struct btree_node_iter_set l,
 				       struct btree_node_iter_set r)
 {
-	s64 c = bkey_cmp_packed(&iter->b->set->data->format, l.k, r.k);
+	s64 c = bkey_cmp_packed(&b->set->data->format, l.k, r.k);
 
 	/*
 	 * For non extents, when keys compare equal the deleted keys have to
@@ -1062,7 +1063,9 @@ static inline bool btree_node_iter_cmp(struct btree_node_iter *iter,
 }
 
 void bch_btree_node_iter_push(struct btree_node_iter *iter,
-			      struct bkey_packed *k, struct bkey_packed *end)
+			      struct btree_keys *b,
+			      struct bkey_packed *k,
+			      struct bkey_packed *end)
 {
 	if (k != end) {
 		struct btree_node_iter_set n =
@@ -1071,11 +1074,10 @@ void bch_btree_node_iter_push(struct btree_node_iter *iter,
 
 		for (i = 0;
 		     i < iter->used &&
-		     btree_node_iter_cmp(iter, n, iter->data[i]);
+		     btree_node_iter_cmp(iter, b, n, iter->data[i]);
 		     i++)
 			;
 
-		BUG_ON(iter->used >= iter->size);
 		memmove(&iter->data[i + 1],
 			&iter->data[i],
 			(iter->used - i) * sizeof(struct btree_node_iter_set));
@@ -1084,43 +1086,40 @@ void bch_btree_node_iter_push(struct btree_node_iter *iter,
 	}
 }
 
-static void __bch_btree_node_iter_init(struct btree_keys *b,
-				       struct btree_node_iter *iter,
+static void __bch_btree_node_iter_init(struct btree_node_iter *iter,
+				       struct btree_keys *b,
 				       struct bset_tree *start)
 {
-	iter->size = ARRAY_SIZE(iter->data);
 	iter->used = 0;
 	iter->is_extents = b->ops->is_extents;
-	iter->b	= b;
 }
 
-void bch_btree_node_iter_init(struct btree_keys *b,
-			      struct btree_node_iter *iter,
-			      struct bpos search)
+void bch_btree_node_iter_init(struct btree_node_iter *iter,
+			      struct btree_keys *b, struct bpos search)
 {
 	struct bset_tree *t;
 	struct bkey_packed p, *packed_search =
 		bkey_pack_pos(&p, search, &b->set->data->format) ? &p : NULL;
 
-	__bch_btree_node_iter_init(b, iter, b->set);
+	__bch_btree_node_iter_init(iter, b, b->set);
 
 	for (t = b->set; t <= b->set + b->nsets; t++)
-		bch_btree_node_iter_push(iter,
+		bch_btree_node_iter_push(iter, b,
 					 bch_bset_search(b, t, search,
 							 packed_search),
 					 bset_bkey_last(t->data));
 }
 EXPORT_SYMBOL(bch_btree_node_iter_init);
 
-void bch_btree_node_iter_init_from_start(struct btree_keys *b,
-					 struct btree_node_iter *iter)
+void bch_btree_node_iter_init_from_start(struct btree_node_iter *iter,
+					 struct btree_keys *b)
 {
 	struct bset_tree *t;
 
-	__bch_btree_node_iter_init(b, iter, b->set);
+	__bch_btree_node_iter_init(iter, b, b->set);
 
 	for (t = b->set; t <= b->set + b->nsets; t++)
-		bch_btree_node_iter_push(iter,
+		bch_btree_node_iter_push(iter, b,
 					 t->data->start,
 					 bset_bkey_last(t->data));
 }
@@ -1143,6 +1142,7 @@ struct bkey_packed *bch_btree_node_iter_bset_pos(struct btree_node_iter *iter,
 }
 
 static inline void btree_node_iter_sift(struct btree_node_iter *iter,
+					struct btree_keys *b,
 					unsigned start)
 {
 	unsigned i;
@@ -1151,19 +1151,20 @@ static inline void btree_node_iter_sift(struct btree_node_iter *iter,
 
 	for (i = start;
 	     i + 1 < iter->used &&
-	     btree_node_iter_cmp(iter, iter->data[i], iter->data[i + 1]);
+	     btree_node_iter_cmp(iter, b, iter->data[i], iter->data[i + 1]);
 	     i++)
 		swap(iter->data[i], iter->data[i + 1]);
 }
 
-void bch_btree_node_iter_sort(struct btree_node_iter *iter)
+void bch_btree_node_iter_sort(struct btree_node_iter *iter,
+			      struct btree_keys *b)
 {
 	int i;
 
 	BUG_ON(iter->used > MAX_BSETS);
 
 	for (i = iter->used - 1; i >= 0; --i)
-		btree_node_iter_sift(iter, i);
+		btree_node_iter_sift(iter, b, i);
 }
 EXPORT_SYMBOL(bch_btree_node_iter_sort);
 
@@ -1173,7 +1174,8 @@ EXPORT_SYMBOL(bch_btree_node_iter_sort);
  * Doesn't do debugchecks - for cases where (insert_fixup_extent()) a bset might
  * momentarily have out of order extents.
  */
-void bch_btree_node_iter_advance(struct btree_node_iter *iter)
+void bch_btree_node_iter_advance(struct btree_node_iter *iter,
+				 struct btree_keys *b)
 {
 	iter->data->k = bkey_next(iter->data->k);
 
@@ -1184,13 +1186,13 @@ void bch_btree_node_iter_advance(struct btree_node_iter *iter)
 		iter->data[0] = iter->data[--iter->used];
 	}
 
-	btree_node_iter_sift(iter, 0);
+	btree_node_iter_sift(iter, b, 0);
 }
 EXPORT_SYMBOL(bch_btree_node_iter_advance);
 
 #ifdef CONFIG_BCACHE_DEBUG
-void bch_btree_node_iter_verify(struct btree_keys *b,
-				struct btree_node_iter *iter)
+void bch_btree_node_iter_verify(struct btree_node_iter *iter,
+				struct btree_keys *b)
 {
 	struct btree_node_iter_set *set;
 	struct bset_tree *t;
@@ -1201,7 +1203,7 @@ void bch_btree_node_iter_verify(struct btree_keys *b,
 	     set < iter->data + iter->used;
 	     set++) {
 		BUG_ON(set + 1 < iter->data + iter->used &&
-		       btree_node_iter_cmp(iter, set[0], set[1]));
+		       btree_node_iter_cmp(iter, b, set[0], set[1]));
 
 		for (t =  b->set;
 		     t <= b->set + b->nsets;
@@ -1215,9 +1217,10 @@ next:
 }
 
 static void bch_btree_node_iter_next_check(struct btree_node_iter *iter,
+					   struct btree_keys *b,
 					   struct bkey_packed *k)
 {
-	const struct bkey_format *f = &iter->b->set->data->format;
+	const struct bkey_format *f = &b->set->data->format;
 
 	bkey_unpack_key(f, k);
 
@@ -1227,20 +1230,21 @@ static void bch_btree_node_iter_next_check(struct btree_node_iter *iter,
 		struct bkey nu = bkey_unpack_key(f, iter->data->k);
 		char buf1[80], buf2[80];
 
-		bch_dump_bucket(iter->b);
+		bch_dump_bucket(b);
 		bch_bkey_to_text(buf1, sizeof(buf1), &ku);
 		bch_bkey_to_text(buf2, sizeof(buf2), &nu);
 		panic("out of order/overlapping:\n%s\n%s\n", buf1, buf2);
 	}
 }
 
-struct bkey_packed *bch_btree_node_iter_next_all(struct btree_node_iter *iter)
+struct bkey_packed *bch_btree_node_iter_next_all(struct btree_node_iter *iter,
+						 struct btree_keys *b)
 {
 	struct bkey_packed *ret = bch_btree_node_iter_peek_all(iter);
 
 	if (ret) {
-		bch_btree_node_iter_advance(iter);
-		bch_btree_node_iter_next_check(iter, ret);
+		bch_btree_node_iter_advance(iter, b);
+		bch_btree_node_iter_next_check(iter, b, ret);
 	}
 
 	return ret;
@@ -1248,12 +1252,12 @@ struct bkey_packed *bch_btree_node_iter_next_all(struct btree_node_iter *iter)
 EXPORT_SYMBOL(bch_btree_node_iter_next_all);
 #endif
 
-bool bch_btree_node_iter_next_unpack(struct btree_keys *b,
-				     struct btree_node_iter *iter,
+bool bch_btree_node_iter_next_unpack(struct btree_node_iter *iter,
+				     struct btree_keys *b,
 				     struct bkey_tup *tup)
 {
 	struct bkey_format *f = &b->set->data->format;
-	struct bkey_packed *k = bch_btree_node_iter_next(iter);
+	struct bkey_packed *k = bch_btree_node_iter_next(iter, b);
 
 	if (!k)
 		return false;
@@ -1295,7 +1299,7 @@ static void btree_mergesort(struct btree_keys *b, struct bset *bset,
 	struct bkey_tup tup;
 
 	while (!bch_btree_node_iter_end(iter)) {
-		k = bch_btree_node_iter_next_all(iter);
+		k = bch_btree_node_iter_next_all(iter, b);
 
 		BUG_ON((void *) __bkey_idx(out, k->u64s) >
 		       (void *) bset + (PAGE_SIZE << b->page_order));
@@ -1429,10 +1433,10 @@ void bch_btree_sort_partial(struct btree_keys *b, unsigned start,
 	struct btree_node_iter iter;
 	struct bset_tree *t;
 
-	__bch_btree_node_iter_init(b, &iter, &b->set[start]);
+	__bch_btree_node_iter_init(&iter, b, &b->set[start]);
 
 	for (t = b->set + start; t <= b->set + b->nsets; t++)
-		bch_btree_node_iter_push(&iter,
+		bch_btree_node_iter_push(&iter, b,
 					 t->data->start,
 					 bset_bkey_last(t->data));
 
@@ -1470,7 +1474,7 @@ void bch_btree_sort_into(struct btree_keys *dst,
 	uint64_t start_time = local_clock();
 	struct btree_node_iter iter;
 
-	bch_btree_node_iter_init_from_start(src, &iter);
+	bch_btree_node_iter_init_from_start(&iter, src);
 
 	btree_mergesort(src, dst->set->data, &iter, filter, true);
 
diff --git a/drivers/md/bcache/bset.h b/drivers/md/bcache/bset.h
index 8275d60bb82b..f8e57b1fd223 100644
--- a/drivers/md/bcache/bset.h
+++ b/drivers/md/bcache/bset.h
@@ -398,27 +398,24 @@ static inline enum bch_extent_overlap bch_extent_overlap(const struct bkey *k,
 
 struct btree_node_iter {
 	u8		is_extents;
+	unsigned	used:24;
 
-	unsigned	size:24;
-	unsigned	used;
-
-	struct btree_keys *b;
 	struct btree_node_iter_set {
 		struct bkey_packed *k, *end;
 	} data[MAX_BSETS];
 };
 
-void bch_btree_node_iter_push(struct btree_node_iter *,
+void bch_btree_node_iter_push(struct btree_node_iter *, struct btree_keys *,
 			      struct bkey_packed *, struct bkey_packed *);
-void bch_btree_node_iter_init(struct btree_keys *, struct btree_node_iter *,
+void bch_btree_node_iter_init(struct btree_node_iter *, struct btree_keys *,
 			      struct bpos);
-void bch_btree_node_iter_init_from_start(struct btree_keys *,
-					 struct btree_node_iter *);
+void bch_btree_node_iter_init_from_start(struct btree_node_iter *,
+					 struct btree_keys *);
 struct bkey_packed *bch_btree_node_iter_bset_pos(struct btree_node_iter *,
 						 struct bset *);
 
-void bch_btree_node_iter_sort(struct btree_node_iter *);
-void bch_btree_node_iter_advance(struct btree_node_iter *);
+void bch_btree_node_iter_sort(struct btree_node_iter *, struct btree_keys *);
+void bch_btree_node_iter_advance(struct btree_node_iter *, struct btree_keys *);
 
 static inline bool bch_btree_node_iter_end(struct btree_node_iter *iter)
 {
@@ -436,55 +433,57 @@ bch_btree_node_iter_peek_all(struct btree_node_iter *iter)
 /* In debug mode, bch_btree_node_iter_next_all() does debug checks */
 
 #ifdef CONFIG_BCACHE_DEBUG
-struct bkey_packed *bch_btree_node_iter_next_all(struct btree_node_iter *);
+struct bkey_packed *bch_btree_node_iter_next_all(struct btree_node_iter *,
+						 struct btree_keys *);
 #else
 static inline struct bkey_packed *
-bch_btree_node_iter_next_all(struct btree_node_iter *iter)
+bch_btree_node_iter_next_all(struct btree_node_iter *iter, struct btree_keys *b)
 {
 	struct bkey_packed *ret = bch_btree_node_iter_peek_all(iter);
 
 	if (ret)
-		bch_btree_node_iter_advance(iter);
+		bch_btree_node_iter_advance(iter, b);
 
 	return ret;
 }
 #endif
 
 static inline struct bkey_packed *
-bch_btree_node_iter_next(struct btree_node_iter *iter)
+bch_btree_node_iter_next(struct btree_node_iter *iter, struct btree_keys *b)
 {
 	struct bkey_packed *ret;
 
 	do {
-		ret = bch_btree_node_iter_next_all(iter);
+		ret = bch_btree_node_iter_next_all(iter, b);
 	} while (ret && bkey_deleted(ret));
 
 	return ret;
 }
 
 static inline struct bkey_packed *
-bch_btree_node_iter_peek(struct btree_node_iter *iter)
+bch_btree_node_iter_peek(struct btree_node_iter *iter, struct btree_keys *b)
 {
 	struct bkey_packed *ret;
 
 	while ((ret = bch_btree_node_iter_peek_all(iter)) &&
 	       bkey_deleted(ret))
-		bch_btree_node_iter_next_all(iter);
+		bch_btree_node_iter_next_all(iter, b);
 
 	return ret;
 }
 
 static inline struct bkey_packed *
 bch_btree_node_iter_peek_overlapping(struct btree_node_iter *iter,
+				     struct btree_keys *b,
 				     struct bkey *end)
 {
-	const struct bkey_format *f = &iter->b->set->data->format;
+	const struct bkey_format *f = &b->set->data->format;
 	struct bkey_packed *ret;
 	struct bkey u;
 
 	while ((ret = bch_btree_node_iter_peek_all(iter)) &&
 	       (bkey_cmp_left_packed(f, ret, bkey_start_pos(end)) <= 0))
-		bch_btree_node_iter_next_all(iter);
+		bch_btree_node_iter_next_all(iter, b);
 
 	if (!ret)
 		return false;
@@ -499,20 +498,20 @@ bch_btree_node_iter_peek_overlapping(struct btree_node_iter *iter,
  * overlapping) keys
  */
 #define for_each_btree_node_key(b, k, iter)				\
-	for (bch_btree_node_iter_init_from_start((b), (iter));		\
-	     ((k) = bch_btree_node_iter_next(iter));)
+	for (bch_btree_node_iter_init_from_start((iter), (b));		\
+	     ((k) = bch_btree_node_iter_next(iter, b));)
 
 #define for_each_btree_node_key_all(b, k, iter)				\
-	for (bch_btree_node_iter_init_from_start((b), (iter));		\
-	     ((k) = bch_btree_node_iter_next_all(iter));)
+	for (bch_btree_node_iter_init_from_start((iter), (b));		\
+	     ((k) = bch_btree_node_iter_next_all(iter, b));)
 
-bool bch_btree_node_iter_next_unpack(struct btree_keys *,
-				     struct btree_node_iter *,
+bool bch_btree_node_iter_next_unpack(struct btree_node_iter *,
+				     struct btree_keys *,
 				     struct bkey_tup *);
 
 #define for_each_btree_node_key_unpack(b, tup, iter)			\
-	for (bch_btree_node_iter_init_from_start((b), (iter));		\
-	     bch_btree_node_iter_next_unpack(b, iter, tup);)
+	for (bch_btree_node_iter_init_from_start((iter), (b));		\
+	     bch_btree_node_iter_next_unpack((iter), (b), (tup));)
 
 /* Sorting */
 
@@ -563,7 +562,7 @@ void bch_btree_keys_stats(struct btree_keys *, struct bset_stats *);
 s64 __bch_count_data(struct btree_keys *);
 void __bch_count_data_verify(struct btree_keys *, int);
 void bch_dump_bucket(struct btree_keys *);
-void bch_btree_node_iter_verify(struct btree_keys *, struct btree_node_iter *);
+void bch_btree_node_iter_verify(struct btree_node_iter *, struct btree_keys *);
 void bch_verify_nr_live_u64s(struct btree_keys *);
 
 #else
@@ -571,8 +570,8 @@ void bch_verify_nr_live_u64s(struct btree_keys *);
 static inline s64 __bch_count_data(struct btree_keys *b) { return -1; }
 static inline void __bch_count_data_verify(struct btree_keys *b, int oldsize ) {}
 static inline void bch_dump_bucket(struct btree_keys *b) {}
-static inline void bch_btree_node_iter_verify(struct btree_keys *b,
-					 struct btree_node_iter *iter) {}
+static inline void bch_btree_node_iter_verify(struct btree_node_iter *iter,
+					      struct btree_keys *b) {}
 static inline void bch_verify_nr_live_u64s(struct btree_keys *b) {}
 
 #endif
diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
index 56c15c382343..a8bed330dd77 100644
--- a/drivers/md/bcache/btree.c
+++ b/drivers/md/bcache/btree.c
@@ -254,10 +254,8 @@ void bch_btree_node_read_done(struct btree *b, struct cache *ca,
 	struct bkey_packed *k;
 
 	iter = mempool_alloc(b->c->fill_iter, GFP_NOIO);
-	iter->size = btree_blocks(c);
 	iter->used = 0;
 	iter->is_extents = b->keys.ops->is_extents;
-	iter->b = &b->keys;
 
 	err = "dynamic fault";
 	if (bch_meta_read_fault("btree"))
@@ -341,7 +339,8 @@ void bch_btree_node_read_done(struct btree *b, struct cache *ca,
 			k = bkey_next(k);
 		}
 
-		bch_btree_node_iter_push(iter, i->start, bset_bkey_last(i));
+		bch_btree_node_iter_push(iter, &b->keys,
+					 i->start, bset_bkey_last(i));
 	}
 
 	err = "corrupted btree";
@@ -1675,7 +1674,7 @@ static bool btree_insert_key(struct btree_iter *iter, struct btree *b,
 	BUG_ON(write_block(b) != btree_bset_last(b));
 	BUG_ON(!b->level &&
 	       bkey_cmp(bkey_start_pos(&insert->k), iter->pos) < 0);
-	bch_btree_node_iter_verify(&b->keys, node_iter);
+	bch_btree_node_iter_verify(node_iter, &b->keys);
 
 	if (b->keys.ops->is_extents) {
 		bkey_copy(&temp.key, insert);
@@ -2250,9 +2249,8 @@ int bch_btree_insert_check_key(struct btree_iter *iter,
 
 	bkey_copy(&tmp.key, check_key);
 
-	bch_btree_node_iter_init(&iter->nodes[0]->keys,
-				 &iter->node_iters[0],
-				 bkey_start_pos(&check_key->k));
+	__btree_iter_node_set(iter, iter->nodes[0],
+			      bkey_start_pos(&check_key->k));
 
 	return bch_btree_insert_at(iter, &keylist_single(&tmp.key), NULL,
 				   NULL, iter->btree_id, BTREE_INSERT_ATOMIC);
@@ -2327,7 +2325,8 @@ static inline struct bkey_s_c __btree_iter_peek(struct btree_iter *iter)
 	const struct bkey_format *f =
 		&iter->nodes[iter->level]->keys.set->data->format;
 	struct bkey_packed *k =
-		bch_btree_node_iter_peek(&iter->node_iters[iter->level]);
+		bch_btree_node_iter_peek(&iter->node_iters[iter->level],
+					 &iter->nodes[iter->level]->keys);
 	struct bkey_s_c ret;
 
 	if (!k)
@@ -2344,7 +2343,8 @@ static inline struct bkey_s_c __btree_iter_peek(struct btree_iter *iter)
 
 static inline void __btree_iter_next_all(struct btree_iter *iter)
 {
-	bch_btree_node_iter_next_all(&iter->node_iters[iter->level]);
+	bch_btree_node_iter_next_all(&iter->node_iters[iter->level],
+				     &iter->nodes[iter->level]->keys);
 }
 
 static bool btree_iter_cmp(struct btree_iter *iter,
diff --git a/drivers/md/bcache/btree.h b/drivers/md/bcache/btree.h
index c321dae08817..4ba91553c016 100644
--- a/drivers/md/bcache/btree.h
+++ b/drivers/md/bcache/btree.h
@@ -292,9 +292,8 @@ static inline void __btree_iter_node_set(struct btree_iter *iter,
 
 	iter->lock_seq[b->level] = b->lock.state.seq;
 	iter->nodes[b->level] = b;
-	bch_btree_node_iter_init(&b->keys,
-				 &iter->node_iters[b->level],
-				 search);
+	bch_btree_node_iter_init(&iter->node_iters[b->level],
+				 &b->keys, search);
 }
 
 static inline void btree_iter_node_set(struct btree_iter *iter, struct btree *b)
diff --git a/drivers/md/bcache/extents.c b/drivers/md/bcache/extents.c
index 2a6dacdee775..c2f6c3c5953b 100644
--- a/drivers/md/bcache/extents.c
+++ b/drivers/md/bcache/extents.c
@@ -43,15 +43,15 @@ static void sort_key_next(struct btree_node_iter *iter,
  */
 #define key_sort_cmp(l, r)						\
 ({									\
-	int _c = bkey_cmp_packed(&iter->b->set->data->format,		\
-				 (l).k, (r).k);				\
+	int _c = bkey_cmp_packed(&b->set->data->format,	(l).k, (r).k);	\
 									\
 	_c ? _c > 0 : (l).k > (r).k;					\
 })
 
-static inline bool should_drop_next_key(struct btree_node_iter *iter)
+static inline bool should_drop_next_key(struct btree_node_iter *iter,
+					struct btree_keys *b)
 {
-	const struct bkey_format *f = &iter->b->set->data->format;
+	const struct bkey_format *f = &b->set->data->format;
 	struct btree_node_iter_set *l = iter->data, *r = iter->data + 1;
 
 	if (bkey_deleted(l->k))
@@ -81,7 +81,7 @@ void bch_key_sort_fix_overlapping(struct btree_keys *b,
 	heap_resort(iter, key_sort_cmp);
 
 	while (!bch_btree_node_iter_end(iter)) {
-		if (!should_drop_next_key(iter)) {
+		if (!should_drop_next_key(iter, b)) {
 			/* XXX: need better bkey_copy */
 			memcpy(out, iter->data->k,
 			       bkey_bytes(iter->data->k));
@@ -118,7 +118,7 @@ bool bch_insert_fixup_key(struct btree *b, struct bkey_i *insert,
 			b->keys.nr_live_u64s -= k->u64s;
 		}
 
-		bch_btree_node_iter_next_all(iter);
+		bch_btree_node_iter_next_all(iter, &b->keys);
 	}
 
 	bch_btree_insert_and_journal(b, iter, insert, res);
@@ -607,7 +607,7 @@ static void extent_save(struct bkey_packed *dst, struct bkey *src,
  */
 #define extent_sort_cmp(l, r)						\
 ({									\
-	const struct bkey_format *_f = &iter->b->set->data->format;	\
+	const struct bkey_format *_f = &b->set->data->format;		\
 	struct bkey _ul = bkey_unpack_key(_f, (l).k);			\
 	struct bkey _ur = bkey_unpack_key(_f, (r).k);			\
 									\
@@ -615,12 +615,14 @@ static void extent_save(struct bkey_packed *dst, struct bkey *src,
 	_c ? _c > 0 : (l).k < (r).k;					\
 })
 
-static inline void extent_sort_sift(struct btree_node_iter *iter, size_t i)
+static inline void extent_sort_sift(struct btree_node_iter *iter,
+				    struct btree_keys *b, size_t i)
 {
 	heap_sift(iter, i, extent_sort_cmp);
 }
 
 static inline void extent_sort_next(struct btree_node_iter *iter,
+				    struct btree_keys *b,
 				    struct btree_node_iter_set *i)
 {
 	sort_key_next(iter, i);
@@ -666,7 +668,7 @@ void bch_extent_sort_fix_overlapping(struct btree_keys *b,
 	while (!bch_btree_node_iter_end(iter)) {
 		if (iter->used == 1) {
 			out = extent_sort_append(b, out, &prev, _l->k);
-			extent_sort_next(iter, _l);
+			extent_sort_next(iter, b, _l);
 			continue;
 		}
 
@@ -681,13 +683,13 @@ void bch_extent_sort_fix_overlapping(struct btree_keys *b,
 		/* If current key and next key don't overlap, just append */
 		if (bkey_cmp(l.k.p, bkey_start_pos(&r.k)) <= 0) {
 			out = extent_sort_append(b, out, &prev, _l->k);
-			extent_sort_next(iter, _l);
+			extent_sort_next(iter, b, _l);
 			continue;
 		}
 
 		/* Skip 0 size keys */
 		if (!r.k.size) {
-			extent_sort_next(iter, _r);
+			extent_sort_next(iter, b, _r);
 			continue;
 		}
 
@@ -710,7 +712,7 @@ void bch_extent_sort_fix_overlapping(struct btree_keys *b,
 				extent_save(_r->k, &r.k, f);
 			}
 
-			extent_sort_sift(iter, _r - iter->data);
+			extent_sort_sift(iter, b, _r - iter->data);
 		} else if (bkey_cmp(l.k.p, r.k.p) > 0) {
 			BKEY_PADDED(k) tmp;
 
@@ -723,7 +725,7 @@ void bch_extent_sort_fix_overlapping(struct btree_keys *b,
 			__bch_cut_front(r.k.p, bkey_tup_to_s(&l));
 			extent_save(_l->k, &l.k, f);
 
-			extent_sort_sift(iter, 0);
+			extent_sort_sift(iter, b, 0);
 
 			out = extent_sort_append(b, out, &prev,
 						 bkey_to_packed(&tmp.k));
@@ -1191,7 +1193,8 @@ bool bch_insert_fixup_extent(struct btree *b, struct bkey_i *insert,
 	}
 
 	while (insert->k.size &&
-	       (_k = bch_btree_node_iter_peek_overlapping(iter, &insert->k))) {
+	       (_k = bch_btree_node_iter_peek_overlapping(iter, &b->keys,
+							  &insert->k))) {
 		bool needs_split, res_full;
 
 		bkey_disassemble(&tup, f, _k);
@@ -1262,7 +1265,7 @@ bool bch_insert_fixup_extent(struct btree *b, struct bkey_i *insert,
 			 * auxiliary tree.
 			 */
 			bch_bset_fix_invalidated_key(&b->keys, _k);
-			bch_btree_node_iter_advance(iter);
+			bch_btree_node_iter_advance(iter, &b->keys);
 			break;
 
 		case BCH_EXTENT_OVERLAP_ALL:
@@ -1275,7 +1278,7 @@ bool bch_insert_fixup_extent(struct btree *b, struct bkey_i *insert,
 			extent_save(_k, k.k, f);
 
 			bch_bset_fix_invalidated_key(&b->keys, _k);
-			bch_btree_node_iter_advance(iter);
+			bch_btree_node_iter_advance(iter, &b->keys);
 			break;
 
 		case BCH_EXTENT_OVERLAP_MIDDLE:
@@ -1812,7 +1815,7 @@ static bool bch_extent_merge_inline(struct btree_keys *b,
 		}
 	}
 
-	bch_btree_node_iter_sort(iter);
+	bch_btree_node_iter_sort(iter, b);
 	return true;
 }