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  */
  83 struct 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  */
  93 struct 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 */
 104 struct journal {
 105         spinlock_t              lock;
 106         spinlock_t              flush_write_lock;
 107         bool                    btree_flushing;
 108         /* used when waiting because the journal was full */
 109         struct closure_waitlist wait;
 110         struct closure          io;
 111         int                     io_in_flight;
 112         struct delayed_work     work;
 113
 114         /* Number of blocks free in the bucket(s) we're currently writing to */
 115         unsigned int            blocks_free;
 116         uint64_t                seq;
 117         DECLARE_FIFO(atomic_t, pin);
 118
 119         BKEY_PADDED(key);
 120
 121         struct journal_write    w[2], *cur;
 122 };
 123
 124 /*
 125  * Embedded in struct cache. First three fields refer to the array of journal
 126  * buckets, in cache_sb.
 127  */
 128 struct journal_device {
 129         /*
 130          * For each journal bucket, contains the max sequence number of the
 131          * journal writes it contains - so we know when a bucket can be reused.
 132          */
 133         uint64_t                seq[SB_JOURNAL_BUCKETS];
 134
 135         /* Journal bucket we're currently writing to */
 136         unsigned int            cur_idx;
 137
 138         /* Last journal bucket that still contains an open journal entry */
 139         unsigned int            last_idx;
 140
 141         /* Next journal bucket to be discarded */
 142         unsigned int            discard_idx;
 143
 144 #define DISCARD_READY           0
 145 #define DISCARD_IN_FLIGHT       1
 146 #define DISCARD_DONE            2
 147         /* 1 - discard in flight, -1 - discard completed */
 148         atomic_t                discard_in_flight;
 149
 150         struct work_struct      discard_work;
 151         struct bio              discard_bio;
 152         struct bio_vec          discard_bv;
 153
 154         /* Bio for journal reads/writes to this device */
 155         struct bio              bio;
 156         struct bio_vec          bv[8];
 157 };
 158
 159 #define BTREE_FLUSH_NR  8
 160
 161 #define journal_pin_cmp(c, l, r)                                \
 162         (fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r)))
 163
 164 #define JOURNAL_PIN     20000
 165
 166 #define journal_full(j)                                         \
 167         (!(j)->blocks_free || fifo_free(&(j)->pin) <= 1)
 168
 169 struct closure;
 170 struct cache_set;
 171 struct btree_op;
 172 struct keylist;
 173
 174 atomic_t *bch_journal(struct cache_set *c,
 175                       struct keylist *keys,
 176                       struct closure *parent);
 177 void bch_journal_next(struct journal *j);
 178 void bch_journal_mark(struct cache_set *c, struct list_head *list);
 179 void bch_journal_meta(struct cache_set *c, struct closure *cl);
 180 int bch_journal_read(struct cache_set *c, struct list_head *list);
 181 int bch_journal_replay(struct cache_set *c, struct list_head *list);
 182
 183 void bch_journal_free(struct cache_set *c);
 184 int bch_journal_alloc(struct cache_set *c);
 185
 186 #endif /* _BCACHE_JOURNAL_H */