| /* SPDX-License-Identifier: GPL-2.0 */ |
| #ifndef _BCACHE_JOURNAL_H |
| #define _BCACHE_JOURNAL_H |
| |
| /* |
| * THE JOURNAL: |
| * |
| * The journal is treated as a circular buffer of buckets - a journal entry |
| * never spans two buckets. This means (not implemented yet) we can resize the |
| * journal at runtime, and will be needed for bcache on raw flash support. |
| * |
| * Journal entries contain a list of keys, ordered by the time they were |
| * inserted; thus journal replay just has to reinsert the keys. |
| * |
| * We also keep some things in the journal header that are logically part of the |
| * superblock - all the things that are frequently updated. This is for future |
| * bcache on raw flash support; the superblock (which will become another |
| * journal) can't be moved or wear leveled, so it contains just enough |
| * information to find the main journal, and the superblock only has to be |
| * rewritten when we want to move/wear level the main journal. |
| * |
| * Currently, we don't journal BTREE_REPLACE operations - this will hopefully be |
| * fixed eventually. This isn't a bug - BTREE_REPLACE is used for insertions |
| * from cache misses, which don't have to be journaled, and for writeback and |
| * moving gc we work around it by flushing the btree to disk before updating the |
| * gc information. But it is a potential issue with incremental garbage |
| * collection, and it's fragile. |
| * |
| * OPEN JOURNAL ENTRIES: |
| * |
| * Each journal entry contains, in the header, the sequence number of the last |
| * journal entry still open - i.e. that has keys that haven't been flushed to |
| * disk in the btree. |
| * |
| * We track this by maintaining a refcount for every open journal entry, in a |
| * fifo; each entry in the fifo corresponds to a particular journal |
| * entry/sequence number. When the refcount at the tail of the fifo goes to |
| * zero, we pop it off - thus, the size of the fifo tells us the number of open |
| * journal entries |
| * |
| * We take a refcount on a journal entry when we add some keys to a journal |
| * entry that we're going to insert (held by struct btree_op), and then when we |
| * insert those keys into the btree the btree write we're setting up takes a |
| * copy of that refcount (held by struct btree_write). That refcount is dropped |
| * when the btree write completes. |
| * |
| * A struct btree_write can only hold a refcount on a single journal entry, but |
| * might contain keys for many journal entries - we handle this by making sure |
| * it always has a refcount on the _oldest_ journal entry of all the journal |
| * entries it has keys for. |
| * |
| * JOURNAL RECLAIM: |
| * |
| * As mentioned previously, our fifo of refcounts tells us the number of open |
| * journal entries; from that and the current journal sequence number we compute |
| * last_seq - the oldest journal entry we still need. We write last_seq in each |
| * journal entry, and we also have to keep track of where it exists on disk so |
| * we don't overwrite it when we loop around the journal. |
| * |
| * To do that we track, for each journal bucket, the sequence number of the |
| * newest journal entry it contains - if we don't need that journal entry we |
| * don't need anything in that bucket anymore. From that we track the last |
| * journal bucket we still need; all this is tracked in struct journal_device |
| * and updated by journal_reclaim(). |
| * |
| * JOURNAL FILLING UP: |
| * |
| * There are two ways the journal could fill up; either we could run out of |
| * space to write to, or we could have too many open journal entries and run out |
| * of room in the fifo of refcounts. Since those refcounts are decremented |
| * without any locking we can't safely resize that fifo, so we handle it the |
| * same way. |
| * |
| * If the journal fills up, we start flushing dirty btree nodes until we can |
| * allocate space for a journal write again - preferentially flushing btree |
| * nodes that are pinning the oldest journal entries first. |
| */ |
| |
| /* |
| * Only used for holding the journal entries we read in btree_journal_read() |
| * during cache_registration |
| */ |
| struct journal_replay { |
| struct list_head list; |
| atomic_t *pin; |
| struct jset j; |
| }; |
| |
| /* |
| * We put two of these in struct journal; we used them for writes to the |
| * journal that are being staged or in flight. |
| */ |
| struct journal_write { |
| struct jset *data; |
| #define JSET_BITS 3 |
| |
| struct cache_set *c; |
| struct closure_waitlist wait; |
| bool dirty; |
| bool need_write; |
| }; |
| |
| /* Embedded in struct cache_set */ |
| struct journal { |
| spinlock_t lock; |
| /* used when waiting because the journal was full */ |
| struct closure_waitlist wait; |
| struct closure io; |
| int io_in_flight; |
| struct delayed_work work; |
| |
| /* Number of blocks free in the bucket(s) we're currently writing to */ |
| unsigned blocks_free; |
| uint64_t seq; |
| DECLARE_FIFO(atomic_t, pin); |
| |
| BKEY_PADDED(key); |
| |
| struct journal_write w[2], *cur; |
| }; |
| |
| /* |
| * Embedded in struct cache. First three fields refer to the array of journal |
| * buckets, in cache_sb. |
| */ |
| struct journal_device { |
| /* |
| * For each journal bucket, contains the max sequence number of the |
| * journal writes it contains - so we know when a bucket can be reused. |
| */ |
| uint64_t seq[SB_JOURNAL_BUCKETS]; |
| |
| /* Journal bucket we're currently writing to */ |
| unsigned cur_idx; |
| |
| /* Last journal bucket that still contains an open journal entry */ |
| unsigned last_idx; |
| |
| /* Next journal bucket to be discarded */ |
| unsigned discard_idx; |
| |
| #define DISCARD_READY 0 |
| #define DISCARD_IN_FLIGHT 1 |
| #define DISCARD_DONE 2 |
| /* 1 - discard in flight, -1 - discard completed */ |
| atomic_t discard_in_flight; |
| |
| struct work_struct discard_work; |
| struct bio discard_bio; |
| struct bio_vec discard_bv; |
| |
| /* Bio for journal reads/writes to this device */ |
| struct bio bio; |
| struct bio_vec bv[8]; |
| }; |
| |
| #define journal_pin_cmp(c, l, r) \ |
| (fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r))) |
| |
| #define JOURNAL_PIN 20000 |
| |
| #define journal_full(j) \ |
| (!(j)->blocks_free || fifo_free(&(j)->pin) <= 1) |
| |
| struct closure; |
| struct cache_set; |
| struct btree_op; |
| struct keylist; |
| |
| atomic_t *bch_journal(struct cache_set *, struct keylist *, struct closure *); |
| void bch_journal_next(struct journal *); |
| void bch_journal_mark(struct cache_set *, struct list_head *); |
| void bch_journal_meta(struct cache_set *, struct closure *); |
| int bch_journal_read(struct cache_set *, struct list_head *); |
| int bch_journal_replay(struct cache_set *, struct list_head *); |
| |
| void bch_journal_free(struct cache_set *); |
| int bch_journal_alloc(struct cache_set *); |
| |
| #endif /* _BCACHE_JOURNAL_H */ |