drivers/md/bcache/alloc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Primary bucket allocation code
   4  *
   5  * Copyright 2012 Google, Inc.
   6  *
   7  * Allocation in bcache is done in terms of buckets:
   8  *
   9  * Each bucket has associated an 8 bit gen; this gen corresponds to the gen in
  10  * btree pointers - they must match for the pointer to be considered valid.
  11  *
  12  * Thus (assuming a bucket has no dirty data or metadata in it) we can reuse a
  13  * bucket simply by incrementing its gen.
  14  *
  15  * The gens (along with the priorities; it's really the gens are important but
  16  * the code is named as if it's the priorities) are written in an arbitrary list
  17  * of buckets on disk, with a pointer to them in the journal header.
  18  *
  19  * When we invalidate a bucket, we have to write its new gen to disk and wait
  20  * for that write to complete before we use it - otherwise after a crash we
  21  * could have pointers that appeared to be good but pointed to data that had
  22  * been overwritten.
  23  *
  24  * Since the gens and priorities are all stored contiguously on disk, we can
  25  * batch this up: We fill up the free_inc list with freshly invalidated buckets,
  26  * call prio_write(), and when prio_write() finishes we pull buckets off the
  27  * free_inc list and optionally discard them.
  28  *
  29  * free_inc isn't the only freelist - if it was, we'd often to sleep while
  30  * priorities and gens were being written before we could allocate. c->free is a
  31  * smaller freelist, and buckets on that list are always ready to be used.
  32  *
  33  * If we've got discards enabled, that happens when a bucket moves from the
  34  * free_inc list to the free list.
  35  *
  36  * There is another freelist, because sometimes we have buckets that we know
  37  * have nothing pointing into them - these we can reuse without waiting for
  38  * priorities to be rewritten. These come from freed btree nodes and buckets
  39  * that garbage collection discovered no longer had valid keys pointing into
  40  * them (because they were overwritten). That's the unused list - buckets on the
  41  * unused list move to the free list, optionally being discarded in the process.
  42  *
  43  * It's also important to ensure that gens don't wrap around - with respect to
  44  * either the oldest gen in the btree or the gen on disk. This is quite
  45  * difficult to do in practice, but we explicitly guard against it anyways - if
  46  * a bucket is in danger of wrapping around we simply skip invalidating it that
  47  * time around, and we garbage collect or rewrite the priorities sooner than we
  48  * would have otherwise.
  49  *
  50  * bch_bucket_alloc() allocates a single bucket from a specific cache.
  51  *
  52  * bch_bucket_alloc_set() allocates one or more buckets from different caches
  53  * out of a cache set.
  54  *
  55  * free_some_buckets() drives all the processes described above. It's called
  56  * from bch_bucket_alloc() and a few other places that need to make sure free
  57  * buckets are ready.
  58  *
  59  * invalidate_buckets_(lru|fifo)() find buckets that are available to be
  60  * invalidated, and then invalidate them and stick them on the free_inc list -
  61  * in either lru or fifo order.
  62  */
  63
  64 #include "bcache.h"
  65 #include "btree.h"
  66
  67 #include <linux/blkdev.h>
  68 #include <linux/kthread.h>
  69 #include <linux/random.h>
  70 #include <trace/events/bcache.h>
  71
  72 #define MAX_OPEN_BUCKETS 128
  73
  74 /* Bucket heap / gen */
  75
  76 uint8_t bch_inc_gen(struct cache *ca, struct bucket *b)
  77 {
  78         uint8_t ret = ++b->gen;
  79
  80         ca->set->need_gc = max(ca->set->need_gc, bucket_gc_gen(b));
  81         WARN_ON_ONCE(ca->set->need_gc > BUCKET_GC_GEN_MAX);
  82
  83         return ret;
  84 }
  85
  86 void bch_rescale_priorities(struct cache_set *c, int sectors)
  87 {
  88         struct cache *ca;
  89         struct bucket *b;
  90         unsigned next = c->nbuckets * c->sb.bucket_size / 1024;
  91         unsigned i;
  92         int r;
  93
  94         atomic_sub(sectors, &c->rescale);
  95
  96         do {
  97                 r = atomic_read(&c->rescale);
  98
  99                 if (r >= 0)
 100                         return;
 101         } while (atomic_cmpxchg(&c->rescale, r, r + next) != r);
 102
 103         mutex_lock(&c->bucket_lock);
 104
 105         c->min_prio = USHRT_MAX;
 106
 107         for_each_cache(ca, c, i)
 108                 for_each_bucket(b, ca)
 109                         if (b->prio &&
 110                             b->prio != BTREE_PRIO &&
 111                             !atomic_read(&b->pin)) {
 112                                 b->prio--;
 113                                 c->min_prio = min(c->min_prio, b->prio);
 114                         }
 115
 116         mutex_unlock(&c->bucket_lock);
 117 }
 118
 119 /*
 120  * Background allocation thread: scans for buckets to be invalidated,
 121  * invalidates them, rewrites prios/gens (marking them as invalidated on disk),
 122  * then optionally issues discard commands to the newly free buckets, then puts
 123  * them on the various freelists.
 124  */
 125
 126 static inline bool can_inc_bucket_gen(struct bucket *b)
 127 {
 128         return bucket_gc_gen(b) < BUCKET_GC_GEN_MAX;
 129 }
 130
 131 bool bch_can_invalidate_bucket(struct cache *ca, struct bucket *b)
 132 {
 133         BUG_ON(!ca->set->gc_mark_valid);
 134
 135         return (!GC_MARK(b) ||
 136                 GC_MARK(b) == GC_MARK_RECLAIMABLE) &&
 137                 !atomic_read(&b->pin) &&
 138                 can_inc_bucket_gen(b);
 139 }
 140
 141 void __bch_invalidate_one_bucket(struct cache *ca, struct bucket *b)
 142 {
 143         lockdep_assert_held(&ca->set->bucket_lock);
 144         BUG_ON(GC_MARK(b) && GC_MARK(b) != GC_MARK_RECLAIMABLE);
 145
 146         if (GC_SECTORS_USED(b))
 147                 trace_bcache_invalidate(ca, b - ca->buckets);
 148
 149         bch_inc_gen(ca, b);
 150         b->prio = INITIAL_PRIO;
 151         atomic_inc(&b->pin);
 152 }
 153
 154 static void bch_invalidate_one_bucket(struct cache *ca, struct bucket *b)
 155 {
 156         __bch_invalidate_one_bucket(ca, b);
 157
 158         fifo_push(&ca->free_inc, b - ca->buckets);
 159 }
 160
 161 /*
 162  * Determines what order we're going to reuse buckets, smallest bucket_prio()
 163  * first: we also take into account the number of sectors of live data in that
 164  * bucket, and in order for that multiply to make sense we have to scale bucket
 165  *
 166  * Thus, we scale the bucket priorities so that the bucket with the smallest
 167  * prio is worth 1/8th of what INITIAL_PRIO is worth.
 168  */
 169
 170 #define bucket_prio(b)                                                  \
 171 ({                                                                      \
 172         unsigned min_prio = (INITIAL_PRIO - ca->set->min_prio) / 8;     \
 173                                                                         \
 174         (b->prio - ca->set->min_prio + min_prio) * GC_SECTORS_USED(b);  \
 175 })
 176
 177 #define bucket_max_cmp(l, r)    (bucket_prio(l) < bucket_prio(r))
 178 #define bucket_min_cmp(l, r)    (bucket_prio(l) > bucket_prio(r))
 179
 180 static void invalidate_buckets_lru(struct cache *ca)
 181 {
 182         struct bucket *b;
 183         ssize_t i;
 184
 185         ca->heap.used = 0;
 186
 187         for_each_bucket(b, ca) {
 188                 if (!bch_can_invalidate_bucket(ca, b))
 189                         continue;
 190
 191                 if (!heap_full(&ca->heap))
 192                         heap_add(&ca->heap, b, bucket_max_cmp);
 193                 else if (bucket_max_cmp(b, heap_peek(&ca->heap))) {
 194                         ca->heap.data[0] = b;
 195                         heap_sift(&ca->heap, 0, bucket_max_cmp);
 196                 }
 197         }
 198
 199         for (i = ca->heap.used / 2 - 1; i >= 0; --i)
 200                 heap_sift(&ca->heap, i, bucket_min_cmp);
 201
 202         while (!fifo_full(&ca->free_inc)) {
 203                 if (!heap_pop(&ca->heap, b, bucket_min_cmp)) {
 204                         /*
 205                          * We don't want to be calling invalidate_buckets()
 206                          * multiple times when it can't do anything
 207                          */
 208                         ca->invalidate_needs_gc = 1;
 209                         wake_up_gc(ca->set);
 210                         return;
 211                 }
 212
 213                 bch_invalidate_one_bucket(ca, b);
 214         }
 215 }
 216
 217 static void invalidate_buckets_fifo(struct cache *ca)
 218 {
 219         struct bucket *b;
 220         size_t checked = 0;
 221
 222         while (!fifo_full(&ca->free_inc)) {
 223                 if (ca->fifo_last_bucket <  ca->sb.first_bucket ||
 224                     ca->fifo_last_bucket >= ca->sb.nbuckets)
 225                         ca->fifo_last_bucket = ca->sb.first_bucket;
 226
 227                 b = ca->buckets + ca->fifo_last_bucket++;
 228
 229                 if (bch_can_invalidate_bucket(ca, b))
 230                         bch_invalidate_one_bucket(ca, b);
 231
 232                 if (++checked >= ca->sb.nbuckets) {
 233                         ca->invalidate_needs_gc = 1;
 234                         wake_up_gc(ca->set);
 235                         return;
 236                 }
 237         }
 238 }
 239
 240 static void invalidate_buckets_random(struct cache *ca)
 241 {
 242         struct bucket *b;
 243         size_t checked = 0;
 244
 245         while (!fifo_full(&ca->free_inc)) {
 246                 size_t n;
 247                 get_random_bytes(&n, sizeof(n));
 248
 249                 n %= (size_t) (ca->sb.nbuckets - ca->sb.first_bucket);
 250                 n += ca->sb.first_bucket;
 251
 252                 b = ca->buckets + n;
 253
 254                 if (bch_can_invalidate_bucket(ca, b))
 255                         bch_invalidate_one_bucket(ca, b);
 256
 257                 if (++checked >= ca->sb.nbuckets / 2) {
 258                         ca->invalidate_needs_gc = 1;
 259                         wake_up_gc(ca->set);
 260                         return;
 261                 }
 262         }
 263 }
 264
 265 static void invalidate_buckets(struct cache *ca)
 266 {
 267         BUG_ON(ca->invalidate_needs_gc);
 268
 269         switch (CACHE_REPLACEMENT(&ca->sb)) {
 270         case CACHE_REPLACEMENT_LRU:
 271                 invalidate_buckets_lru(ca);
 272                 break;
 273         case CACHE_REPLACEMENT_FIFO:
 274                 invalidate_buckets_fifo(ca);
 275                 break;
 276         case CACHE_REPLACEMENT_RANDOM:
 277                 invalidate_buckets_random(ca);
 278                 break;
 279         }
 280 }
 281
 282 #define allocator_wait(ca, cond)                                        \
 283 do {                                                                    \
 284         while (1) {                                                     \
 285                 set_current_state(TASK_INTERRUPTIBLE);                  \
 286                 if (cond)                                               \
 287                         break;                                          \
 288                                                                         \
 289                 mutex_unlock(&(ca)->set->bucket_lock);                  \
 290                 if (kthread_should_stop()) {                            \
 291                         set_current_state(TASK_RUNNING);                \
 292                         return 0;                                       \
 293                 }                                                       \
 294                                                                         \
 295                 schedule();                                             \
 296                 mutex_lock(&(ca)->set->bucket_lock);                    \
 297         }                                                               \
 298         __set_current_state(TASK_RUNNING);                              \
 299 } while (0)
 300
 301 static int bch_allocator_push(struct cache *ca, long bucket)
 302 {
 303         unsigned i;
 304
 305         /* Prios/gens are actually the most important reserve */
 306         if (fifo_push(&ca->free[RESERVE_PRIO], bucket))
 307                 return true;
 308
 309         for (i = 0; i < RESERVE_NR; i++)
 310                 if (fifo_push(&ca->free[i], bucket))
 311                         return true;
 312
 313         return false;
 314 }
 315
 316 static int bch_allocator_thread(void *arg)
 317 {
 318         struct cache *ca = arg;
 319
 320         mutex_lock(&ca->set->bucket_lock);
 321
 322         while (1) {
 323                 /*
 324                  * First, we pull buckets off of the unused and free_inc lists,
 325                  * possibly issue discards to them, then we add the bucket to
 326                  * the free list:
 327                  */
 328                 while (1) {
 329                         long bucket;
 330
 331                         if (!fifo_pop(&ca->free_inc, bucket))
 332                                 break;
 333
 334                         if (ca->discard) {
 335                                 mutex_unlock(&ca->set->bucket_lock);
 336                                 blkdev_issue_discard(ca->bdev,
 337                                         bucket_to_sector(ca->set, bucket),
 338                                         ca->sb.bucket_size, GFP_KERNEL, 0);
 339                                 mutex_lock(&ca->set->bucket_lock);
 340                         }
 341
 342                         allocator_wait(ca, bch_allocator_push(ca, bucket));
 343                         wake_up(&ca->set->btree_cache_wait);
 344                         wake_up(&ca->set->bucket_wait);
 345                 }
 346
 347                 /*
 348                  * We've run out of free buckets, we need to find some buckets
 349                  * we can invalidate. First, invalidate them in memory and add
 350                  * them to the free_inc list:
 351                  */
 352
 353 retry_invalidate:
 354                 allocator_wait(ca, ca->set->gc_mark_valid &&
 355                                !ca->invalidate_needs_gc);
 356                 invalidate_buckets(ca);
 357
 358                 /*
 359                  * Now, we write their new gens to disk so we can start writing
 360                  * new stuff to them:
 361                  */
 362                 allocator_wait(ca, !atomic_read(&ca->set->prio_blocked));
 363                 if (CACHE_SYNC(&ca->set->sb)) {
 364                         /*
 365                          * This could deadlock if an allocation with a btree
 366                          * node locked ever blocked - having the btree node
 367                          * locked would block garbage collection, but here we're
 368                          * waiting on garbage collection before we invalidate
 369                          * and free anything.
 370                          *
 371                          * But this should be safe since the btree code always
 372                          * uses btree_check_reserve() before allocating now, and
 373                          * if it fails it blocks without btree nodes locked.
 374                          */
 375                         if (!fifo_full(&ca->free_inc))
 376                                 goto retry_invalidate;
 377
 378                         bch_prio_write(ca);
 379                 }
 380         }
 381 }
 382
 383 /* Allocation */
 384
 385 long bch_bucket_alloc(struct cache *ca, unsigned reserve, bool wait)
 386 {
 387         DEFINE_WAIT(w);
 388         struct bucket *b;
 389         long r;
 390
 391         /* fastpath */
 392         if (fifo_pop(&ca->free[RESERVE_NONE], r) ||
 393             fifo_pop(&ca->free[reserve], r))
 394                 goto out;
 395
 396         if (!wait) {
 397                 trace_bcache_alloc_fail(ca, reserve);
 398                 return -1;
 399         }
 400
 401         do {
 402                 prepare_to_wait(&ca->set->bucket_wait, &w,
 403                                 TASK_UNINTERRUPTIBLE);
 404
 405                 mutex_unlock(&ca->set->bucket_lock);
 406                 schedule();
 407                 mutex_lock(&ca->set->bucket_lock);
 408         } while (!fifo_pop(&ca->free[RESERVE_NONE], r) &&
 409                  !fifo_pop(&ca->free[reserve], r));
 410
 411         finish_wait(&ca->set->bucket_wait, &w);
 412 out:
 413         if (ca->alloc_thread)
 414                 wake_up_process(ca->alloc_thread);
 415
 416         trace_bcache_alloc(ca, reserve);
 417
 418         if (expensive_debug_checks(ca->set)) {
 419                 size_t iter;
 420                 long i;
 421                 unsigned j;
 422
 423                 for (iter = 0; iter < prio_buckets(ca) * 2; iter++)
 424                         BUG_ON(ca->prio_buckets[iter] == (uint64_t) r);
 425
 426                 for (j = 0; j < RESERVE_NR; j++)
 427                         fifo_for_each(i, &ca->free[j], iter)
 428                                 BUG_ON(i == r);
 429                 fifo_for_each(i, &ca->free_inc, iter)
 430                         BUG_ON(i == r);
 431         }
 432
 433         b = ca->buckets + r;
 434
 435         BUG_ON(atomic_read(&b->pin) != 1);
 436
 437         SET_GC_SECTORS_USED(b, ca->sb.bucket_size);
 438
 439         if (reserve <= RESERVE_PRIO) {
 440                 SET_GC_MARK(b, GC_MARK_METADATA);
 441                 SET_GC_MOVE(b, 0);
 442                 b->prio = BTREE_PRIO;
 443         } else {
 444                 SET_GC_MARK(b, GC_MARK_RECLAIMABLE);
 445                 SET_GC_MOVE(b, 0);
 446                 b->prio = INITIAL_PRIO;
 447         }
 448
 449         return r;
 450 }
 451
 452 void __bch_bucket_free(struct cache *ca, struct bucket *b)
 453 {
 454         SET_GC_MARK(b, 0);
 455         SET_GC_SECTORS_USED(b, 0);
 456 }
 457
 458 void bch_bucket_free(struct cache_set *c, struct bkey *k)
 459 {
 460         unsigned i;
 461
 462         for (i = 0; i < KEY_PTRS(k); i++)
 463                 __bch_bucket_free(PTR_CACHE(c, k, i),
 464                                   PTR_BUCKET(c, k, i));
 465 }
 466
 467 int __bch_bucket_alloc_set(struct cache_set *c, unsigned reserve,
 468                            struct bkey *k, int n, bool wait)
 469 {
 470         int i;
 471
 472         lockdep_assert_held(&c->bucket_lock);
 473         BUG_ON(!n || n > c->caches_loaded || n > 8);
 474
 475         bkey_init(k);
 476
 477         /* sort by free space/prio of oldest data in caches */
 478
 479         for (i = 0; i < n; i++) {
 480                 struct cache *ca = c->cache_by_alloc[i];
 481                 long b = bch_bucket_alloc(ca, reserve, wait);
 482
 483                 if (b == -1)
 484                         goto err;
 485
 486                 k->ptr[i] = MAKE_PTR(ca->buckets[b].gen,
 487                                 bucket_to_sector(c, b),
 488                                 ca->sb.nr_this_dev);
 489
 490                 SET_KEY_PTRS(k, i + 1);
 491         }
 492
 493         return 0;
 494 err:
 495         bch_bucket_free(c, k);
 496         bkey_put(c, k);
 497         return -1;
 498 }
 499
 500 int bch_bucket_alloc_set(struct cache_set *c, unsigned reserve,
 501                          struct bkey *k, int n, bool wait)
 502 {
 503         int ret;
 504         mutex_lock(&c->bucket_lock);
 505         ret = __bch_bucket_alloc_set(c, reserve, k, n, wait);
 506         mutex_unlock(&c->bucket_lock);
 507         return ret;
 508 }
 509
 510 /* Sector allocator */
 511
 512 struct open_bucket {
 513         struct list_head        list;
 514         unsigned                last_write_point;
 515         unsigned                sectors_free;
 516         BKEY_PADDED(key);
 517 };
 518
 519 /*
 520  * We keep multiple buckets open for writes, and try to segregate different
 521  * write streams for better cache utilization: first we try to segregate flash
 522  * only volume write streams from cached devices, secondly we look for a bucket
 523  * where the last write to it was sequential with the current write, and
 524  * failing that we look for a bucket that was last used by the same task.
 525  *
 526  * The ideas is if you've got multiple tasks pulling data into the cache at the
 527  * same time, you'll get better cache utilization if you try to segregate their
 528  * data and preserve locality.
 529  *
 530  * For example, dirty sectors of flash only volume is not reclaimable, if their
 531  * dirty sectors mixed with dirty sectors of cached device, such buckets will
 532  * be marked as dirty and won't be reclaimed, though the dirty data of cached
 533  * device have been written back to backend device.
 534  *
 535  * And say you've starting Firefox at the same time you're copying a
 536  * bunch of files. Firefox will likely end up being fairly hot and stay in the
 537  * cache awhile, but the data you copied might not be; if you wrote all that
 538  * data to the same buckets it'd get invalidated at the same time.
 539  *
 540  * Both of those tasks will be doing fairly random IO so we can't rely on
 541  * detecting sequential IO to segregate their data, but going off of the task
 542  * should be a sane heuristic.
 543  */
 544 static struct open_bucket *pick_data_bucket(struct cache_set *c,
 545                                             const struct bkey *search,
 546                                             unsigned write_point,
 547                                             struct bkey *alloc)
 548 {
 549         struct open_bucket *ret, *ret_task = NULL;
 550
 551         list_for_each_entry_reverse(ret, &c->data_buckets, list)
 552                 if (UUID_FLASH_ONLY(&c->uuids[KEY_INODE(&ret->key)]) !=
 553                     UUID_FLASH_ONLY(&c->uuids[KEY_INODE(search)]))
 554                         continue;
 555                 else if (!bkey_cmp(&ret->key, search))
 556                         goto found;
 557                 else if (ret->last_write_point == write_point)
 558                         ret_task = ret;
 559
 560         ret = ret_task ?: list_first_entry(&c->data_buckets,
 561                                            struct open_bucket, list);
 562 found:
 563         if (!ret->sectors_free && KEY_PTRS(alloc)) {
 564                 ret->sectors_free = c->sb.bucket_size;
 565                 bkey_copy(&ret->key, alloc);
 566                 bkey_init(alloc);
 567         }
 568
 569         if (!ret->sectors_free)
 570                 ret = NULL;
 571
 572         return ret;
 573 }
 574
 575 /*
 576  * Allocates some space in the cache to write to, and k to point to the newly
 577  * allocated space, and updates KEY_SIZE(k) and KEY_OFFSET(k) (to point to the
 578  * end of the newly allocated space).
 579  *
 580  * May allocate fewer sectors than @sectors, KEY_SIZE(k) indicates how many
 581  * sectors were actually allocated.
 582  *
 583  * If s->writeback is true, will not fail.
 584  */
 585 bool bch_alloc_sectors(struct cache_set *c, struct bkey *k, unsigned sectors,
 586                        unsigned write_point, unsigned write_prio, bool wait)
 587 {
 588         struct open_bucket *b;
 589         BKEY_PADDED(key) alloc;
 590         unsigned i;
 591
 592         /*
 593          * We might have to allocate a new bucket, which we can't do with a
 594          * spinlock held. So if we have to allocate, we drop the lock, allocate
 595          * and then retry. KEY_PTRS() indicates whether alloc points to
 596          * allocated bucket(s).
 597          */
 598
 599         bkey_init(&alloc.key);
 600         spin_lock(&c->data_bucket_lock);
 601
 602         while (!(b = pick_data_bucket(c, k, write_point, &alloc.key))) {
 603                 unsigned watermark = write_prio
 604                         ? RESERVE_MOVINGGC
 605                         : RESERVE_NONE;
 606
 607                 spin_unlock(&c->data_bucket_lock);
 608
 609                 if (bch_bucket_alloc_set(c, watermark, &alloc.key, 1, wait))
 610                         return false;
 611
 612                 spin_lock(&c->data_bucket_lock);
 613         }
 614
 615         /*
 616          * If we had to allocate, we might race and not need to allocate the
 617          * second time we call find_data_bucket(). If we allocated a bucket but
 618          * didn't use it, drop the refcount bch_bucket_alloc_set() took:
 619          */
 620         if (KEY_PTRS(&alloc.key))
 621                 bkey_put(c, &alloc.key);
 622
 623         for (i = 0; i < KEY_PTRS(&b->key); i++)
 624                 EBUG_ON(ptr_stale(c, &b->key, i));
 625
 626         /* Set up the pointer to the space we're allocating: */
 627
 628         for (i = 0; i < KEY_PTRS(&b->key); i++)
 629                 k->ptr[i] = b->key.ptr[i];
 630
 631         sectors = min(sectors, b->sectors_free);
 632
 633         SET_KEY_OFFSET(k, KEY_OFFSET(k) + sectors);
 634         SET_KEY_SIZE(k, sectors);
 635         SET_KEY_PTRS(k, KEY_PTRS(&b->key));
 636
 637         /*
 638          * Move b to the end of the lru, and keep track of what this bucket was
 639          * last used for:
 640          */
 641         list_move_tail(&b->list, &c->data_buckets);
 642         bkey_copy_key(&b->key, k);
 643         b->last_write_point = write_point;
 644
 645         b->sectors_free -= sectors;
 646
 647         for (i = 0; i < KEY_PTRS(&b->key); i++) {
 648                 SET_PTR_OFFSET(&b->key, i, PTR_OFFSET(&b->key, i) + sectors);
 649
 650                 atomic_long_add(sectors,
 651                                 &PTR_CACHE(c, &b->key, i)->sectors_written);
 652         }
 653
 654         if (b->sectors_free < c->sb.block_size)
 655                 b->sectors_free = 0;
 656
 657         /*
 658          * k takes refcounts on the buckets it points to until it's inserted
 659          * into the btree, but if we're done with this bucket we just transfer
 660          * get_data_bucket()'s refcount.
 661          */
 662         if (b->sectors_free)
 663                 for (i = 0; i < KEY_PTRS(&b->key); i++)
 664                         atomic_inc(&PTR_BUCKET(c, &b->key, i)->pin);
 665
 666         spin_unlock(&c->data_bucket_lock);
 667         return true;
 668 }
 669
 670 /* Init */
 671
 672 void bch_open_buckets_free(struct cache_set *c)
 673 {
 674         struct open_bucket *b;
 675
 676         while (!list_empty(&c->data_buckets)) {
 677                 b = list_first_entry(&c->data_buckets,
 678                                      struct open_bucket, list);
 679                 list_del(&b->list);
 680                 kfree(b);
 681         }
 682 }
 683
 684 int bch_open_buckets_alloc(struct cache_set *c)
 685 {
 686         int i;
 687
 688         spin_lock_init(&c->data_bucket_lock);
 689
 690         for (i = 0; i < MAX_OPEN_BUCKETS; i++) {
 691                 struct open_bucket *b = kzalloc(sizeof(*b), GFP_KERNEL);
 692                 if (!b)
 693                         return -ENOMEM;
 694
 695                 list_add(&b->list, &c->data_buckets);
 696         }
 697
 698         return 0;
 699 }
 700
 701 int bch_cache_allocator_start(struct cache *ca)
 702 {
 703         struct task_struct *k = kthread_run(bch_allocator_thread,
 704                                             ca, "bcache_allocator");
 705         if (IS_ERR(k))
 706                 return PTR_ERR(k);
 707
 708         ca->alloc_thread = k;
 709         return 0;
 710 }