LXR linux/drivers/md/bcache/journal.h

   1/* SPDX-License-Identifier: GPL-2.0 */
   2#ifndef _BCACHE_JOURNAL_H
   3#define _BCACHE_JOURNAL_H
   4
   5/*
   6 * THE JOURNAL:
   7 *
   8 * The journal is treated as a circular buffer of buckets - a journal entry
   9 * never spans two buckets. This means (not implemented yet) we can resize the
  10 * journal at runtime, and will be needed for bcache on raw flash support.
  11 *
  12 * Journal entries contain a list of keys, ordered by the time they were
  13 * inserted; thus journal replay just has to reinsert the keys.
  14 *
  15 * We also keep some things in the journal header that are logically part of the
  16 * superblock - all the things that are frequently updated. This is for future
  17 * bcache on raw flash support; the superblock (which will become another
  18 * journal) can't be moved or wear leveled, so it contains just enough
  19 * information to find the main journal, and the superblock only has to be
  20 * rewritten when we want to move/wear level the main journal.
  21 *
  22 * Currently, we don't journal BTREE_REPLACE operations - this will hopefully be
  23 * fixed eventually. This isn't a bug - BTREE_REPLACE is used for insertions
  24 * from cache misses, which don't have to be journaled, and for writeback and
  25 * moving gc we work around it by flushing the btree to disk before updating the
  26 * gc information. But it is a potential issue with incremental garbage
  27 * collection, and it's fragile.
  28 *
  29 * OPEN JOURNAL ENTRIES:
  30 *
  31 * Each journal entry contains, in the header, the sequence number of the last
  32 * journal entry still open - i.e. that has keys that haven't been flushed to
  33 * disk in the btree.
  34 *
  35 * We track this by maintaining a refcount for every open journal entry, in a
  36 * fifo; each entry in the fifo corresponds to a particular journal
  37 * entry/sequence number. When the refcount at the tail of the fifo goes to
  38 * zero, we pop it off - thus, the size of the fifo tells us the number of open
  39 * journal entries
  40 *
  41 * We take a refcount on a journal entry when we add some keys to a journal
  42 * entry that we're going to insert (held by struct btree_op), and then when we
  43 * insert those keys into the btree the btree write we're setting up takes a
  44 * copy of that refcount (held by struct btree_write). That refcount is dropped
  45 * when the btree write completes.
  46 *
  47 * A struct btree_write can only hold a refcount on a single journal entry, but
  48 * might contain keys for many journal entries - we handle this by making sure
  49 * it always has a refcount on the _oldest_ journal entry of all the journal
  50 * entries it has keys for.
  51 *
  52 * JOURNAL RECLAIM:
  53 *
  54 * As mentioned previously, our fifo of refcounts tells us the number of open
  55 * journal entries; from that and the current journal sequence number we compute
  56 * last_seq - the oldest journal entry we still need. We write last_seq in each
  57 * journal entry, and we also have to keep track of where it exists on disk so
  58 * we don't overwrite it when we loop around the journal.
  59 *
  60 * To do that we track, for each journal bucket, the sequence number of the
  61 * newest journal entry it contains - if we don't need that journal entry we
  62 * don't need anything in that bucket anymore. From that we track the last
  63 * journal bucket we still need; all this is tracked in struct journal_device
  64 * and updated by journal_reclaim().
  65 *
  66 * JOURNAL FILLING UP:
  67 *
  68 * There are two ways the journal could fill up; either we could run out of
  69 * space to write to, or we could have too many open journal entries and run out
  70 * of room in the fifo of refcounts. Since those refcounts are decremented
  71 * without any locking we can't safely resize that fifo, so we handle it the
  72 * same way.
  73 *
  74 * If the journal fills up, we start flushing dirty btree nodes until we can
  75 * allocate space for a journal write again - preferentially flushing btree
  76 * nodes that are pinning the oldest journal entries first.
  77 */
  78
  79/*
  80 * Only used for holding the journal entries we read in btree_journal_read()
  81 * during cache_registration
  82 */
  83struct journal_replay {
  84        struct list_head        list;
  85        atomic_t                *pin;
  86        struct jset             j;
  87};
  88
  89/*
  90 * We put two of these in struct journal; we used them for writes to the
  91 * journal that are being staged or in flight.
  92 */
  93struct journal_write {
  94        struct jset             *data;
  95#define JSET_BITS               3
  96
  97        struct cache_set        *c;
  98        struct closure_waitlist wait;
  99        bool                    dirty;
 100        bool                    need_write;
 101};
 102
 103/* Embedded in struct cache_set */
 104struct journal {
 105        spinlock_t              lock;
 106        /* used when waiting because the journal was full */
 107        struct closure_waitlist wait;
 108        struct closure          io;
 109        int                     io_in_flight;
 110        struct delayed_work     work;
 111
 112        /* Number of blocks free in the bucket(s) we're currently writing to */
 113        unsigned                blocks_free;
 114        uint64_t                seq;
 115        DECLARE_FIFO(atomic_t, pin);
 116
 117        BKEY_PADDED(key);
 118
 119        struct journal_write    w[2], *cur;
 120};
 121
 122/*
 123 * Embedded in struct cache. First three fields refer to the array of journal
 124 * buckets, in cache_sb.
 125 */
 126struct journal_device {
 127        /*
 128         * For each journal bucket, contains the max sequence number of the
 129         * journal writes it contains - so we know when a bucket can be reused.
 130         */
 131        uint64_t                seq[SB_JOURNAL_BUCKETS];
 132
 133        /* Journal bucket we're currently writing to */
 134        unsigned                cur_idx;
 135
 136        /* Last journal bucket that still contains an open journal entry */
 137        unsigned                last_idx;
 138
 139        /* Next journal bucket to be discarded */
 140        unsigned                discard_idx;
 141
 142#define DISCARD_READY           0
 143#define DISCARD_IN_FLIGHT       1
 144#define DISCARD_DONE            2
 145        /* 1 - discard in flight, -1 - discard completed */
 146        atomic_t                discard_in_flight;
 147
 148        struct work_struct      discard_work;
 149        struct bio              discard_bio;
 150        struct bio_vec          discard_bv;
 151
 152        /* Bio for journal reads/writes to this device */
 153        struct bio              bio;
 154        struct bio_vec          bv[8];
 155};
 156
 157#define journal_pin_cmp(c, l, r)                                \
 158        (fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r)))
 159
 160#define JOURNAL_PIN     20000
 161
 162#define journal_full(j)                                         \
 163        (!(j)->blocks_free || fifo_free(&(j)->pin) <= 1)
 164
 165struct closure;
 166struct cache_set;
 167struct btree_op;
 168struct keylist;
 169
 170atomic_t *bch_journal(struct cache_set *, struct keylist *, struct closure *);
 171void bch_journal_next(struct journal *);
 172void bch_journal_mark(struct cache_set *, struct list_head *);
 173void bch_journal_meta(struct cache_set *, struct closure *);
 174int bch_journal_read(struct cache_set *, struct list_head *);
 175int bch_journal_replay(struct cache_set *, struct list_head *);
 176
 177void bch_journal_free(struct cache_set *);
 178int bch_journal_alloc(struct cache_set *);
 179
 180#endif /* _BCACHE_JOURNAL_H */
 181