bcachefs: bch2_btree_write_buffer_maybe_flush()

Add a new helper for checking references to write buffer btrees, where
we need a flush before we definitively know we have an inconsistency.

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

diff --git a/fs/bcachefs/backpointers.c b/fs/bcachefs/backpointers.c
index 4321f9fb73bd9f7e098b663e20f516b0c505f6d4..e8037b5d8332e8f58e3c7174584b91b41c9bd69e 100644 (file)
--- a/fs/bcachefs/backpointers.c
+++ b/fs/bcachefs/backpointers.c
@@ -434,13 +434,6 @@ int bch2_check_btree_backpointers(struct bch_fs *c)
        return ret;
 }
 
-static inline bool bkey_and_val_eq(struct bkey_s_c l, struct bkey_s_c r)
-{
-       return bpos_eq(l.k->p, r.k->p) &&
-               bkey_bytes(l.k) == bkey_bytes(r.k) &&
-               !memcmp(l.v, r.v, bkey_val_bytes(l.k));
-}
-
 struct extents_to_bp_state {
        struct bpos     bucket_start;
        struct bpos     bucket_end;
@@ -536,11 +529,8 @@ static int check_bp_exists(struct btree_trans *trans,
        struct btree_iter other_extent_iter = {};
        struct printbuf buf = PRINTBUF;
        struct bkey_s_c bp_k;
-       struct bkey_buf tmp;
        int ret = 0;
 
-       bch2_bkey_buf_init(&tmp);
-
        struct bch_dev *ca = bch2_dev_bucket_tryget(c, bucket);
        if (!ca) {
                prt_str(&buf, "extent for nonexistent device:bucket ");
@@ -565,22 +555,9 @@ static int check_bp_exists(struct btree_trans *trans,
 
        if (bp_k.k->type != KEY_TYPE_backpointer ||
            memcmp(bkey_s_c_to_backpointer(bp_k).v, &bp, sizeof(bp))) {
-               bch2_bkey_buf_reassemble(&tmp, c, orig_k);
-
-               if (!bkey_and_val_eq(orig_k, bkey_i_to_s_c(s->last_flushed.k))) {
-                       if (bp.level) {
-                               bch2_trans_unlock(trans);
-                               bch2_btree_interior_updates_flush(c);
-                       }
-
-                       ret = bch2_btree_write_buffer_flush_sync(trans);
-                       if (ret)
-                               goto err;
-
-                       bch2_bkey_buf_copy(&s->last_flushed, c, tmp.k);
-                       ret = -BCH_ERR_transaction_restart_write_buffer_flush;
-                       goto out;
-               }
+               ret = bch2_btree_write_buffer_maybe_flush(trans, orig_k, &s->last_flushed);
+               if (ret)
+                       goto err;
 
                goto check_existing_bp;
        }
@@ -589,7 +566,6 @@ err:
 fsck_err:
        bch2_trans_iter_exit(trans, &other_extent_iter);
        bch2_trans_iter_exit(trans, &bp_iter);
-       bch2_bkey_buf_exit(&tmp, c);
        bch2_dev_put(ca);
        printbuf_exit(&buf);
        return ret;
@@ -905,7 +881,7 @@ static int check_one_backpointer(struct btree_trans *trans,
                                 struct bbpos start,
                                 struct bbpos end,
                                 struct bkey_s_c_backpointer bp,
-                                struct bpos *last_flushed_pos)
+                                struct bkey_buf *last_flushed)
 {
        struct bch_fs *c = trans->c;
        struct btree_iter iter;
@@ -925,20 +901,18 @@ static int check_one_backpointer(struct btree_trans *trans,
        if (ret)
                return ret;
 
-       if (!k.k && !bpos_eq(*last_flushed_pos, bp.k->p)) {
-               *last_flushed_pos = bp.k->p;
-               ret = bch2_btree_write_buffer_flush_sync(trans) ?:
-                       -BCH_ERR_transaction_restart_write_buffer_flush;
-               goto out;
-       }
+       if (!k.k) {
+               ret = bch2_btree_write_buffer_maybe_flush(trans, bp.s_c, last_flushed);
+               if (ret)
+                       goto out;
 
-       if (fsck_err_on(!k.k, c,
-                       backpointer_to_missing_ptr,
-                       "backpointer for missing %s\n  %s",
-                       bp.v->level ? "btree node" : "extent",
-                       (bch2_bkey_val_to_text(&buf, c, bp.s_c), buf.buf))) {
-               ret = bch2_btree_delete_at_buffered(trans, BTREE_ID_backpointers, bp.k->p);
-               goto out;
+               if (fsck_err(c, backpointer_to_missing_ptr,
+                            "backpointer for missing %s\n  %s",
+                            bp.v->level ? "btree node" : "extent",
+                            (bch2_bkey_val_to_text(&buf, c, bp.s_c), buf.buf))) {
+                       ret = bch2_btree_delete_at_buffered(trans, BTREE_ID_backpointers, bp.k->p);
+                       goto out;
+               }
        }
 out:
 fsck_err:
@@ -951,14 +925,20 @@ static int bch2_check_backpointers_to_extents_pass(struct btree_trans *trans,
                                                   struct bbpos start,
                                                   struct bbpos end)
 {
-       struct bpos last_flushed_pos = SPOS_MAX;
+       struct bkey_buf last_flushed;
 
-       return for_each_btree_key_commit(trans, iter, BTREE_ID_backpointers,
+       bch2_bkey_buf_init(&last_flushed);
+       bkey_init(&last_flushed.k->k);
+
+       int ret = for_each_btree_key_commit(trans, iter, BTREE_ID_backpointers,
                                  POS_MIN, BTREE_ITER_prefetch, k,
                                  NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
                check_one_backpointer(trans, start, end,
                                      bkey_s_c_to_backpointer(k),
-                                     &last_flushed_pos));
+                                     &last_flushed));
+
+       bch2_bkey_buf_exit(&last_flushed, trans->c);
+       return ret;
 }
 
 int bch2_check_backpointers_to_extents(struct bch_fs *c)

diff --git a/fs/bcachefs/bkey.h b/fs/bcachefs/bkey.h
index fcd43915df07928cb0cbfd287bc1a9cb961d707e..936357149cf0fb580dac9431d8bebfb89850bb78 100644 (file)
--- a/fs/bcachefs/bkey.h
+++ b/fs/bcachefs/bkey.h
@@ -194,6 +194,13 @@ static inline struct bpos bkey_max(struct bpos l, struct bpos r)
        return bkey_gt(l, r) ? l : r;
 }
 
+static inline bool bkey_and_val_eq(struct bkey_s_c l, struct bkey_s_c r)
+{
+       return bpos_eq(l.k->p, r.k->p) &&
+               bkey_bytes(l.k) == bkey_bytes(r.k) &&
+               !memcmp(l.v, r.v, bkey_val_bytes(l.k));
+}
+
 void bch2_bpos_swab(struct bpos *);
 void bch2_bkey_swab_key(const struct bkey_format *, struct bkey_packed *);
 

diff --git a/fs/bcachefs/btree_write_buffer.c b/fs/bcachefs/btree_write_buffer.c
index 75c8a196b3f63e393c34eeaa6ecb906c81fe3d6b..d0e92d948002d4a3e07aeeaec0cb95d6333884eb 100644 (file)
--- a/fs/bcachefs/btree_write_buffer.c
+++ b/fs/bcachefs/btree_write_buffer.c
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: GPL-2.0
 
 #include "bcachefs.h"
+#include "bkey_buf.h"
 #include "btree_locking.h"
 #include "btree_update.h"
 #include "btree_update_interior.h"
 #include "btree_write_buffer.h"
 #include "error.h"
+#include "extents.h"
 #include "journal.h"
 #include "journal_io.h"
 #include "journal_reclaim.h"
@@ -492,6 +494,41 @@ int bch2_btree_write_buffer_tryflush(struct btree_trans *trans)
        return ret;
 }
 
+/**
+ * In check and repair code, when checking references to write buffer btrees we
+ * need to issue a flush before we have a definitive error: this issues a flush
+ * if this is a key we haven't yet checked.
+ */
+int bch2_btree_write_buffer_maybe_flush(struct btree_trans *trans,
+                                       struct bkey_s_c referring_k,
+                                       struct bkey_buf *last_flushed)
+{
+       struct bch_fs *c = trans->c;
+       struct bkey_buf tmp;
+       int ret = 0;
+
+       bch2_bkey_buf_init(&tmp);
+
+       if (!bkey_and_val_eq(referring_k, bkey_i_to_s_c(last_flushed->k))) {
+               bch2_bkey_buf_reassemble(&tmp, c, referring_k);
+
+               if (bkey_is_btree_ptr(referring_k.k)) {
+                       bch2_trans_unlock(trans);
+                       bch2_btree_interior_updates_flush(c);
+               }
+
+               ret = bch2_btree_write_buffer_flush_sync(trans);
+               if (ret)
+                       goto err;
+
+               bch2_bkey_buf_copy(last_flushed, c, tmp.k);
+               ret = -BCH_ERR_transaction_restart_write_buffer_flush;
+       }
+err:
+       bch2_bkey_buf_exit(&tmp, c);
+       return ret;
+}
+
 static void bch2_btree_write_buffer_flush_work(struct work_struct *work)
 {
        struct bch_fs *c = container_of(work, struct bch_fs, btree_write_buffer.flush_work);

diff --git a/fs/bcachefs/btree_write_buffer.h b/fs/bcachefs/btree_write_buffer.h
index eebcd2b15249a773172c651d166f34876870a04e..dd5e64218b50f8789a03a41deaf689e01ad972aa 100644 (file)
--- a/fs/bcachefs/btree_write_buffer.h
+++ b/fs/bcachefs/btree_write_buffer.h
@@ -23,6 +23,9 @@ int bch2_btree_write_buffer_flush_sync(struct btree_trans *);
 int bch2_btree_write_buffer_flush_nocheck_rw(struct btree_trans *);
 int bch2_btree_write_buffer_tryflush(struct btree_trans *);
 
+struct bkey_buf;
+int bch2_btree_write_buffer_maybe_flush(struct btree_trans *, struct bkey_s_c, struct bkey_buf *);
+
 struct journal_keys_to_wb {
        struct btree_write_buffer_keys  *wb;
        size_t                          room;