[mirror_ubuntu-artful-kernel.git] / drivers / md / bcache / writeback.h

#ifndef _BCACHE_WRITEBACK_H
#define _BCACHE_WRITEBACK_H

#define CUTOFF_WRITEBACK	40
#define CUTOFF_WRITEBACK_SYNC	70

static inline uint64_t bcache_dev_sectors_dirty(struct bcache_device *d)
{
	uint64_t i, ret = 0;

	for (i = 0; i < d->nr_stripes; i++)
		ret += atomic_read(d->stripe_sectors_dirty + i);

	return ret;
}

static inline unsigned offset_to_stripe(struct bcache_device *d,
					uint64_t offset)
{
	do_div(offset, d->stripe_size);
	return offset;
}

static inline bool bcache_dev_stripe_dirty(struct cached_dev *dc,
					   uint64_t offset,
					   unsigned nr_sectors)
{
	unsigned stripe = offset_to_stripe(&dc->disk, offset);

	while (1) {
		if (atomic_read(dc->disk.stripe_sectors_dirty + stripe))
			return true;

		if (nr_sectors <= dc->disk.stripe_size)
			return false;

		nr_sectors -= dc->disk.stripe_size;
		stripe++;
	}
}

static inline bool should_writeback(struct cached_dev *dc, struct bio *bio,
				    unsigned cache_mode, bool would_skip)
{
	unsigned in_use = dc->disk.c->gc_stats.in_use;

	if (cache_mode != CACHE_MODE_WRITEBACK ||
	    test_bit(BCACHE_DEV_DETACHING, &dc->disk.flags) ||
	    in_use > CUTOFF_WRITEBACK_SYNC)
		return false;

	if (dc->partial_stripes_expensive &&
	    bcache_dev_stripe_dirty(dc, bio->bi_iter.bi_sector,
				    bio_sectors(bio)))
		return true;

	if (would_skip)
		return false;

	return bio->bi_rw & REQ_SYNC ||
		in_use <= CUTOFF_WRITEBACK;
}

static inline void bch_writeback_queue(struct cached_dev *dc)
{
	if (!IS_ERR_OR_NULL(dc->writeback_thread))
		wake_up_process(dc->writeback_thread);
}

static inline void bch_writeback_add(struct cached_dev *dc)
{
	if (!atomic_read(&dc->has_dirty) &&
	    !atomic_xchg(&dc->has_dirty, 1)) {
		atomic_inc(&dc->count);

		if (BDEV_STATE(&dc->sb) != BDEV_STATE_DIRTY) {
			SET_BDEV_STATE(&dc->sb, BDEV_STATE_DIRTY);
			/* XXX: should do this synchronously */
			bch_write_bdev_super(dc, NULL);
		}

		bch_writeback_queue(dc);
	}
}

void bcache_dev_sectors_dirty_add(struct cache_set *, unsigned, uint64_t, int);

void bch_sectors_dirty_init(struct cached_dev *dc);
void bch_cached_dev_writeback_init(struct cached_dev *);
int bch_cached_dev_writeback_start(struct cached_dev *);

#endif
Commit	Line	Data
279afbad KO	1	#ifndef _BCACHE_WRITEBACK_H
	2	#define _BCACHE_WRITEBACK_H
	3
72c27061 KO	4	#define CUTOFF_WRITEBACK 40
	5	#define CUTOFF_WRITEBACK_SYNC 70
	6
279afbad KO	7	static inline uint64_t bcache_dev_sectors_dirty(struct bcache_device *d)
	8	{
	9	uint64_t i, ret = 0;
	10
	11	for (i = 0; i < d->nr_stripes; i++)
	12	ret += atomic_read(d->stripe_sectors_dirty + i);
	13
	14	return ret;
	15	}
	16
48a915a8 KO	17	static inline unsigned offset_to_stripe(struct bcache_device *d,
	18	uint64_t offset)
	19	{
	20	do_div(offset, d->stripe_size);
	21	return offset;
	22	}
	23
	24	static inline bool bcache_dev_stripe_dirty(struct cached_dev *dc,
72c27061 KO	25	uint64_t offset,
	26	unsigned nr_sectors)
	27	{
48a915a8	28	unsigned stripe = offset_to_stripe(&dc->disk, offset);
72c27061 KO	29
72c27061 KO	30	while (1) {
48a915a8	31	if (atomic_read(dc->disk.stripe_sectors_dirty + stripe))
72c27061 KO	32	return true;
72c27061 KO	33
48a915a8	34	if (nr_sectors <= dc->disk.stripe_size)
72c27061 KO	35	return false;
72c27061 KO	36
48a915a8	37	nr_sectors -= dc->disk.stripe_size;
72c27061 KO	38	stripe++;
	39	}
	40	}
	41
	42	static inline bool should_writeback(struct cached_dev dc, struct bio bio,
	43	unsigned cache_mode, bool would_skip)
	44	{
	45	unsigned in_use = dc->disk.c->gc_stats.in_use;
	46
	47	if (cache_mode != CACHE_MODE_WRITEBACK \|\|
c4d951dd	48	test_bit(BCACHE_DEV_DETACHING, &dc->disk.flags) \|\|
72c27061 KO	49	in_use > CUTOFF_WRITEBACK_SYNC)
	50	return false;
	51
	52	if (dc->partial_stripes_expensive &&
4f024f37	53	bcache_dev_stripe_dirty(dc, bio->bi_iter.bi_sector,
72c27061 KO	54	bio_sectors(bio)))
	55	return true;
	56
	57	if (would_skip)
	58	return false;
	59
	60	return bio->bi_rw & REQ_SYNC \|\|
	61	in_use <= CUTOFF_WRITEBACK;
	62	}
	63
5e6926da KO	64	static inline void bch_writeback_queue(struct cached_dev *dc)
5e6926da KO	65	{
8d16ce54 SB	66	if (!IS_ERR_OR_NULL(dc->writeback_thread))
8d16ce54 SB	67	wake_up_process(dc->writeback_thread);
5e6926da KO	68	}
	69
	70	static inline void bch_writeback_add(struct cached_dev *dc)
	71	{
	72	if (!atomic_read(&dc->has_dirty) &&
	73	!atomic_xchg(&dc->has_dirty, 1)) {
	74	atomic_inc(&dc->count);
	75
	76	if (BDEV_STATE(&dc->sb) != BDEV_STATE_DIRTY) {
	77	SET_BDEV_STATE(&dc->sb, BDEV_STATE_DIRTY);
	78	/* XXX: should do this synchronously */
	79	bch_write_bdev_super(dc, NULL);
	80	}
	81
	82	bch_writeback_queue(dc);
	83	}
	84	}
	85
279afbad	86	void bcache_dev_sectors_dirty_add(struct cache_set *, unsigned, uint64_t, int);
279afbad KO	87
279afbad KO	88	void bch_sectors_dirty_init(struct cached_dev *dc);
9e5c3535 SP	89	void bch_cached_dev_writeback_init(struct cached_dev *);
9e5c3535 SP	90	int bch_cached_dev_writeback_start(struct cached_dev *);
279afbad KO	91
279afbad KO	92	#endif