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