Update bcachefs sources to e67d924a90 bcachefs: Introduce bch2_journal_keys_peek_...

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

diff --git a/libbcachefs/rebalance.c b/libbcachefs/rebalance.c
index 44d2651be9700590177844f29e14b0938efc8235..d914892f53396dc83c7c868dcbeaa7b4f13cb738 100644 (file)
--- a/libbcachefs/rebalance.c
+++ b/libbcachefs/rebalance.c
@@ -166,19 +166,21 @@ static int bch2_rebalance_thread(void *arg)
        struct bch_fs_rebalance *r = &c->rebalance;
        struct io_clock *clock = &c->io_clock[WRITE];
        struct rebalance_work w, p;
+       struct bch_move_stats move_stats;
        unsigned long start, prev_start;
        unsigned long prev_run_time, prev_run_cputime;
        unsigned long cputime, prev_cputime;
-       unsigned long io_start;
+       u64 io_start;
        long throttle;
 
        set_freezable();
 
-       io_start        = atomic_long_read(&clock->now);
+       io_start        = atomic64_read(&clock->now);
        p               = rebalance_work(c);
        prev_start      = jiffies;
        prev_cputime    = curr_cputime();
 
+       bch_move_stats_init(&move_stats, "rebalance");
        while (!kthread_wait_freezable(r->enabled)) {
                cond_resched();
 
@@ -210,7 +212,7 @@ static int bch2_rebalance_thread(void *arg)
                                        (20 - w.dev_most_full_percent),
                                        50);
 
-                       if (atomic_long_read(&clock->now) + clock->max_slop <
+                       if (atomic64_read(&clock->now) + clock->max_slop <
                            r->throttled_until_iotime) {
                                r->throttled_until_cputime = start + throttle;
                                r->state = REBALANCE_THROTTLED;
@@ -229,22 +231,23 @@ static int bch2_rebalance_thread(void *arg)
                              max(p.dev_most_full_percent, 1U) /
                              max(w.dev_most_full_percent, 1U));
 
-               io_start        = atomic_long_read(&clock->now);
+               io_start        = atomic64_read(&clock->now);
                p               = w;
                prev_start      = start;
                prev_cputime    = cputime;
 
                r->state = REBALANCE_RUNNING;
-               memset(&r->move_stats, 0, sizeof(r->move_stats));
+               memset(&move_stats, 0, sizeof(move_stats));
                rebalance_work_reset(c);
 
                bch2_move_data(c,
+                              0,               POS_MIN,
+                              BTREE_ID_NR,     POS_MAX,
                               /* ratelimiting disabled for now */
                               NULL, /*  &r->pd.rate, */
                               writepoint_ptr(&c->rebalance_write_point),
-                              POS_MIN, POS_MAX,
                               rebalance_pred, NULL,
-                              &r->move_stats);
+                              &move_stats);
        }
 
        return 0;
@@ -254,38 +257,47 @@ void bch2_rebalance_work_to_text(struct printbuf *out, struct bch_fs *c)
 {
        struct bch_fs_rebalance *r = &c->rebalance;
        struct rebalance_work w = rebalance_work(c);
-       char h1[21], h2[21];
 
-       bch2_hprint(&PBUF(h1), w.dev_most_full_work << 9);
-       bch2_hprint(&PBUF(h2), w.dev_most_full_capacity << 9);
-       pr_buf(out, "fullest_dev (%i):\t%s/%s\n",
-              w.dev_most_full_idx, h1, h2);
+       out->tabstops[0] = 20;
 
-       bch2_hprint(&PBUF(h1), w.total_work << 9);
-       bch2_hprint(&PBUF(h2), c->capacity << 9);
-       pr_buf(out, "total work:\t\t%s/%s\n", h1, h2);
+       pr_buf(out, "fullest_dev (%i):", w.dev_most_full_idx);
+       pr_tab(out);
 
-       pr_buf(out, "rate:\t\t\t%u\n", r->pd.rate.rate);
+       bch2_hprint(out, w.dev_most_full_work << 9);
+       pr_buf(out, "/");
+       bch2_hprint(out, w.dev_most_full_capacity << 9);
+       pr_newline(out);
+
+       pr_buf(out, "total work:");
+       pr_tab(out);
+
+       bch2_hprint(out, w.total_work << 9);
+       pr_buf(out, "/");
+       bch2_hprint(out, c->capacity << 9);
+       pr_newline(out);
+
+       pr_buf(out, "rate:");
+       pr_tab(out);
+       pr_buf(out, "%u", r->pd.rate.rate);
+       pr_newline(out);
 
        switch (r->state) {
        case REBALANCE_WAITING:
-               pr_buf(out, "waiting\n");
+               pr_buf(out, "waiting");
                break;
        case REBALANCE_THROTTLED:
-               bch2_hprint(&PBUF(h1),
+               pr_buf(out, "throttled for %lu sec or ",
+                      (r->throttled_until_cputime - jiffies) / HZ);
+               bch2_hprint(out,
                            (r->throttled_until_iotime -
-                            atomic_long_read(&c->io_clock[WRITE].now)) << 9);
-               pr_buf(out, "throttled for %lu sec or %s io\n",
-                      (r->throttled_until_cputime - jiffies) / HZ,
-                      h1);
+                            atomic64_read(&c->io_clock[WRITE].now)) << 9);
+               pr_buf(out, " io");
                break;
        case REBALANCE_RUNNING:
-               pr_buf(out, "running\n");
-               pr_buf(out, "pos %llu:%llu\n",
-                      r->move_stats.pos.inode,
-                      r->move_stats.pos.offset);
+               pr_buf(out, "running");
                break;
        }
+       pr_newline(out);
 }
 
 void bch2_rebalance_stop(struct bch_fs *c)
@@ -311,12 +323,17 @@ int bch2_rebalance_start(struct bch_fs *c)
 {
        struct task_struct *p;
 
+       if (c->rebalance.thread)
+               return 0;
+
        if (c->opts.nochanges)
                return 0;
 
-       p = kthread_create(bch2_rebalance_thread, c, "bch_rebalance");
-       if (IS_ERR(p))
+       p = kthread_create(bch2_rebalance_thread, c, "bch-rebalance/%s", c->name);
+       if (IS_ERR(p)) {
+               bch_err(c, "error creating rebalance thread: %li", PTR_ERR(p));
                return PTR_ERR(p);
+       }
 
        get_task_struct(p);
        rcu_assign_pointer(c->rebalance.thread, p);