X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libbcachefs%2Frebalance.c;h=d914892f53396dc83c7c868dcbeaa7b4f13cb738;hb=7923c2ee0616ef35d984e292dd9e799babe96662;hp=44d2651be9700590177844f29e14b0938efc8235;hpb=37270fc79cbe4ab62001893eebd16b6fde4b621b;p=bcachefs-tools-debian

diff --git a/libbcachefs/rebalance.c b/libbcachefs/rebalance.c
index 44d2651..d914892 100644
--- 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);