git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/btree_update_leaf.c

   1
   2 #include "bcachefs.h"
   3 #include "btree_update.h"
   4 #include "btree_update_interior.h"
   5 #include "btree_io.h"
   6 #include "btree_iter.h"
   7 #include "btree_locking.h"
   8 #include "debug.h"
   9 #include "extents.h"
  10 #include "journal.h"
  11 #include "journal_reclaim.h"
  12 #include "keylist.h"
  13
  14 #include <linux/sort.h>
  15 #include <trace/events/bcachefs.h>
  16
  17 /* Inserting into a given leaf node (last stage of insert): */
  18
  19 /* Handle overwrites and do insert, for non extents: */
  20 bool bch2_btree_bset_insert_key(struct btree_iter *iter,
  21                                 struct btree *b,
  22                                 struct btree_node_iter *node_iter,
  23                                 struct bkey_i *insert)
  24 {
  25         const struct bkey_format *f = &b->format;
  26         struct bkey_packed *k;
  27         struct bset_tree *t;
  28         unsigned clobber_u64s;
  29
  30         EBUG_ON(btree_node_just_written(b));
  31         EBUG_ON(bset_written(b, btree_bset_last(b)));
  32         EBUG_ON(bkey_deleted(&insert->k) && bkey_val_u64s(&insert->k));
  33         EBUG_ON(bkey_cmp(bkey_start_pos(&insert->k), b->data->min_key) < 0 ||
  34                 bkey_cmp(insert->k.p, b->data->max_key) > 0);
  35
  36         k = bch2_btree_node_iter_peek_all(node_iter, b);
  37         if (k && !bkey_cmp_packed(b, k, &insert->k)) {
  38                 BUG_ON(bkey_whiteout(k));
  39
  40                 t = bch2_bkey_to_bset(b, k);
  41
  42                 if (bset_unwritten(b, bset(b, t)) &&
  43                     bkey_val_u64s(&insert->k) == bkeyp_val_u64s(f, k) &&
  44                     !bkey_whiteout(&insert->k)) {
  45                         k->type = insert->k.type;
  46                         memcpy_u64s(bkeyp_val(f, k), &insert->v,
  47                                     bkey_val_u64s(&insert->k));
  48                         return true;
  49                 }
  50
  51                 insert->k.needs_whiteout = k->needs_whiteout;
  52
  53                 btree_keys_account_key_drop(&b->nr, t - b->set, k);
  54
  55                 if (t == bset_tree_last(b)) {
  56                         clobber_u64s = k->u64s;
  57
  58                         /*
  59                          * If we're deleting, and the key we're deleting doesn't
  60                          * need a whiteout (it wasn't overwriting a key that had
  61                          * been written to disk) - just delete it:
  62                          */
  63                         if (bkey_whiteout(&insert->k) && !k->needs_whiteout) {
  64                                 bch2_bset_delete(b, k, clobber_u64s);
  65                                 bch2_btree_node_iter_fix(iter, b, node_iter, t,
  66                                                         k, clobber_u64s, 0);
  67                                 return true;
  68                         }
  69
  70                         goto overwrite;
  71                 }
  72
  73                 k->type = KEY_TYPE_DELETED;
  74                 bch2_btree_node_iter_fix(iter, b, node_iter, t, k,
  75                                         k->u64s, k->u64s);
  76
  77                 if (bkey_whiteout(&insert->k)) {
  78                         reserve_whiteout(b, t, k);
  79                         return true;
  80                 } else {
  81                         k->needs_whiteout = false;
  82                 }
  83         } else {
  84                 /*
  85                  * Deleting, but the key to delete wasn't found - nothing to do:
  86                  */
  87                 if (bkey_whiteout(&insert->k))
  88                         return false;
  89
  90                 insert->k.needs_whiteout = false;
  91         }
  92
  93         t = bset_tree_last(b);
  94         k = bch2_btree_node_iter_bset_pos(node_iter, b, t);
  95         clobber_u64s = 0;
  96 overwrite:
  97         bch2_bset_insert(b, node_iter, k, insert, clobber_u64s);
  98         if (k->u64s != clobber_u64s || bkey_whiteout(&insert->k))
  99                 bch2_btree_node_iter_fix(iter, b, node_iter, t, k,
 100                                         clobber_u64s, k->u64s);
 101         return true;
 102 }
 103
 104 static void __btree_node_flush(struct journal *j, struct journal_entry_pin *pin,
 105                                unsigned i, u64 seq)
 106 {
 107         struct bch_fs *c = container_of(j, struct bch_fs, journal);
 108         struct btree_write *w = container_of(pin, struct btree_write, journal);
 109         struct btree *b = container_of(w, struct btree, writes[i]);
 110
 111         btree_node_lock_type(c, b, SIX_LOCK_read);
 112         bch2_btree_node_write_cond(c, b,
 113                         (btree_current_write(b) == w &&
 114                          w->journal.pin_list == journal_seq_pin(j, seq)));
 115         six_unlock_read(&b->lock);
 116 }
 117
 118 static void btree_node_flush0(struct journal *j, struct journal_entry_pin *pin, u64 seq)
 119 {
 120         return __btree_node_flush(j, pin, 0, seq);
 121 }
 122
 123 static void btree_node_flush1(struct journal *j, struct journal_entry_pin *pin, u64 seq)
 124 {
 125         return __btree_node_flush(j, pin, 1, seq);
 126 }
 127
 128 void bch2_btree_journal_key(struct btree_insert *trans,
 129                            struct btree_iter *iter,
 130                            struct bkey_i *insert)
 131 {
 132         struct bch_fs *c = trans->c;
 133         struct journal *j = &c->journal;
 134         struct btree *b = iter->l[0].b;
 135         struct btree_write *w = btree_current_write(b);
 136
 137         EBUG_ON(iter->level || b->level);
 138         EBUG_ON(trans->journal_res.ref !=
 139                 !(trans->flags & BTREE_INSERT_JOURNAL_REPLAY));
 140
 141         if (likely(!(trans->flags & BTREE_INSERT_JOURNAL_REPLAY))) {
 142                 u64 seq = trans->journal_res.seq;
 143                 bool needs_whiteout = insert->k.needs_whiteout;
 144
 145                 /* ick */
 146                 insert->k.needs_whiteout = false;
 147                 bch2_journal_add_keys(j, &trans->journal_res,
 148                                       iter->btree_id, insert);
 149                 insert->k.needs_whiteout = needs_whiteout;
 150
 151                 bch2_journal_set_has_inode(j, &trans->journal_res,
 152                                            insert->k.p.inode);
 153
 154                 if (trans->journal_seq)
 155                         *trans->journal_seq = seq;
 156                 btree_bset_last(b)->journal_seq = cpu_to_le64(seq);
 157         }
 158
 159         if (unlikely(!journal_pin_active(&w->journal))) {
 160                 u64 seq = likely(!(trans->flags & BTREE_INSERT_JOURNAL_REPLAY))
 161                         ? trans->journal_res.seq
 162                         : j->replay_journal_seq;
 163
 164                 bch2_journal_pin_add(j, seq, &w->journal,
 165                                      btree_node_write_idx(b) == 0
 166                                      ? btree_node_flush0
 167                                      : btree_node_flush1);
 168         }
 169
 170         if (unlikely(!btree_node_dirty(b)))
 171                 set_btree_node_dirty(b);
 172 }
 173
 174 static enum btree_insert_ret
 175 bch2_insert_fixup_key(struct btree_insert *trans,
 176                      struct btree_insert_entry *insert)
 177 {
 178         struct btree_iter *iter = insert->iter;
 179         struct btree_iter_level *l = &iter->l[0];
 180
 181         EBUG_ON(iter->level);
 182         EBUG_ON(insert->k->k.u64s >
 183                 bch_btree_keys_u64s_remaining(trans->c, l->b));
 184
 185         if (bch2_btree_bset_insert_key(iter, l->b, &l->iter,
 186                                        insert->k))
 187                 bch2_btree_journal_key(trans, iter, insert->k);
 188
 189         trans->did_work = true;
 190         return BTREE_INSERT_OK;
 191 }
 192
 193 /**
 194  * btree_insert_key - insert a key one key into a leaf node
 195  */
 196 static enum btree_insert_ret
 197 btree_insert_key_leaf(struct btree_insert *trans,
 198                       struct btree_insert_entry *insert)
 199 {
 200         struct bch_fs *c = trans->c;
 201         struct btree_iter *iter = insert->iter;
 202         struct btree *b = iter->l[0].b;
 203         enum btree_insert_ret ret;
 204         int old_u64s = le16_to_cpu(btree_bset_last(b)->u64s);
 205         int old_live_u64s = b->nr.live_u64s;
 206         int live_u64s_added, u64s_added;
 207
 208         btree_iter_set_dirty(iter, BTREE_ITER_NEED_PEEK);
 209
 210         ret = !btree_node_is_extents(b)
 211                 ? bch2_insert_fixup_key(trans, insert)
 212                 : bch2_insert_fixup_extent(trans, insert);
 213
 214         live_u64s_added = (int) b->nr.live_u64s - old_live_u64s;
 215         u64s_added = (int) le16_to_cpu(btree_bset_last(b)->u64s) - old_u64s;
 216
 217         if (b->sib_u64s[0] != U16_MAX && live_u64s_added < 0)
 218                 b->sib_u64s[0] = max(0, (int) b->sib_u64s[0] + live_u64s_added);
 219         if (b->sib_u64s[1] != U16_MAX && live_u64s_added < 0)
 220                 b->sib_u64s[1] = max(0, (int) b->sib_u64s[1] + live_u64s_added);
 221
 222         if (u64s_added > live_u64s_added &&
 223             bch2_maybe_compact_whiteouts(c, b))
 224                 bch2_btree_iter_reinit_node(iter, b);
 225
 226         trace_btree_insert_key(c, b, insert->k);
 227         return ret;
 228 }
 229
 230 #define trans_for_each_entry(trans, i)                                  \
 231         for ((i) = (trans)->entries; (i) < (trans)->entries + (trans)->nr; (i)++)
 232
 233 /*
 234  * We sort transaction entries so that if multiple iterators point to the same
 235  * leaf node they'll be adjacent:
 236  */
 237 static bool same_leaf_as_prev(struct btree_insert *trans,
 238                               struct btree_insert_entry *i)
 239 {
 240         return i != trans->entries &&
 241                 i[0].iter->l[0].b == i[-1].iter->l[0].b;
 242 }
 243
 244 static inline struct btree_insert_entry *trans_next_leaf(struct btree_insert *trans,
 245                                                          struct btree_insert_entry *i)
 246 {
 247         struct btree *b = i->iter->l[0].b;
 248
 249         do {
 250                 i++;
 251         } while (i < trans->entries + trans->nr && b == i->iter->l[0].b);
 252
 253         return i;
 254 }
 255
 256 #define trans_for_each_leaf(trans, i)                                   \
 257         for ((i) = (trans)->entries;                                    \
 258              (i) < (trans)->entries + (trans)->nr;                      \
 259              (i) = trans_next_leaf(trans, i))
 260
 261 inline void bch2_btree_node_lock_for_insert(struct bch_fs *c, struct btree *b,
 262                                             struct btree_iter *iter)
 263 {
 264         bch2_btree_node_lock_write(b, iter);
 265
 266         if (btree_node_just_written(b) &&
 267             bch2_btree_post_write_cleanup(c, b))
 268                 bch2_btree_iter_reinit_node(iter, b);
 269
 270         /*
 271          * If the last bset has been written, or if it's gotten too big - start
 272          * a new bset to insert into:
 273          */
 274         if (want_new_bset(c, b))
 275                 bch2_btree_init_next(c, b, iter);
 276 }
 277
 278 static void multi_lock_write(struct bch_fs *c, struct btree_insert *trans)
 279 {
 280         struct btree_insert_entry *i;
 281
 282         trans_for_each_leaf(trans, i)
 283                 bch2_btree_node_lock_for_insert(c, i->iter->l[0].b, i->iter);
 284 }
 285
 286 static void multi_unlock_write(struct btree_insert *trans)
 287 {
 288         struct btree_insert_entry *i;
 289
 290         trans_for_each_leaf(trans, i)
 291                 bch2_btree_node_unlock_write(i->iter->l[0].b, i->iter);
 292 }
 293
 294 static inline int btree_trans_cmp(struct btree_insert_entry l,
 295                                   struct btree_insert_entry r)
 296 {
 297         return btree_iter_cmp(l.iter, r.iter);
 298 }
 299
 300 /* Normal update interface: */
 301
 302 /*
 303  * Get journal reservation, take write locks, and attempt to do btree update(s):
 304  */
 305 static inline int do_btree_insert_at(struct btree_insert *trans,
 306                                      struct btree_iter **split,
 307                                      bool *cycle_gc_lock)
 308 {
 309         struct bch_fs *c = trans->c;
 310         struct btree_insert_entry *i;
 311         unsigned u64s;
 312         int ret;
 313
 314         trans_for_each_entry(trans, i)
 315                 BUG_ON(i->done);
 316
 317         u64s = 0;
 318         trans_for_each_entry(trans, i)
 319                 u64s += jset_u64s(i->k->k.u64s + i->extra_res);
 320
 321         memset(&trans->journal_res, 0, sizeof(trans->journal_res));
 322
 323         ret = !(trans->flags & BTREE_INSERT_JOURNAL_REPLAY)
 324                 ? bch2_journal_res_get(&c->journal,
 325                                       &trans->journal_res,
 326                                       u64s, u64s)
 327                 : 0;
 328         if (ret)
 329                 return ret;
 330
 331         multi_lock_write(c, trans);
 332
 333         if (race_fault()) {
 334                 ret = -EINTR;
 335                 goto out;
 336         }
 337
 338         u64s = 0;
 339         trans_for_each_entry(trans, i) {
 340                 /* Multiple inserts might go to same leaf: */
 341                 if (!same_leaf_as_prev(trans, i))
 342                         u64s = 0;
 343
 344                 /*
 345                  * bch2_btree_node_insert_fits() must be called under write lock:
 346                  * with only an intent lock, another thread can still call
 347                  * bch2_btree_node_write(), converting an unwritten bset to a
 348                  * written one
 349                  */
 350                 u64s += i->k->k.u64s + i->extra_res;
 351                 if (!bch2_btree_node_insert_fits(c,
 352                                 i->iter->l[0].b, u64s)) {
 353                         ret = -EINTR;
 354                         *split = i->iter;
 355                         goto out;
 356                 }
 357         }
 358
 359         if (journal_seq_verify(c) &&
 360             !(trans->flags & BTREE_INSERT_JOURNAL_REPLAY))
 361                 trans_for_each_entry(trans, i)
 362                         i->k->k.version.lo = trans->journal_res.seq;
 363
 364         trans_for_each_entry(trans, i) {
 365                 switch (btree_insert_key_leaf(trans, i)) {
 366                 case BTREE_INSERT_OK:
 367                         i->done = true;
 368                         break;
 369                 case BTREE_INSERT_JOURNAL_RES_FULL:
 370                 case BTREE_INSERT_NEED_TRAVERSE:
 371                 case BTREE_INSERT_NEED_RESCHED:
 372                         ret = -EINTR;
 373                         break;
 374                 case BTREE_INSERT_BTREE_NODE_FULL:
 375                         ret = -EINTR;
 376                         *split = i->iter;
 377                         break;
 378                 case BTREE_INSERT_ENOSPC:
 379                         ret = -ENOSPC;
 380                         break;
 381                 case BTREE_INSERT_NEED_GC_LOCK:
 382                         ret = -EINTR;
 383                         *cycle_gc_lock = true;
 384                         break;
 385                 default:
 386                         BUG();
 387                 }
 388
 389                 /*
 390                  * If we did some work (i.e. inserted part of an extent),
 391                  * we have to do all the other updates as well:
 392                  */
 393                 if (!trans->did_work && (ret || *split))
 394                         break;
 395         }
 396 out:
 397         multi_unlock_write(trans);
 398         bch2_journal_res_put(&c->journal, &trans->journal_res);
 399
 400         return ret;
 401 }
 402
 403 /**
 404  * __bch_btree_insert_at - insert keys at given iterator positions
 405  *
 406  * This is main entry point for btree updates.
 407  *
 408  * Return values:
 409  * -EINTR: locking changed, this function should be called again. Only returned
 410  *  if passed BTREE_INSERT_ATOMIC.
 411  * -EROFS: filesystem read only
 412  * -EIO: journal or btree node IO error
 413  */
 414 int __bch2_btree_insert_at(struct btree_insert *trans)
 415 {
 416         struct bch_fs *c = trans->c;
 417         struct btree_insert_entry *i;
 418         struct btree_iter *linked, *split = NULL;
 419         bool cycle_gc_lock = false;
 420         unsigned flags;
 421         int ret;
 422
 423         for_each_btree_iter(trans->entries[0].iter, linked)
 424                 bch2_btree_iter_verify_locks(linked);
 425
 426         /* for the sake of sanity: */
 427         BUG_ON(trans->nr > 1 && !(trans->flags & BTREE_INSERT_ATOMIC));
 428
 429         trans_for_each_entry(trans, i) {
 430                 BUG_ON(i->iter->level);
 431                 BUG_ON(bkey_cmp(bkey_start_pos(&i->k->k), i->iter->pos));
 432                 BUG_ON(debug_check_bkeys(c) &&
 433                        bch2_bkey_invalid(c, i->iter->btree_id,
 434                                          bkey_i_to_s_c(i->k)));
 435                 BUG_ON(i->iter->uptodate == BTREE_ITER_END);
 436         }
 437
 438         bubble_sort(trans->entries, trans->nr, btree_trans_cmp);
 439
 440         if (unlikely(!percpu_ref_tryget(&c->writes)))
 441                 return -EROFS;
 442 retry:
 443         split = NULL;
 444         cycle_gc_lock = false;
 445
 446         trans_for_each_entry(trans, i) {
 447                 if (!bch2_btree_iter_upgrade(i->iter, 1)) {
 448                         ret = -EINTR;
 449                         goto err;
 450                 }
 451
 452                 if (i->iter->flags & BTREE_ITER_ERROR) {
 453                         ret = -EIO;
 454                         goto err;
 455                 }
 456         }
 457
 458         ret = do_btree_insert_at(trans, &split, &cycle_gc_lock);
 459         if (unlikely(ret))
 460                 goto err;
 461
 462         trans_for_each_leaf(trans, i)
 463                 bch2_foreground_maybe_merge(c, i->iter, 0, trans->flags);
 464
 465         trans_for_each_entry(trans, i)
 466                 bch2_btree_iter_downgrade(i->iter);
 467 out:
 468         percpu_ref_put(&c->writes);
 469
 470         if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG)) {
 471                 /* make sure we didn't drop or screw up locks: */
 472                 for_each_btree_iter(trans->entries[0].iter, linked) {
 473                         bch2_btree_iter_verify_locks(linked);
 474                         BUG_ON((trans->flags & BTREE_INSERT_NOUNLOCK) &&
 475                                trans->did_work &&
 476                                linked->uptodate >= BTREE_ITER_NEED_RELOCK);
 477                 }
 478
 479                 /* make sure we didn't lose an error: */
 480                 if (!ret)
 481                         trans_for_each_entry(trans, i)
 482                                 BUG_ON(!i->done);
 483         }
 484
 485         BUG_ON(!(trans->flags & BTREE_INSERT_ATOMIC) && ret == -EINTR);
 486
 487         return ret;
 488 err:
 489         flags = trans->flags;
 490
 491         /*
 492          * BTREE_INSERT_NOUNLOCK means don't unlock _after_ successful btree
 493          * update; if we haven't done anything yet it doesn't apply
 494          */
 495         if (!trans->did_work)
 496                 flags &= ~BTREE_INSERT_NOUNLOCK;
 497
 498         if (split) {
 499                 ret = bch2_btree_split_leaf(c, split, flags);
 500
 501                 /*
 502                  * if the split succeeded without dropping locks the insert will
 503                  * still be atomic (in the BTREE_INSERT_ATOMIC sense, what the
 504                  * caller peeked() and is overwriting won't have changed)
 505                  */
 506 #if 0
 507                 /*
 508                  * XXX:
 509                  * split -> btree node merging (of parent node) might still drop
 510                  * locks when we're not passing it BTREE_INSERT_NOUNLOCK
 511                  */
 512                 if (!ret && !trans->did_work)
 513                         goto retry;
 514 #endif
 515
 516                 /*
 517                  * don't care if we got ENOSPC because we told split it
 518                  * couldn't block:
 519                  */
 520                 if (!ret || (flags & BTREE_INSERT_NOUNLOCK))
 521                         ret = -EINTR;
 522         }
 523
 524         if (cycle_gc_lock) {
 525                 if (!down_read_trylock(&c->gc_lock)) {
 526                         if (flags & BTREE_INSERT_NOUNLOCK)
 527                                 goto out;
 528
 529                         bch2_btree_iter_unlock(trans->entries[0].iter);
 530                         down_read(&c->gc_lock);
 531                 }
 532                 up_read(&c->gc_lock);
 533         }
 534
 535         if (ret == -EINTR) {
 536                 if (flags & BTREE_INSERT_NOUNLOCK)
 537                         goto out;
 538
 539                 trans_for_each_entry(trans, i) {
 540                         int ret2 = bch2_btree_iter_traverse(i->iter);
 541                         if (ret2) {
 542                                 ret = ret2;
 543                                 goto out;
 544                         }
 545
 546                         BUG_ON(i->iter->uptodate > BTREE_ITER_NEED_PEEK);
 547                 }
 548
 549                 /*
 550                  * BTREE_ITER_ATOMIC means we have to return -EINTR if we
 551                  * dropped locks:
 552                  */
 553                 if (!(flags & BTREE_INSERT_ATOMIC))
 554                         goto retry;
 555         }
 556
 557         goto out;
 558 }
 559
 560 int bch2_btree_delete_at(struct btree_iter *iter, unsigned flags)
 561 {
 562         struct bkey_i k;
 563
 564         bkey_init(&k.k);
 565         k.k.p = iter->pos;
 566
 567         return bch2_btree_insert_at(iter->c, NULL, NULL, NULL,
 568                                     BTREE_INSERT_NOFAIL|
 569                                     BTREE_INSERT_USE_RESERVE|flags,
 570                                     BTREE_INSERT_ENTRY(iter, &k));
 571 }
 572
 573 int bch2_btree_insert_list_at(struct btree_iter *iter,
 574                              struct keylist *keys,
 575                              struct disk_reservation *disk_res,
 576                              struct extent_insert_hook *hook,
 577                              u64 *journal_seq, unsigned flags)
 578 {
 579         BUG_ON(flags & BTREE_INSERT_ATOMIC);
 580         BUG_ON(bch2_keylist_empty(keys));
 581         bch2_verify_keylist_sorted(keys);
 582
 583         while (!bch2_keylist_empty(keys)) {
 584                 int ret = bch2_btree_insert_at(iter->c, disk_res, hook,
 585                                 journal_seq, flags,
 586                                 BTREE_INSERT_ENTRY(iter, bch2_keylist_front(keys)));
 587                 if (ret)
 588                         return ret;
 589
 590                 bch2_keylist_pop_front(keys);
 591         }
 592
 593         return 0;
 594 }
 595
 596 /**
 597  * bch_btree_insert - insert keys into the extent btree
 598  * @c:                  pointer to struct bch_fs
 599  * @id:                 btree to insert into
 600  * @insert_keys:        list of keys to insert
 601  * @hook:               insert callback
 602  */
 603 int bch2_btree_insert(struct bch_fs *c, enum btree_id id,
 604                      struct bkey_i *k,
 605                      struct disk_reservation *disk_res,
 606                      struct extent_insert_hook *hook,
 607                      u64 *journal_seq, int flags)
 608 {
 609         struct btree_iter iter;
 610         int ret;
 611
 612         bch2_btree_iter_init(&iter, c, id, bkey_start_pos(&k->k),
 613                              BTREE_ITER_INTENT);
 614         ret = bch2_btree_insert_at(c, disk_res, hook, journal_seq, flags,
 615                                    BTREE_INSERT_ENTRY(&iter, k));
 616         bch2_btree_iter_unlock(&iter);
 617
 618         return ret;
 619 }
 620
 621 /*
 622  * bch_btree_delete_range - delete everything within a given range
 623  *
 624  * Range is a half open interval - [start, end)
 625  */
 626 int bch2_btree_delete_range(struct bch_fs *c, enum btree_id id,
 627                            struct bpos start,
 628                            struct bpos end,
 629                            struct bversion version,
 630                            struct disk_reservation *disk_res,
 631                            struct extent_insert_hook *hook,
 632                            u64 *journal_seq)
 633 {
 634         struct btree_iter iter;
 635         struct bkey_s_c k;
 636         int ret = 0;
 637
 638         bch2_btree_iter_init(&iter, c, id, start,
 639                              BTREE_ITER_INTENT);
 640
 641         while ((k = bch2_btree_iter_peek(&iter)).k &&
 642                !(ret = btree_iter_err(k))) {
 643                 unsigned max_sectors = KEY_SIZE_MAX & (~0 << c->block_bits);
 644                 /* really shouldn't be using a bare, unpadded bkey_i */
 645                 struct bkey_i delete;
 646
 647                 if (bkey_cmp(iter.pos, end) >= 0)
 648                         break;
 649
 650                 if (k.k->type == KEY_TYPE_DISCARD) {
 651                         bch2_btree_iter_next(&iter);
 652                         continue;
 653                 }
 654
 655                 bkey_init(&delete.k);
 656
 657                 /*
 658                  * For extents, iter.pos won't necessarily be the same as
 659                  * bkey_start_pos(k.k) (for non extents they always will be the
 660                  * same). It's important that we delete starting from iter.pos
 661                  * because the range we want to delete could start in the middle
 662                  * of k.
 663                  *
 664                  * (bch2_btree_iter_peek() does guarantee that iter.pos >=
 665                  * bkey_start_pos(k.k)).
 666                  */
 667                 delete.k.p = iter.pos;
 668                 delete.k.version = version;
 669
 670                 if (iter.flags & BTREE_ITER_IS_EXTENTS) {
 671                         /*
 672                          * The extents btree is special - KEY_TYPE_DISCARD is
 673                          * used for deletions, not KEY_TYPE_DELETED. This is an
 674                          * internal implementation detail that probably
 675                          * shouldn't be exposed (internally, KEY_TYPE_DELETED is
 676                          * used as a proxy for k->size == 0):
 677                          */
 678                         delete.k.type = KEY_TYPE_DISCARD;
 679
 680                         /* create the biggest key we can */
 681                         bch2_key_resize(&delete.k, max_sectors);
 682                         bch2_cut_back(end, &delete.k);
 683                 }
 684
 685                 ret = bch2_btree_insert_at(c, disk_res, hook, journal_seq,
 686                                            BTREE_INSERT_NOFAIL,
 687                                            BTREE_INSERT_ENTRY(&iter, &delete));
 688                 if (ret)
 689                         break;
 690
 691                 bch2_btree_iter_cond_resched(&iter);
 692         }
 693
 694         bch2_btree_iter_unlock(&iter);
 695         return ret;
 696 }