bcachefs: Pass flags arg to bch2_alloc_write()

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

diff --git a/fs/bcachefs/alloc_background.c b/fs/bcachefs/alloc_background.c
index c6a909bdfc02e8cad6e9a90c6ec6b9d92caaef16..acd7be90fc47c20551c92d25c02efbfe8b8cb824 100644 (file)
--- a/fs/bcachefs/alloc_background.c
+++ b/fs/bcachefs/alloc_background.c
@@ -359,7 +359,7 @@ err:
 
 static int __bch2_alloc_write_key(struct btree_trans *trans, struct bch_dev *ca,
                                  size_t b, struct btree_iter *iter,
-                                 u64 *journal_seq, unsigned flags)
+                                 unsigned flags)
 {
        struct bch_fs *c = trans->c;
 #if 0
@@ -397,13 +397,10 @@ static int __bch2_alloc_write_key(struct btree_trans *trans, struct bch_dev *ca,
 
        bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
 
-       ret = bch2_trans_commit(trans, NULL, journal_seq,
-                                  BTREE_INSERT_NOCHECK_RW|
-                                  BTREE_INSERT_NOFAIL|
-                                  BTREE_INSERT_USE_RESERVE|
-                                  BTREE_INSERT_USE_ALLOC_RESERVE|
-                                  BTREE_INSERT_NOMARK|
-                                  flags);
+       ret = bch2_trans_commit(trans, NULL, NULL,
+                               BTREE_INSERT_NOFAIL|
+                               BTREE_INSERT_NOMARK|
+                               flags);
        if (ret)
                return ret;
 
@@ -417,14 +414,12 @@ static int __bch2_alloc_write_key(struct btree_trans *trans, struct bch_dev *ca,
        return 0;
 }
 
-int bch2_alloc_write(struct bch_fs *c, bool nowait, bool *wrote)
+int bch2_alloc_write(struct bch_fs *c, unsigned flags, bool *wrote)
 {
        struct bch_dev *ca;
        unsigned i;
        int ret = 0;
 
-       *wrote = false;
-
        for_each_rw_member(ca, c, i) {
                struct btree_trans trans;
                struct btree_iter *iter;
@@ -445,10 +440,8 @@ int bch2_alloc_write(struct bch_fs *c, bool nowait, bool *wrote)
                        if (!buckets->b[b].mark.dirty)
                                continue;
 
-                       ret = __bch2_alloc_write_key(&trans, ca, b, iter, NULL,
-                                                    nowait
-                                                    ? BTREE_INSERT_NOWAIT
-                                                    : 0);
+                       ret = __bch2_alloc_write_key(&trans, ca, b,
+                                                    iter, flags);
                        if (ret)
                                break;
 
@@ -1683,7 +1676,10 @@ int bch2_fs_allocator_start(struct bch_fs *c)
                 * XXX: it's possible for this to deadlock waiting on journal reclaim,
                 * since we're holding btree writes. What then?
                 */
-               ret = bch2_alloc_write(c, true, &wrote);
+               ret = bch2_alloc_write(c,
+                                      BTREE_INSERT_NOCHECK_RW|
+                                      BTREE_INSERT_USE_ALLOC_RESERVE|
+                                      BTREE_INSERT_NOWAIT, &wrote);
 
                /*
                 * If bch2_alloc_write() did anything, it may have used some

diff --git a/fs/bcachefs/alloc_background.h b/fs/bcachefs/alloc_background.h
index ff6eccf904af349eef7edefed6ee6dfd1d632aae..25d7426613daff2542af9e6b002205b6f3a633de 100644 (file)
--- a/fs/bcachefs/alloc_background.h
+++ b/fs/bcachefs/alloc_background.h
@@ -65,7 +65,7 @@ void bch2_dev_allocator_quiesce(struct bch_fs *, struct bch_dev *);
 void bch2_dev_allocator_stop(struct bch_dev *);
 int bch2_dev_allocator_start(struct bch_dev *);
 
-int bch2_alloc_write(struct bch_fs *, bool, bool *);
+int bch2_alloc_write(struct bch_fs *, unsigned, bool *);
 int bch2_fs_allocator_start(struct bch_fs *);
 void bch2_fs_allocator_background_init(struct bch_fs *);
 

diff --git a/fs/bcachefs/ec.c b/fs/bcachefs/ec.c
index 75fe0c28fa2222d63eebe0d18435466fe1675517..ea009f0ff829aadc18970cd8d91ac6ea95b2439c 100644 (file)
--- a/fs/bcachefs/ec.c
+++ b/fs/bcachefs/ec.c
@@ -1194,7 +1194,7 @@ static int __bch2_stripe_write_key(struct btree_trans *trans,
                                 BTREE_INSERT_NOFAIL|flags);
 }
 
-int bch2_stripes_write(struct bch_fs *c, bool *wrote)
+int bch2_stripes_write(struct bch_fs *c, unsigned flags, bool *wrote)
 {
        struct btree_trans trans;
        struct btree_iter *iter;
@@ -1216,7 +1216,7 @@ int bch2_stripes_write(struct bch_fs *c, bool *wrote)
                        continue;
 
                ret = __bch2_stripe_write_key(&trans, iter, m, giter.pos,
-                                       new_key, BTREE_INSERT_NOCHECK_RW);
+                                             new_key, flags);
                if (ret)
                        break;
 

diff --git a/fs/bcachefs/ec.h b/fs/bcachefs/ec.h
index 7bcbb7e1137753ef9407d4917a289401c153e58f..b048244a4a4593cd067423f62aa12fafb28d18bc 100644 (file)
--- a/fs/bcachefs/ec.h
+++ b/fs/bcachefs/ec.h
@@ -151,7 +151,7 @@ void bch2_ec_stop_dev(struct bch_fs *, struct bch_dev *);
 void bch2_ec_flush_new_stripes(struct bch_fs *);
 
 int bch2_stripes_read(struct bch_fs *, struct list_head *);
-int bch2_stripes_write(struct bch_fs *, bool *);
+int bch2_stripes_write(struct bch_fs *, unsigned, bool *);
 
 int bch2_ec_mem_alloc(struct bch_fs *, bool);
 

diff --git a/fs/bcachefs/super.c b/fs/bcachefs/super.c
index 18576538613c01c7a4bd8ce242347fa8cd3c8b6b..e0d4898ad0f546627975ff4ed984d506ed30dc08 100644 (file)
--- a/fs/bcachefs/super.c
+++ b/fs/bcachefs/super.c
@@ -196,13 +196,15 @@ static void __bch2_fs_read_only(struct bch_fs *c)
                goto allocator_not_running;
 
        do {
-               ret = bch2_stripes_write(c, &wrote);
+               wrote = false;
+
+               ret = bch2_stripes_write(c, BTREE_INSERT_NOCHECK_RW, &wrote);
                if (ret) {
                        bch2_fs_inconsistent(c, "error writing out stripes");
                        break;
                }
 
-               ret = bch2_alloc_write(c, false, &wrote);
+               ret = bch2_alloc_write(c, BTREE_INSERT_NOCHECK_RW, &wrote);
                if (ret) {
                        bch2_fs_inconsistent(c, "error writing out alloc info %i", ret);
                        break;
@@ -305,7 +307,9 @@ void bch2_fs_read_only(struct bch_fs *c)
        if (!bch2_journal_error(&c->journal) &&
            !test_bit(BCH_FS_ERROR, &c->flags) &&
            !test_bit(BCH_FS_EMERGENCY_RO, &c->flags) &&
-           test_bit(BCH_FS_STARTED, &c->flags))
+           test_bit(BCH_FS_STARTED, &c->flags) &&
+           !c->opts.noreplay &&
+           !c->opts.norecovery)
                bch2_fs_mark_clean(c);
 
        clear_bit(BCH_FS_RW, &c->flags);

diff --git a/fs/bcachefs/sysfs.c b/fs/bcachefs/sysfs.c
index 59503ad0006c20b7ef8d85e75ae04b22960f9687..db87a63b97cc75859670c2fd3b31fcb531103a45 100644 (file)
--- a/fs/bcachefs/sysfs.c
+++ b/fs/bcachefs/sysfs.c
@@ -502,7 +502,7 @@ STORE(__bch2_fs)
        if (attr == &sysfs_trigger_alloc_write) {
                bool wrote;
 
-               bch2_alloc_write(c, false, &wrote);
+               bch2_alloc_write(c, 0, &wrote);
        }
 
        if (attr == &sysfs_prune_cache) {