Update bcachefs sources to 1b14994029 bcachefs: Fragmentation LRU

[bcachefs-tools-debian] / libbcachefs / journal_reclaim.c

diff --git a/libbcachefs/journal_reclaim.c b/libbcachefs/journal_reclaim.c
index a9f7d5a7feb2a8811a406d42974c47305c479721..8744581dfda7de7bad38aa65ad66b9aca27562a1 100644 (file)
--- a/libbcachefs/journal_reclaim.c
+++ b/libbcachefs/journal_reclaim.c
@@ -2,6 +2,7 @@
 
 #include "bcachefs.h"
 #include "btree_key_cache.h"
+#include "errcode.h"
 #include "error.h"
 #include "journal.h"
 #include "journal_io.h"
@@ -231,7 +232,7 @@ void bch2_journal_space_available(struct journal *j)
        if ((j->space[journal_space_clean_ondisk].next_entry <
             j->space[journal_space_clean_ondisk].total) &&
            (clean - clean_ondisk <= total / 8) &&
-           (clean_ondisk * 2 > clean ))
+           (clean_ondisk * 2 > clean))
                set_bit(JOURNAL_MAY_SKIP_FLUSH, &j->flags);
        else
                clear_bit(JOURNAL_MAY_SKIP_FLUSH, &j->flags);
@@ -282,11 +283,11 @@ void bch2_journal_do_discards(struct journal *j)
                while (should_discard_bucket(j, ja)) {
                        if (!c->opts.nochanges &&
                            ca->mi.discard &&
-                           blk_queue_discard(bdev_get_queue(ca->disk_sb.bdev)))
+                           bdev_max_discard_sectors(ca->disk_sb.bdev))
                                blkdev_issue_discard(ca->disk_sb.bdev,
                                        bucket_to_sector(ca,
                                                ja->buckets[ja->discard_idx]),
-                                       ca->mi.bucket_size, GFP_NOIO, 0);
+                                       ca->mi.bucket_size, GFP_NOIO);
 
                        spin_lock(&j->lock);
                        ja->discard_idx = (ja->discard_idx + 1) % ja->nr;
@@ -346,13 +347,13 @@ void bch2_journal_pin_put(struct journal *j, u64 seq)
        }
 }
 
