[deliverable/linux.git] / drivers / md / bcache / journal.h

#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			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;
	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 */
Commit	Line	Data
cafe5635 KO	1	#ifndef _BCACHE_JOURNAL_H
	2	#define _BCACHE_JOURNAL_H
	3
	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
cafe5635 KO	78	/*
	79	* Only used for holding the journal entries we read in btree_journal_read()
	80	* during cache_registration
	81	*/
	82	struct journal_replay {
	83	struct list_head list;
	84	atomic_t *pin;
	85	struct jset j;
	86	};
	87
	88	/*
	89	* We put two of these in struct journal; we used them for writes to the
	90	* journal that are being staged or in flight.
	91	*/
	92	struct journal_write {
	93	struct jset *data;
	94	#define JSET_BITS 3
	95
	96	struct cache_set *c;
	97	struct closure_waitlist wait;
	98	bool need_write;
	99	};
	100
	101	/* Embedded in struct cache_set */
	102	struct journal {
	103	spinlock_t lock;
	104	/* used when waiting because the journal was full */
	105	struct closure_waitlist wait;
7857d5d4 KO	106	struct closure io;
7857d5d4 KO	107	struct delayed_work work;
cafe5635 KO	108
	109	/* Number of blocks free in the bucket(s) we're currently writing to */
	110	unsigned blocks_free;
	111	uint64_t seq;
	112	DECLARE_FIFO(atomic_t, pin);
	113
	114	BKEY_PADDED(key);
	115
	116	struct journal_write w[2], *cur;
	117	};
	118
	119	/*
	120	* Embedded in struct cache. First three fields refer to the array of journal
	121	* buckets, in cache_sb.
	122	*/
	123	struct journal_device {
	124	/*
	125	* For each journal bucket, contains the max sequence number of the
	126	* journal writes it contains - so we know when a bucket can be reused.
	127	*/
	128	uint64_t seq[SB_JOURNAL_BUCKETS];
	129
	130	/* Journal bucket we're currently writing to */
	131	unsigned cur_idx;
	132
	133	/* Last journal bucket that still contains an open journal entry */
	134	unsigned last_idx;
	135
	136	/* Next journal bucket to be discarded */
	137	unsigned discard_idx;
	138
	139	#define DISCARD_READY 0
	140	#define DISCARD_IN_FLIGHT 1
	141	#define DISCARD_DONE 2
	142	/* 1 - discard in flight, -1 - discard completed */
	143	atomic_t discard_in_flight;
	144
	145	struct work_struct discard_work;
	146	struct bio discard_bio;
	147	struct bio_vec discard_bv;
	148
	149	/* Bio for journal reads/writes to this device */
	150	struct bio bio;
	151	struct bio_vec bv[8];
	152	};
	153
	154	#define journal_pin_cmp(c, l, r) \
c18536a7	155	(fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r)))
cafe5635 KO	156
	157	#define JOURNAL_PIN 20000
	158
	159	#define journal_full(j) \
	160	(!(j)->blocks_free \|\| fifo_free(&(j)->pin) <= 1)
	161
	162	struct closure;
	163	struct cache_set;
	164	struct btree_op;
a34a8bfd	165	struct keylist;
cafe5635	166
a34a8bfd	167	atomic_t bch_journal(struct cache_set , struct keylist , struct closure );
cafe5635 KO	168	void bch_journal_next(struct journal *);
	169	void bch_journal_mark(struct cache_set , struct list_head );
	170	void bch_journal_meta(struct cache_set , struct closure );
c18536a7 KO	171	int bch_journal_read(struct cache_set , struct list_head );
c18536a7 KO	172	int bch_journal_replay(struct cache_set , struct list_head );
cafe5635 KO	173
	174	void bch_journal_free(struct cache_set *);
	175	int bch_journal_alloc(struct cache_set *);
	176
	177	#endif /* _BCACHE_JOURNAL_H */