2 * Primary bucket allocation code
4 * Copyright 2012 Google, Inc.
6 * Allocation in bcache is done in terms of buckets:
8 * Each bucket has associated an 8 bit gen; this gen corresponds to the gen in
9 * btree pointers - they must match for the pointer to be considered valid.
11 * Thus (assuming a bucket has no dirty data or metadata in it) we can reuse a
12 * bucket simply by incrementing its gen.
14 * The gens (along with the priorities; it's really the gens are important but
15 * the code is named as if it's the priorities) are written in an arbitrary list
16 * of buckets on disk, with a pointer to them in the journal header.
18 * When we invalidate a bucket, we have to write its new gen to disk and wait
19 * for that write to complete before we use it - otherwise after a crash we
20 * could have pointers that appeared to be good but pointed to data that had
23 * Since the gens and priorities are all stored contiguously on disk, we can
24 * batch this up: We fill up the free_inc list with freshly invalidated buckets,
25 * call prio_write(), and when prio_write() finishes we pull buckets off the
26 * free_inc list and optionally discard them.
28 * free_inc isn't the only freelist - if it was, we'd often to sleep while
29 * priorities and gens were being written before we could allocate. c->free is a
30 * smaller freelist, and buckets on that list are always ready to be used.
32 * If we've got discards enabled, that happens when a bucket moves from the
33 * free_inc list to the free list.
35 * There is another freelist, because sometimes we have buckets that we know
36 * have nothing pointing into them - these we can reuse without waiting for
37 * priorities to be rewritten. These come from freed btree nodes and buckets
38 * that garbage collection discovered no longer had valid keys pointing into
39 * them (because they were overwritten). That's the unused list - buckets on the
40 * unused list move to the free list, optionally being discarded in the process.
42 * It's also important to ensure that gens don't wrap around - with respect to
43 * either the oldest gen in the btree or the gen on disk. This is quite
44 * difficult to do in practice, but we explicitly guard against it anyways - if
45 * a bucket is in danger of wrapping around we simply skip invalidating it that
46 * time around, and we garbage collect or rewrite the priorities sooner than we
47 * would have otherwise.
49 * bch_bucket_alloc() allocates a single bucket from a specific cache.
51 * bch_bucket_alloc_set() allocates one or more buckets from different caches
54 * free_some_buckets() drives all the processes described above. It's called
55 * from bch_bucket_alloc() and a few other places that need to make sure free
58 * invalidate_buckets_(lru|fifo)() find buckets that are available to be
59 * invalidated, and then invalidate them and stick them on the free_inc list -
60 * in either lru or fifo order.
66 #include <linux/blkdev.h>
67 #include <linux/freezer.h>
68 #include <linux/kthread.h>
69 #include <linux/random.h>
70 #include <trace/events/bcache.h>
72 /* Bucket heap / gen */
74 uint8_t bch_inc_gen(struct cache *ca, struct bucket *b)
76 uint8_t ret = ++b->gen;
78 ca->set->need_gc = max(ca->set->need_gc, bucket_gc_gen(b));
79 WARN_ON_ONCE(ca->set->need_gc > BUCKET_GC_GEN_MAX);
81 if (CACHE_SYNC(&ca->set->sb)) {
82 ca->need_save_prio = max(ca->need_save_prio,
84 WARN_ON_ONCE(ca->need_save_prio > BUCKET_DISK_GEN_MAX);
90 void bch_rescale_priorities(struct cache_set *c, int sectors)
94 unsigned next = c->nbuckets * c->sb.bucket_size / 1024;
98 atomic_sub(sectors, &c->rescale);
101 r = atomic_read(&c->rescale);
105 } while (atomic_cmpxchg(&c->rescale, r, r + next) != r);
107 mutex_lock(&c->bucket_lock);
109 c->min_prio = USHRT_MAX;
111 for_each_cache(ca, c, i)
112 for_each_bucket(b, ca)
114 b->prio != BTREE_PRIO &&
115 !atomic_read(&b->pin)) {
117 c->min_prio = min(c->min_prio, b->prio);
120 mutex_unlock(&c->bucket_lock);
125 static inline bool can_inc_bucket_gen(struct bucket *b)
127 return bucket_gc_gen(b) < BUCKET_GC_GEN_MAX &&
128 bucket_disk_gen(b) < BUCKET_DISK_GEN_MAX;
131 bool bch_bucket_add_unused(struct cache *ca, struct bucket *b)
133 BUG_ON(GC_MARK(b) || GC_SECTORS_USED(b));
135 if (fifo_used(&ca->free) > ca->watermark[WATERMARK_MOVINGGC] &&
136 CACHE_REPLACEMENT(&ca->sb) == CACHE_REPLACEMENT_FIFO)
141 if (can_inc_bucket_gen(b) &&
142 fifo_push(&ca->unused, b - ca->buckets)) {
150 static bool can_invalidate_bucket(struct cache *ca, struct bucket *b)
152 return GC_MARK(b) == GC_MARK_RECLAIMABLE &&
153 !atomic_read(&b->pin) &&
154 can_inc_bucket_gen(b);
157 static void invalidate_one_bucket(struct cache *ca, struct bucket *b)
160 b->prio = INITIAL_PRIO;
162 fifo_push(&ca->free_inc, b - ca->buckets);
165 #define bucket_prio(b) \
166 (((unsigned) (b->prio - ca->set->min_prio)) * GC_SECTORS_USED(b))
168 #define bucket_max_cmp(l, r) (bucket_prio(l) < bucket_prio(r))
169 #define bucket_min_cmp(l, r) (bucket_prio(l) > bucket_prio(r))
171 static void invalidate_buckets_lru(struct cache *ca)
178 for_each_bucket(b, ca) {
180 * If we fill up the unused list, if we then return before
181 * adding anything to the free_inc list we'll skip writing
182 * prios/gens and just go back to allocating from the unused
185 if (fifo_full(&ca->unused))
188 if (!can_invalidate_bucket(ca, b))
191 if (!GC_SECTORS_USED(b) &&
192 bch_bucket_add_unused(ca, b))
195 if (!heap_full(&ca->heap))
196 heap_add(&ca->heap, b, bucket_max_cmp);
197 else if (bucket_max_cmp(b, heap_peek(&ca->heap))) {
198 ca->heap.data[0] = b;
199 heap_sift(&ca->heap, 0, bucket_max_cmp);
203 for (i = ca->heap.used / 2 - 1; i >= 0; --i)
204 heap_sift(&ca->heap, i, bucket_min_cmp);
206 while (!fifo_full(&ca->free_inc)) {
207 if (!heap_pop(&ca->heap, b, bucket_min_cmp)) {
209 * We don't want to be calling invalidate_buckets()
210 * multiple times when it can't do anything
212 ca->invalidate_needs_gc = 1;
217 invalidate_one_bucket(ca, b);
221 static void invalidate_buckets_fifo(struct cache *ca)
226 while (!fifo_full(&ca->free_inc)) {
227 if (ca->fifo_last_bucket < ca->sb.first_bucket ||
228 ca->fifo_last_bucket >= ca->sb.nbuckets)
229 ca->fifo_last_bucket = ca->sb.first_bucket;
231 b = ca->buckets + ca->fifo_last_bucket++;
233 if (can_invalidate_bucket(ca, b))
234 invalidate_one_bucket(ca, b);
236 if (++checked >= ca->sb.nbuckets) {
237 ca->invalidate_needs_gc = 1;
244 static void invalidate_buckets_random(struct cache *ca)
249 while (!fifo_full(&ca->free_inc)) {
251 get_random_bytes(&n, sizeof(n));
253 n %= (size_t) (ca->sb.nbuckets - ca->sb.first_bucket);
254 n += ca->sb.first_bucket;
258 if (can_invalidate_bucket(ca, b))
259 invalidate_one_bucket(ca, b);
261 if (++checked >= ca->sb.nbuckets / 2) {
262 ca->invalidate_needs_gc = 1;
269 static void invalidate_buckets(struct cache *ca)
271 if (ca->invalidate_needs_gc)
274 switch (CACHE_REPLACEMENT(&ca->sb)) {
275 case CACHE_REPLACEMENT_LRU:
276 invalidate_buckets_lru(ca);
278 case CACHE_REPLACEMENT_FIFO:
279 invalidate_buckets_fifo(ca);
281 case CACHE_REPLACEMENT_RANDOM:
282 invalidate_buckets_random(ca);
286 trace_bcache_alloc_invalidate(ca);
289 #define allocator_wait(ca, cond) \
292 set_current_state(TASK_INTERRUPTIBLE); \
296 mutex_unlock(&(ca)->set->bucket_lock); \
297 if (kthread_should_stop()) \
302 mutex_lock(&(ca)->set->bucket_lock); \
304 __set_current_state(TASK_RUNNING); \
307 static int bch_allocator_thread(void *arg)
309 struct cache *ca = arg;
311 mutex_lock(&ca->set->bucket_lock);
315 * First, we pull buckets off of the unused and free_inc lists,
316 * possibly issue discards to them, then we add the bucket to
322 if ((!atomic_read(&ca->set->prio_blocked) ||
323 !CACHE_SYNC(&ca->set->sb)) &&
324 !fifo_empty(&ca->unused))
325 fifo_pop(&ca->unused, bucket);
326 else if (!fifo_empty(&ca->free_inc))
327 fifo_pop(&ca->free_inc, bucket);
332 mutex_unlock(&ca->set->bucket_lock);
333 blkdev_issue_discard(ca->bdev,
334 bucket_to_sector(ca->set, bucket),
335 ca->sb.block_size, GFP_KERNEL, 0);
336 mutex_lock(&ca->set->bucket_lock);
339 allocator_wait(ca, !fifo_full(&ca->free));
341 fifo_push(&ca->free, bucket);
342 wake_up(&ca->set->bucket_wait);
346 * We've run out of free buckets, we need to find some buckets
347 * we can invalidate. First, invalidate them in memory and add
348 * them to the free_inc list:
351 allocator_wait(ca, ca->set->gc_mark_valid &&
352 (ca->need_save_prio > 64 ||
353 !ca->invalidate_needs_gc));
354 invalidate_buckets(ca);
357 * Now, we write their new gens to disk so we can start writing
360 allocator_wait(ca, !atomic_read(&ca->set->prio_blocked));
361 if (CACHE_SYNC(&ca->set->sb) &&
362 (!fifo_empty(&ca->free_inc) ||
363 ca->need_save_prio > 64))
368 long bch_bucket_alloc(struct cache *ca, unsigned watermark, bool wait)
375 if (fifo_used(&ca->free) > ca->watermark[watermark]) {
376 fifo_pop(&ca->free, r);
384 if (fifo_used(&ca->free) > ca->watermark[watermark]) {
385 fifo_pop(&ca->free, r);
389 prepare_to_wait(&ca->set->bucket_wait, &w,
390 TASK_UNINTERRUPTIBLE);
392 mutex_unlock(&ca->set->bucket_lock);
394 mutex_lock(&ca->set->bucket_lock);
397 finish_wait(&ca->set->bucket_wait, &w);
399 wake_up_process(ca->alloc_thread);
401 if (expensive_debug_checks(ca->set)) {
405 for (iter = 0; iter < prio_buckets(ca) * 2; iter++)
406 BUG_ON(ca->prio_buckets[iter] == (uint64_t) r);
408 fifo_for_each(i, &ca->free, iter)
410 fifo_for_each(i, &ca->free_inc, iter)
412 fifo_for_each(i, &ca->unused, iter)
418 BUG_ON(atomic_read(&b->pin) != 1);
420 SET_GC_SECTORS_USED(b, ca->sb.bucket_size);
422 if (watermark <= WATERMARK_METADATA) {
423 SET_GC_MARK(b, GC_MARK_METADATA);
424 b->prio = BTREE_PRIO;
426 SET_GC_MARK(b, GC_MARK_RECLAIMABLE);
427 b->prio = INITIAL_PRIO;
433 void bch_bucket_free(struct cache_set *c, struct bkey *k)
437 for (i = 0; i < KEY_PTRS(k); i++) {
438 struct bucket *b = PTR_BUCKET(c, k, i);
440 SET_GC_MARK(b, GC_MARK_RECLAIMABLE);
441 SET_GC_SECTORS_USED(b, 0);
442 bch_bucket_add_unused(PTR_CACHE(c, k, i), b);
446 int __bch_bucket_alloc_set(struct cache_set *c, unsigned watermark,
447 struct bkey *k, int n, bool wait)
451 lockdep_assert_held(&c->bucket_lock);
452 BUG_ON(!n || n > c->caches_loaded || n > 8);
456 /* sort by free space/prio of oldest data in caches */
458 for (i = 0; i < n; i++) {
459 struct cache *ca = c->cache_by_alloc[i];
460 long b = bch_bucket_alloc(ca, watermark, wait);
465 k->ptr[i] = PTR(ca->buckets[b].gen,
466 bucket_to_sector(c, b),
469 SET_KEY_PTRS(k, i + 1);
474 bch_bucket_free(c, k);
479 int bch_bucket_alloc_set(struct cache_set *c, unsigned watermark,
480 struct bkey *k, int n, bool wait)
483 mutex_lock(&c->bucket_lock);
484 ret = __bch_bucket_alloc_set(c, watermark, k, n, wait);
485 mutex_unlock(&c->bucket_lock);
489 /* Sector allocator */
492 struct list_head list;
493 unsigned last_write_point;
494 unsigned sectors_free;
499 * We keep multiple buckets open for writes, and try to segregate different
500 * write streams for better cache utilization: first we look for a bucket where
501 * the last write to it was sequential with the current write, and failing that
502 * we look for a bucket that was last used by the same task.
504 * The ideas is if you've got multiple tasks pulling data into the cache at the
505 * same time, you'll get better cache utilization if you try to segregate their
506 * data and preserve locality.
508 * For example, say you've starting Firefox at the same time you're copying a
509 * bunch of files. Firefox will likely end up being fairly hot and stay in the
510 * cache awhile, but the data you copied might not be; if you wrote all that
511 * data to the same buckets it'd get invalidated at the same time.
513 * Both of those tasks will be doing fairly random IO so we can't rely on
514 * detecting sequential IO to segregate their data, but going off of the task
515 * should be a sane heuristic.
517 static struct open_bucket *pick_data_bucket(struct cache_set *c,
518 const struct bkey *search,
519 unsigned write_point,
522 struct open_bucket *ret, *ret_task = NULL;
524 list_for_each_entry_reverse(ret, &c->data_buckets, list)
525 if (!bkey_cmp(&ret->key, search))
527 else if (ret->last_write_point == write_point)
530 ret = ret_task ?: list_first_entry(&c->data_buckets,
531 struct open_bucket, list);
533 if (!ret->sectors_free && KEY_PTRS(alloc)) {
534 ret->sectors_free = c->sb.bucket_size;
535 bkey_copy(&ret->key, alloc);
539 if (!ret->sectors_free)
546 * Allocates some space in the cache to write to, and k to point to the newly
547 * allocated space, and updates KEY_SIZE(k) and KEY_OFFSET(k) (to point to the
548 * end of the newly allocated space).
550 * May allocate fewer sectors than @sectors, KEY_SIZE(k) indicates how many
551 * sectors were actually allocated.
553 * If s->writeback is true, will not fail.
555 bool bch_alloc_sectors(struct cache_set *c, struct bkey *k, unsigned sectors,
556 unsigned write_point, unsigned write_prio, bool wait)
558 struct open_bucket *b;
559 BKEY_PADDED(key) alloc;
563 * We might have to allocate a new bucket, which we can't do with a
564 * spinlock held. So if we have to allocate, we drop the lock, allocate
565 * and then retry. KEY_PTRS() indicates whether alloc points to
566 * allocated bucket(s).
569 bkey_init(&alloc.key);
570 spin_lock(&c->data_bucket_lock);
572 while (!(b = pick_data_bucket(c, k, write_point, &alloc.key))) {
573 unsigned watermark = write_prio
577 spin_unlock(&c->data_bucket_lock);
579 if (bch_bucket_alloc_set(c, watermark, &alloc.key, 1, wait))
582 spin_lock(&c->data_bucket_lock);
586 * If we had to allocate, we might race and not need to allocate the
587 * second time we call find_data_bucket(). If we allocated a bucket but
588 * didn't use it, drop the refcount bch_bucket_alloc_set() took:
590 if (KEY_PTRS(&alloc.key))
591 bkey_put(c, &alloc.key);
593 for (i = 0; i < KEY_PTRS(&b->key); i++)
594 EBUG_ON(ptr_stale(c, &b->key, i));
596 /* Set up the pointer to the space we're allocating: */
598 for (i = 0; i < KEY_PTRS(&b->key); i++)
599 k->ptr[i] = b->key.ptr[i];
601 sectors = min(sectors, b->sectors_free);
603 SET_KEY_OFFSET(k, KEY_OFFSET(k) + sectors);
604 SET_KEY_SIZE(k, sectors);
605 SET_KEY_PTRS(k, KEY_PTRS(&b->key));
608 * Move b to the end of the lru, and keep track of what this bucket was
611 list_move_tail(&b->list, &c->data_buckets);
612 bkey_copy_key(&b->key, k);
613 b->last_write_point = write_point;
615 b->sectors_free -= sectors;
617 for (i = 0; i < KEY_PTRS(&b->key); i++) {
618 SET_PTR_OFFSET(&b->key, i, PTR_OFFSET(&b->key, i) + sectors);
620 atomic_long_add(sectors,
621 &PTR_CACHE(c, &b->key, i)->sectors_written);
624 if (b->sectors_free < c->sb.block_size)
628 * k takes refcounts on the buckets it points to until it's inserted
629 * into the btree, but if we're done with this bucket we just transfer
630 * get_data_bucket()'s refcount.
633 for (i = 0; i < KEY_PTRS(&b->key); i++)
634 atomic_inc(&PTR_BUCKET(c, &b->key, i)->pin);
636 spin_unlock(&c->data_bucket_lock);
642 void bch_open_buckets_free(struct cache_set *c)
644 struct open_bucket *b;
646 while (!list_empty(&c->data_buckets)) {
647 b = list_first_entry(&c->data_buckets,
648 struct open_bucket, list);
654 int bch_open_buckets_alloc(struct cache_set *c)
658 spin_lock_init(&c->data_bucket_lock);
660 for (i = 0; i < 6; i++) {
661 struct open_bucket *b = kzalloc(sizeof(*b), GFP_KERNEL);
665 list_add(&b->list, &c->data_buckets);
671 int bch_cache_allocator_start(struct cache *ca)
673 struct task_struct *k = kthread_run(bch_allocator_thread,
674 ca, "bcache_allocator");
678 ca->alloc_thread = k;
682 int bch_cache_allocator_init(struct cache *ca)
686 * Prio/gen writes first
687 * Then 8 for btree allocations
688 * Then half for the moving garbage collector
691 ca->watermark[WATERMARK_PRIO] = 0;
693 ca->watermark[WATERMARK_METADATA] = prio_buckets(ca);
695 ca->watermark[WATERMARK_MOVINGGC] = 8 +
696 ca->watermark[WATERMARK_METADATA];
698 ca->watermark[WATERMARK_NONE] = ca->free.size / 2 +
699 ca->watermark[WATERMARK_MOVINGGC];