git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/movinggc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Moving/copying garbage collector
   4  *
   5  * Copyright 2012 Google, Inc.
   6  */
   7
   8 #include "bcachefs.h"
   9 #include "alloc_foreground.h"
  10 #include "btree_iter.h"
  11 #include "btree_update.h"
  12 #include "buckets.h"
  13 #include "clock.h"
  14 #include "disk_groups.h"
  15 #include "error.h"
  16 #include "extents.h"
  17 #include "eytzinger.h"
  18 #include "io.h"
  19 #include "keylist.h"
  20 #include "move.h"
  21 #include "movinggc.h"
  22 #include "super-io.h"
  23
  24 #include <trace/events/bcachefs.h>
  25 #include <linux/freezer.h>
  26 #include <linux/kthread.h>
  27 #include <linux/math64.h>
  28 #include <linux/sched/task.h>
  29 #include <linux/sort.h>
  30 #include <linux/wait.h>
  31
  32 /*
  33  * We can't use the entire copygc reserve in one iteration of copygc: we may
  34  * need the buckets we're freeing up to go back into the copygc reserve to make
  35  * forward progress, but if the copygc reserve is full they'll be available for
  36  * any allocation - and it's possible that in a given iteration, we free up most
  37  * of the buckets we're going to free before we allocate most of the buckets
  38  * we're going to allocate.
  39  *
  40  * If we only use half of the reserve per iteration, then in steady state we'll
  41  * always have room in the reserve for the buckets we're going to need in the
  42  * next iteration:
  43  */
  44 #define COPYGC_BUCKETS_PER_ITER(ca)                                     \
  45         ((ca)->free[RESERVE_MOVINGGC].size / 2)
  46
  47 static int bucket_offset_cmp(const void *_l, const void *_r, size_t size)
  48 {
  49         const struct copygc_heap_entry *l = _l;
  50         const struct copygc_heap_entry *r = _r;
  51
  52         return  cmp_int(l->dev,    r->dev) ?:
  53                 cmp_int(l->offset, r->offset);
  54 }
  55
  56 static enum data_cmd copygc_pred(struct bch_fs *c, void *arg,
  57                                  struct bkey_s_c k,
  58                                  struct bch_io_opts *io_opts,
  59                                  struct data_opts *data_opts)
  60 {
  61         copygc_heap *h = &c->copygc_heap;
  62         struct bkey_ptrs_c ptrs = bch2_bkey_ptrs_c(k);
  63         const union bch_extent_entry *entry;
  64         struct extent_ptr_decoded p = { 0 };
  65
  66         bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
  67                 struct bch_dev *ca = bch_dev_bkey_exists(c, p.ptr.dev);
  68                 struct copygc_heap_entry search = {
  69                         .dev    = p.ptr.dev,
  70                         .offset = p.ptr.offset,
  71                 };
  72
  73                 ssize_t i = eytzinger0_find_le(h->data, h->used,
  74                                                sizeof(h->data[0]),
  75                                                bucket_offset_cmp, &search);
  76 #if 0
  77                 /* eytzinger search verify code: */
  78                 ssize_t j = -1, k;
  79
  80                 for (k = 0; k < h->used; k++)
  81                         if (h->data[k].offset <= ptr->offset &&
  82                             (j < 0 || h->data[k].offset > h->data[j].offset))
  83                                 j = k;
  84
  85                 BUG_ON(i != j);
  86 #endif
  87                 if (i >= 0 &&
  88                     p.ptr.dev == h->data[i].dev &&
  89                     p.ptr.offset < h->data[i].offset + ca->mi.bucket_size &&
  90                     p.ptr.gen == h->data[i].gen) {
  91                         /*
  92                          * We need to use the journal reserve here, because
  93                          *  - journal reclaim depends on btree key cache
  94                          *    flushing to make forward progress,
  95                          *  - which has to make forward progress when the
  96                          *    journal is pre-reservation full,
  97                          *  - and depends on allocation - meaning allocator and
  98                          *    copygc
  99                          */
 100
 101                         data_opts->target               = io_opts->background_target;
 102                         data_opts->nr_replicas          = 1;
 103                         data_opts->btree_insert_flags   = BTREE_INSERT_USE_RESERVE|
 104                                 BTREE_INSERT_JOURNAL_RESERVED;
 105                         data_opts->rewrite_dev          = p.ptr.dev;
 106
 107                         if (p.has_ec)
 108                                 data_opts->nr_replicas += p.ec.redundancy;
 109
 110                         return DATA_REWRITE;
 111                 }
 112         }
 113
 114         return DATA_SKIP;
 115 }
 116
 117 static bool have_copygc_reserve(struct bch_dev *ca)
 118 {
 119         bool ret;
 120
 121         spin_lock(&ca->fs->freelist_lock);
 122         ret = fifo_full(&ca->free[RESERVE_MOVINGGC]) ||
 123                 ca->allocator_state != ALLOCATOR_running;
 124         spin_unlock(&ca->fs->freelist_lock);
 125
 126         return ret;
 127 }
 128
 129 static inline int fragmentation_cmp(copygc_heap *heap,
 130                                    struct copygc_heap_entry l,
 131                                    struct copygc_heap_entry r)
 132 {
 133         return cmp_int(l.fragmentation, r.fragmentation);
 134 }
 135
 136 static int bch2_copygc(struct bch_fs *c)
 137 {
 138         copygc_heap *h = &c->copygc_heap;
 139         struct copygc_heap_entry e, *i;
 140         struct bucket_array *buckets;
 141         struct bch_move_stats move_stats;
 142         u64 sectors_to_move = 0, sectors_to_write = 0, sectors_not_moved = 0;
 143         u64 sectors_reserved = 0;
 144         u64 buckets_to_move, buckets_not_moved = 0;
 145         struct bch_dev *ca;
 146         unsigned dev_idx;
 147         size_t b, heap_size = 0;
 148         int ret;
 149
 150         bch_move_stats_init(&move_stats, "copygc");
 151
 152         /*
 153          * Find buckets with lowest sector counts, skipping completely
 154          * empty buckets, by building a maxheap sorted by sector count,
 155          * and repeatedly replacing the maximum element until all
 156          * buckets have been visited.
 157          */
 158         h->used = 0;
 159
 160         for_each_rw_member(ca, c, dev_idx)
 161                 heap_size += ca->mi.nbuckets >> 7;
 162
 163         if (h->size < heap_size) {
 164                 free_heap(&c->copygc_heap);
 165                 if (!init_heap(&c->copygc_heap, heap_size, GFP_KERNEL)) {
 166                         bch_err(c, "error allocating copygc heap");
 167                         return 0;
 168                 }
 169         }
 170
 171         for_each_rw_member(ca, c, dev_idx) {
 172                 closure_wait_event(&c->freelist_wait, have_copygc_reserve(ca));
 173
 174                 spin_lock(&ca->fs->freelist_lock);
 175                 sectors_reserved += fifo_used(&ca->free[RESERVE_MOVINGGC]) * ca->mi.bucket_size;
 176                 spin_unlock(&ca->fs->freelist_lock);
 177
 178                 down_read(&ca->bucket_lock);
 179                 buckets = bucket_array(ca);
 180
 181                 for (b = buckets->first_bucket; b < buckets->nbuckets; b++) {
 182                         struct bucket *g = buckets->b + b;
 183                         struct bucket_mark m = READ_ONCE(g->mark);
 184                         struct copygc_heap_entry e;
 185
 186                         if (m.owned_by_allocator ||
 187                             m.data_type != BCH_DATA_user ||
 188                             !bucket_sectors_used(m) ||
 189                             bucket_sectors_used(m) >= ca->mi.bucket_size)
 190                                 continue;
 191
 192                         WARN_ON(m.stripe && !g->stripe_redundancy);
 193
 194                         e = (struct copygc_heap_entry) {
 195                                 .dev            = dev_idx,
 196                                 .gen            = m.gen,
 197                                 .replicas       = 1 + g->stripe_redundancy,
 198                                 .fragmentation  = bucket_sectors_used(m) * (1U << 15)
 199                                         / ca->mi.bucket_size,
 200                                 .sectors        = bucket_sectors_used(m),
 201                                 .offset         = bucket_to_sector(ca, b),
 202                         };
 203                         heap_add_or_replace(h, e, -fragmentation_cmp, NULL);
 204                 }
 205                 up_read(&ca->bucket_lock);
 206         }
 207
 208         /*
 209          * Our btree node allocations also come out of RESERVE_MOVINGGC:
 210          */
 211         sectors_reserved = (sectors_reserved * 3) / 4;
 212         if (!sectors_reserved) {
 213                 bch2_fs_fatal_error(c, "stuck, ran out of copygc reserve!");
 214                 return -1;
 215         }
 216
 217         for (i = h->data; i < h->data + h->used; i++) {
 218                 sectors_to_move += i->sectors;
 219                 sectors_to_write += i->sectors * i->replicas;
 220         }
 221
 222         while (sectors_to_write > sectors_reserved) {
 223                 BUG_ON(!heap_pop(h, e, -fragmentation_cmp, NULL));
 224                 sectors_to_write -= e.sectors * e.replicas;
 225         }
 226
 227         buckets_to_move = h->used;
 228
 229         if (!buckets_to_move)
 230                 return 0;
 231
 232         eytzinger0_sort(h->data, h->used,
 233                         sizeof(h->data[0]),
 234                         bucket_offset_cmp, NULL);
 235
 236         ret = bch2_move_data(c,
 237                              0,                 POS_MIN,
 238                              BTREE_ID_NR,       POS_MAX,
 239                              NULL,
 240                              writepoint_ptr(&c->copygc_write_point),
 241                              copygc_pred, NULL,
 242                              &move_stats);
 243
 244         for_each_rw_member(ca, c, dev_idx) {
 245                 down_read(&ca->bucket_lock);
 246                 buckets = bucket_array(ca);
 247                 for (i = h->data; i < h->data + h->used; i++) {
 248                         struct bucket_mark m;
 249                         size_t b;
 250
 251                         if (i->dev != dev_idx)
 252                                 continue;
 253
 254                         b = sector_to_bucket(ca, i->offset);
 255                         m = READ_ONCE(buckets->b[b].mark);
 256
 257                         if (i->gen == m.gen &&
 258                             bucket_sectors_used(m)) {
 259                                 sectors_not_moved += bucket_sectors_used(m);
 260                                 buckets_not_moved++;
 261                         }
 262                 }
 263                 up_read(&ca->bucket_lock);
 264         }
 265
 266         if (sectors_not_moved && !ret)
 267                 bch_warn_ratelimited(c,
 268                         "copygc finished but %llu/%llu sectors, %llu/%llu buckets not moved (move stats: moved %llu sectors, raced %llu keys, %llu sectors)",
 269                          sectors_not_moved, sectors_to_move,
 270                          buckets_not_moved, buckets_to_move,
 271                          atomic64_read(&move_stats.sectors_moved),
 272                          atomic64_read(&move_stats.keys_raced),
 273                          atomic64_read(&move_stats.sectors_raced));
 274
 275         trace_copygc(c,
 276                      atomic64_read(&move_stats.sectors_moved), sectors_not_moved,
 277                      buckets_to_move, buckets_not_moved);
 278         return 0;
 279 }
 280
 281 /*
 282  * Copygc runs when the amount of fragmented data is above some arbitrary
 283  * threshold:
 284  *
 285  * The threshold at the limit - when the device is full - is the amount of space
 286  * we reserved in bch2_recalc_capacity; we can't have more than that amount of
 287  * disk space stranded due to fragmentation and store everything we have
 288  * promised to store.
 289  *
 290  * But we don't want to be running copygc unnecessarily when the device still
 291  * has plenty of free space - rather, we want copygc to smoothly run every so
 292  * often and continually reduce the amount of fragmented space as the device
 293  * fills up. So, we increase the threshold by half the current free space.
 294  */
 295 unsigned long bch2_copygc_wait_amount(struct bch_fs *c)
 296 {
 297         struct bch_dev *ca;
 298         unsigned dev_idx;
 299         s64 wait = S64_MAX, fragmented_allowed, fragmented;
 300
 301         for_each_rw_member(ca, c, dev_idx) {
 302                 struct bch_dev_usage usage = bch2_dev_usage_read(ca);
 303
 304                 fragmented_allowed = ((__dev_buckets_reclaimable(ca, usage) *
 305                                         ca->mi.bucket_size) >> 1);
 306                 fragmented = usage.d[BCH_DATA_user].fragmented;
 307
 308                 wait = min(wait, max(0LL, fragmented_allowed - fragmented));
 309         }
 310
 311         return wait;
 312 }
 313
 314 static int bch2_copygc_thread(void *arg)
 315 {
 316         struct bch_fs *c = arg;
 317         struct io_clock *clock = &c->io_clock[WRITE];
 318         u64 last, wait;
 319
 320         set_freezable();
 321
 322         while (!kthread_should_stop()) {
 323                 cond_resched();
 324
 325                 if (kthread_wait_freezable(c->copy_gc_enabled))
 326                         break;
 327
 328                 last = atomic64_read(&clock->now);
 329                 wait = bch2_copygc_wait_amount(c);
 330
 331                 if (wait > clock->max_slop) {
 332                         trace_copygc_wait(c, wait, last + wait);
 333                         c->copygc_wait = last + wait;
 334                         bch2_kthread_io_clock_wait(clock, last + wait,
 335                                         MAX_SCHEDULE_TIMEOUT);
 336                         continue;
 337                 }
 338
 339                 c->copygc_wait = 0;
 340
 341                 if (bch2_copygc(c))
 342                         break;
 343         }
 344
 345         return 0;
 346 }
 347
 348 void bch2_copygc_stop(struct bch_fs *c)
 349 {
 350         if (c->copygc_thread) {
 351                 kthread_stop(c->copygc_thread);
 352                 put_task_struct(c->copygc_thread);
 353         }
 354         c->copygc_thread = NULL;
 355 }
 356
 357 int bch2_copygc_start(struct bch_fs *c)
 358 {
 359         struct task_struct *t;
 360
 361         if (c->copygc_thread)
 362                 return 0;
 363
 364         if (c->opts.nochanges)
 365                 return 0;
 366
 367         if (bch2_fs_init_fault("copygc_start"))
 368                 return -ENOMEM;
 369
 370         t = kthread_create(bch2_copygc_thread, c, "bch-copygc/%s", c->name);
 371         if (IS_ERR(t)) {
 372                 bch_err(c, "error creating copygc thread: %li", PTR_ERR(t));
 373                 return PTR_ERR(t);
 374         }
 375
 376         get_task_struct(t);
 377
 378         c->copygc_thread = t;
 379         wake_up_process(c->copygc_thread);
 380
 381         return 0;
 382 }
 383
 384 void bch2_fs_copygc_init(struct bch_fs *c)
 385 {
 386 }