journal.h 6.4 KB

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