-static inline void __journal_pin_drop(struct journal *j,
+static inline bool __journal_pin_drop(struct journal *j,
                                      struct journal_entry_pin *pin)
 {
        struct journal_entry_pin_list *pin_list;
 
        if (!journal_pin_active(pin))
-               return;
+               return false;
 
        if (j->flush_in_progress == pin)
                j->flush_in_progress_dropped = true;
@@ -365,16 +366,16 @@ static inline void __journal_pin_drop(struct journal *j,
         * Unpinning a journal entry make make journal_next_bucket() succeed, if
         * writing a new last_seq will now make another bucket available:
         */
-       if (atomic_dec_and_test(&pin_list->count) &&
-           pin_list == &fifo_peek_front(&j->pin))
-               bch2_journal_reclaim_fast(j);
+       return atomic_dec_and_test(&pin_list->count) &&
+               pin_list == &fifo_peek_front(&j->pin);
 }
 
 void bch2_journal_pin_drop(struct journal *j,
                           struct journal_entry_pin *pin)
 {
        spin_lock(&j->lock);
-       __journal_pin_drop(j, pin);
+       if (__journal_pin_drop(j, pin))
+               bch2_journal_reclaim_fast(j);
        spin_unlock(&j->lock);
 }
 
@@ -383,6 +384,7 @@ void bch2_journal_pin_set(struct journal *j, u64 seq,
                          journal_pin_flush_fn flush_fn)
 {
        struct journal_entry_pin_list *pin_list;
+       bool reclaim;
 
        spin_lock(&j->lock);
 
@@ -399,7 +401,7 @@ void bch2_journal_pin_set(struct journal *j, u64 seq,
 
        pin_list = journal_seq_pin(j, seq);
 
-       __journal_pin_drop(j, pin);
+       reclaim = __journal_pin_drop(j, pin);
 
        atomic_inc(&pin_list->count);
        pin->seq        = seq;
@@ -411,6 +413,9 @@ void bch2_journal_pin_set(struct journal *j, u64 seq,
                list_add(&pin->list, &pin_list->list);
        else
                list_add(&pin->list, &pin_list->flushed);
+
+       if (reclaim)
+               bch2_journal_reclaim_fast(j);
        spin_unlock(&j->lock);
 
        /*
@@ -589,7 +594,7 @@ static u64 journal_seq_to_flush(struct journal *j)
  * 512 journal entries or 25% of all journal buckets, then
  * journal_next_bucket() should not stall.
  */
-static int __bch2_journal_reclaim(struct journal *j, bool direct)
+static int __bch2_journal_reclaim(struct journal *j, bool direct, bool kicked)
 {
        struct bch_fs *c = container_of(j, struct bch_fs, journal);
        bool kthread = (current->flags & PF_KTHREAD) != 0;
@@ -638,8 +643,11 @@ static int __bch2_journal_reclaim(struct journal *j, bool direct)
                if (atomic_read(&c->btree_cache.dirty) * 2 > c->btree_cache.used)
                        min_nr = 1;
 
-               trace_journal_reclaim_start(c,
-                               min_nr,
+               min_key_cache = min(bch2_nr_btree_keys_need_flush(c), (size_t) 128);
+
+               trace_and_count(c, journal_reclaim_start, c,
+                               direct, kicked,
+                               min_nr, min_key_cache,
                                j->prereserved.reserved,
                                j->prereserved.remaining,
                                atomic_read(&c->btree_cache.dirty),
@@ -647,8 +655,6 @@ static int __bch2_journal_reclaim(struct journal *j, bool direct)
                                atomic_long_read(&c->btree_key_cache.nr_dirty),
                                atomic_long_read(&c->btree_key_cache.nr_keys));
 
-               min_key_cache = min(bch2_nr_btree_keys_need_flush(c), (size_t) 128);
-
                nr_flushed = journal_flush_pins(j, seq_to_flush,
                                                min_nr, min_key_cache);
 
@@ -656,7 +662,7 @@ static int __bch2_journal_reclaim(struct journal *j, bool direct)
                        j->nr_direct_reclaim += nr_flushed;
                else
                        j->nr_background_reclaim += nr_flushed;
-               trace_journal_reclaim_finish(c, nr_flushed);
+               trace_and_count(c, journal_reclaim_finish, c, nr_flushed);
 
                if (nr_flushed)
                        wake_up(&j->reclaim_wait);
@@ -669,7 +675,7 @@ static int __bch2_journal_reclaim(struct journal *j, bool direct)
 
 int bch2_journal_reclaim(struct journal *j)
 {
-       return __bch2_journal_reclaim(j, true);
+       return __bch2_journal_reclaim(j, true, true);
 }
 
 static int bch2_journal_reclaim_thread(void *arg)
@@ -685,10 +691,12 @@ static int bch2_journal_reclaim_thread(void *arg)
        j->last_flushed = jiffies;
 
        while (!ret && !kthread_should_stop()) {
+               bool kicked = j->reclaim_kicked;
+
                j->reclaim_kicked = false;
 
                mutex_lock(&j->reclaim_lock);
-               ret = __bch2_journal_reclaim(j, false);
+               ret = __bch2_journal_reclaim(j, false, kicked);
                mutex_unlock(&j->reclaim_lock);
 
                now = jiffies;
@@ -699,7 +707,7 @@ static int bch2_journal_reclaim_thread(void *arg)
                        j->next_reclaim = now + delay;
 
                while (1) {
-                       set_current_state(TASK_INTERRUPTIBLE);
+                       set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
                        if (kthread_should_stop())
                                break;
                        if (j->reclaim_kicked)
@@ -710,9 +718,9 @@ static int bch2_journal_reclaim_thread(void *arg)
                        spin_unlock(&j->lock);
 
                        if (journal_empty)
-                               freezable_schedule();
+                               schedule();
                        else if (time_after(j->next_reclaim, jiffies))
-                               freezable_schedule_timeout(j->next_reclaim - jiffies);
+                               schedule_timeout(j->next_reclaim - jiffies);
                        else
                                break;
                }
@@ -738,15 +746,17 @@ int bch2_journal_reclaim_start(struct journal *j)
 {
        struct bch_fs *c = container_of(j, struct bch_fs, journal);
        struct task_struct *p;
+       int ret;
 
        if (j->reclaim_thread)
                return 0;
 
        p = kthread_create(bch2_journal_reclaim_thread, j,
                           "bch-reclaim/%s", c->name);
-       if (IS_ERR(p)) {
-               bch_err(c, "error creating journal reclaim thread: %li", PTR_ERR(p));
-               return PTR_ERR(p);
+       ret = PTR_ERR_OR_ZERO(p);
+       if (ret) {
+               bch_err(c, "error creating journal reclaim thread: %s", bch2_err_str(ret));
+               return ret;
        }
 
        get_task_struct(p);