Merge pull request #196 from Conan-Kudo/spec-libexecdir

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

diff --git a/libbcachefs/movinggc.c b/libbcachefs/movinggc.c
index 0a0576326c5b2d433fcd4aace513379972f57152..69e06a84dad4094847e8c737860d5acc37b25d79 100644 (file)
--- a/libbcachefs/movinggc.c
+++ b/libbcachefs/movinggc.c
@@ -91,7 +91,7 @@ static int bch2_bucket_is_movable(struct btree_trans *trans,
 
        a = bch2_alloc_to_v4(k, &_a);
        b->k.gen        = a->gen;
-       b->sectors      = a->dirty_sectors;
+       b->sectors      = bch2_bucket_sectors_dirty(*a);
 
        ret = data_type_movable(a->data_type) &&
                a->fragmentation_lru &&
@@ -145,20 +145,21 @@ static int bch2_copygc_get_buckets(struct moving_context *ctxt,
 {
        struct btree_trans *trans = ctxt->trans;
        struct bch_fs *c = trans->c;
-       struct btree_iter iter;
-       struct bkey_s_c k;
        size_t nr_to_get = max_t(size_t, 16U, buckets_in_flight->nr / 4);
        size_t saw = 0, in_flight = 0, not_movable = 0, sectors = 0;
        int ret;
 
        move_buckets_wait(ctxt, buckets_in_flight, false);
 
-       ret = bch2_btree_write_buffer_flush(trans);
-       if (bch2_fs_fatal_err_on(ret, c, "%s: error %s from bch2_btree_write_buffer_flush()",
+       ret = bch2_btree_write_buffer_tryflush(trans);
+       if (bch2_err_matches(ret, EROFS))
+               return ret;
+
+       if (bch2_fs_fatal_err_on(ret, c, "%s: error %s from bch2_btree_write_buffer_tryflush()",
                                 __func__, bch2_err_str(ret)))
                return ret;
 
-       ret = for_each_btree_key2_upto(trans, iter, BTREE_ID_lru,
+       ret = for_each_btree_key_upto(trans, iter, BTREE_ID_lru,
                                  lru_pos(BCH_LRU_FRAGMENTATION_START, 0, 0),
                                  lru_pos(BCH_LRU_FRAGMENTATION_START, U64_MAX, LRU_TIME_MAX),
                                  0, k, ({
@@ -167,15 +168,23 @@ static int bch2_copygc_get_buckets(struct moving_context *ctxt,
 
                saw++;
 
-               if (!bch2_bucket_is_movable(trans, &b, lru_pos_time(k.k->p)))
+               ret2 = bch2_bucket_is_movable(trans, &b, lru_pos_time(k.k->p));
+               if (ret2 < 0)
+                       goto err;
+
+               if (!ret2)
                        not_movable++;
                else if (bucket_in_flight(buckets_in_flight, b.k))
                        in_flight++;
                else {
-                       ret2 = darray_push(buckets, b) ?: buckets->nr >= nr_to_get;
-                       if (ret2 >= 0)
-                               sectors += b.sectors;
+                       ret2 = darray_push(buckets, b);
+                       if (ret2)
+                               goto err;
+                       sectors += b.sectors;
                }
+
+               ret2 = buckets->nr >= nr_to_get;
+err:
                ret2;
        }));
 
@@ -198,7 +207,6 @@ static int bch2_copygc(struct moving_context *ctxt,
        };
        move_buckets buckets = { 0 };
        struct move_bucket_in_flight *f;
-       struct move_bucket *i;
        u64 moved = atomic64_read(&ctxt->stats->sectors_moved);
        int ret = 0;
 
@@ -207,7 +215,7 @@ static int bch2_copygc(struct moving_context *ctxt,
                goto err;
 
        darray_for_each(buckets, i) {
-               if (unlikely(freezing(current)))
+               if (kthread_should_stop() || freezing(current))
                        break;
 
                f = move_bucket_in_flight_add(buckets_in_flight, *i);
@@ -221,7 +229,7 @@ static int bch2_copygc(struct moving_context *ctxt,
                        break;
                }
 
-               ret = __bch2_evacuate_bucket(ctxt, f, f->bucket.k.bucket,
+               ret = bch2_evacuate_bucket(ctxt, f, f->bucket.k.bucket,
                                             f->bucket.k.gen, data_opts);
                if (ret)
                        goto err;
@@ -259,19 +267,16 @@ err:
  */
 unsigned long bch2_copygc_wait_amount(struct bch_fs *c)
 {
-       struct bch_dev *ca;
-       unsigned dev_idx;
        s64 wait = S64_MAX, fragmented_allowed, fragmented;
-       unsigned i;
 
-       for_each_rw_member(ca, c, dev_idx) {
+       for_each_rw_member(c, ca) {
                struct bch_dev_usage usage = bch2_dev_usage_read(ca);
 
                fragmented_allowed = ((__dev_buckets_available(ca, usage, BCH_WATERMARK_stripe) *
                                       ca->mi.bucket_size) >> 1);
                fragmented = 0;
 
-               for (i = 0; i < BCH_DATA_NR; i++)
+               for (unsigned i = 0; i < BCH_DATA_NR; i++)
                        if (data_type_movable(i))
                                fragmented += usage.d[i].fragmented;
 
@@ -313,9 +318,9 @@ static int bch2_copygc_thread(void *arg)
        if (!buckets)
                return -ENOMEM;
        ret = rhashtable_init(&buckets->table, &bch_move_bucket_params);
+       bch_err_msg(c, ret, "allocating copygc buckets in flight");
        if (ret) {
                kfree(buckets);
-               bch_err_msg(c, ret, "allocating copygc buckets in flight");
                return ret;
        }
 
@@ -334,7 +339,8 @@ static int bch2_copygc_thread(void *arg)
 
                if (!c->copy_gc_enabled) {
                        move_buckets_wait(&ctxt, buckets, true);
-                       kthread_wait_freezable(c->copy_gc_enabled);
+                       kthread_wait_freezable(c->copy_gc_enabled ||
+                                              kthread_should_stop());
                }
 
                if (unlikely(freezing(current))) {
@@ -411,10 +417,9 @@ int bch2_copygc_start(struct bch_fs *c)
 
        t = kthread_create(bch2_copygc_thread, c, "bch-copygc/%s", c->name);
        ret = PTR_ERR_OR_ZERO(t);
-       if (ret) {
-               bch_err_msg(c, ret, "creating copygc thread");
+       bch_err_msg(c, ret, "creating copygc thread");
+       if (ret)
                return ret;
-       }
 
        get_task_struct(t);