Update bcachefs sources to ffe09df106 bcachefs: Verify fs hasn't been modified before...

[bcachefs-tools-debian] / libbcachefs / journal.h

diff --git a/libbcachefs/journal.h b/libbcachefs/journal.h
index 50d864a3cae3566bcb31da609ccd48fe6043db6c..83b70d51860f063508d9bcd8bae637ca1a079b90 100644 (file)
--- a/libbcachefs/journal.h
+++ b/libbcachefs/journal.h
@@ -118,6 +118,7 @@ static inline void journal_wake(struct journal *j)
 {
        wake_up(&j->wait);
        closure_wake_up(&j->async_wait);
+       closure_wake_up(&j->preres_wait);
 }
 
 static inline struct journal_buf *journal_cur_buf(struct journal *j)
@@ -178,6 +179,11 @@ static inline unsigned jset_u64s(unsigned u64s)
        return u64s + sizeof(struct jset_entry) / sizeof(u64);
 }
 
+static inline int journal_entry_overhead(struct journal *j)
+{
+       return sizeof(struct jset) / sizeof(u64) + j->entry_u64s_reserved;
+}
+
 static inline struct jset_entry *
 bch2_journal_add_entry_noreservation(struct journal_buf *buf, size_t u64s)
 {
@@ -222,7 +228,7 @@ static inline void bch2_journal_add_keys(struct journal *j, struct journal_res *
                               id, 0, k, k->k.u64s);
 }
 
-void bch2_journal_buf_put_slowpath(struct journal *, bool);
+void __bch2_journal_buf_put(struct journal *, bool);
 
 static inline void bch2_journal_buf_put(struct journal *j, unsigned idx,
                                       bool need_write_just_set)
@@ -233,17 +239,10 @@ static inline void bch2_journal_buf_put(struct journal *j, unsigned idx,
                                    .buf0_count = idx == 0,
                                    .buf1_count = idx == 1,
                                    }).v, &j->reservations.counter);
-
-       EBUG_ON(s.idx != idx && !s.prev_buf_unwritten);
-
-       /*
-        * Do not initiate a journal write if the journal is in an error state
-        * (previous journal entry write may have failed)
-        */
-       if (s.idx != idx &&
-           !journal_state_count(s, idx) &&
-           s.cur_entry_offset != JOURNAL_ENTRY_ERROR_VAL)
-               bch2_journal_buf_put_slowpath(j, need_write_just_set);
+       if (!journal_state_count(s, idx)) {
+               EBUG_ON(s.idx == idx || !s.prev_buf_unwritten);
+               __bch2_journal_buf_put(j, need_write_just_set);
+       }
 }
 
 /*
@@ -273,6 +272,7 @@ int bch2_journal_res_get_slowpath(struct journal *, struct journal_res *,
 
 #define JOURNAL_RES_GET_NONBLOCK       (1 << 0)
 #define JOURNAL_RES_GET_CHECK          (1 << 1)
+#define JOURNAL_RES_GET_RESERVED       (1 << 2)
 
 static inline int journal_res_get_fast(struct journal *j,
                                       struct journal_res *res,
@@ -291,6 +291,12 @@ static inline int journal_res_get_fast(struct journal *j,
                if (new.cur_entry_offset + res->u64s > j->cur_entry_u64s)
                        return 0;
 
+               EBUG_ON(!journal_state_count(new, new.idx));
+
+               if (!(flags & JOURNAL_RES_GET_RESERVED) &&
+                   !test_bit(JOURNAL_MAY_GET_UNRESERVED, &j->flags))
+                       return 0;
+
                if (flags & JOURNAL_RES_GET_CHECK)
                        return 1;
 
@@ -330,6 +336,91 @@ out:
        return 0;
 }
 
+/* journal_preres: */
+
+static inline bool journal_check_may_get_unreserved(struct journal *j)
+{
+       union journal_preres_state s = READ_ONCE(j->prereserved);
+       bool ret = s.reserved <= s.remaining &&
+               fifo_free(&j->pin) > 8;
+
+       lockdep_assert_held(&j->lock);
+
+       if (ret != test_bit(JOURNAL_MAY_GET_UNRESERVED, &j->flags)) {
+               if (ret) {
+                       set_bit(JOURNAL_MAY_GET_UNRESERVED, &j->flags);
+                       journal_wake(j);
+               } else {
+                       clear_bit(JOURNAL_MAY_GET_UNRESERVED, &j->flags);
+               }
+       }
+       return ret;
+}
+
+static inline void bch2_journal_preres_put(struct journal *j,
+                                          struct journal_preres *res)
+{
+       union journal_preres_state s = { .reserved = res->u64s };
+
+       if (!res->u64s)
+               return;
+
+       s.v = atomic64_sub_return(s.v, &j->prereserved.counter);
+       res->u64s = 0;
+       closure_wake_up(&j->preres_wait);
+
+       if (s.reserved <= s.remaining &&
+           !test_bit(JOURNAL_MAY_GET_UNRESERVED, &j->flags)) {
+               spin_lock(&j->lock);
+               journal_check_may_get_unreserved(j);
+               spin_unlock(&j->lock);
+       }
+}
+
+int __bch2_journal_preres_get(struct journal *,
+                       struct journal_preres *, unsigned);
+
+static inline int bch2_journal_preres_get_fast(struct journal *j,
+                                              struct journal_preres *res,
+                                              unsigned new_u64s)
+{
+       int d = new_u64s - res->u64s;
+       union journal_preres_state old, new;
+       u64 v = atomic64_read(&j->prereserved.counter);
+
+       do {
+               old.v = new.v = v;
+
+               new.reserved += d;
+
+               if (new.reserved > new.remaining)
+                       return 0;
+       } while ((v = atomic64_cmpxchg(&j->prereserved.counter,
+                                      old.v, new.v)) != old.v);
+
+       res->u64s += d;
+       return 1;
+}
+
+static inline int bch2_journal_preres_get(struct journal *j,
+                                         struct journal_preres *res,
+                                         unsigned new_u64s,
+                                         unsigned flags)
+{
+       if (new_u64s <= res->u64s)
+               return 0;
+
+       if (bch2_journal_preres_get_fast(j, res, new_u64s))
+               return 0;
+
+       if (flags & JOURNAL_RES_GET_NONBLOCK)
+               return -EAGAIN;
+
+       return __bch2_journal_preres_get(j, res, new_u64s);
+}
+
+/* journal_entry_res: */
+
 void bch2_journal_entry_res_resize(struct journal *,
                                   struct journal_entry_res *,
                                   unsigned);
@@ -367,6 +458,9 @@ static inline void bch2_journal_set_replay_done(struct journal *j)
        set_bit(JOURNAL_REPLAY_DONE, &j->flags);
 }
 
+void bch2_journal_unblock(struct journal *);
+void bch2_journal_block(struct journal *);
+
 ssize_t bch2_journal_print_debug(struct journal *, char *);
 ssize_t bch2_journal_print_pins(struct journal *, char *);