[deliverable/linux.git] / drivers / md / bcache / io.c

/*
 * Some low level IO code, and hacks for various block layer limitations
 *
 * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
 * Copyright 2012 Google, Inc.
 */

#include "bcache.h"
#include "bset.h"
#include "debug.h"

#include <linux/blkdev.h>

/* Bios with headers */

void bch_bbio_free(struct bio *bio, struct cache_set *c)
{
	struct bbio *b = container_of(bio, struct bbio, bio);
	mempool_free(b, c->bio_meta);
}

struct bio *bch_bbio_alloc(struct cache_set *c)
{
	struct bbio *b = mempool_alloc(c->bio_meta, GFP_NOIO);
	struct bio *bio = &b->bio;

	bio_init(bio);
	bio->bi_flags		|= BIO_POOL_NONE << BIO_POOL_OFFSET;
	bio->bi_max_vecs	 = bucket_pages(c);
	bio->bi_io_vec		 = bio->bi_inline_vecs;

	return bio;
}

void __bch_submit_bbio(struct bio *bio, struct cache_set *c)
{
	struct bbio *b = container_of(bio, struct bbio, bio);

	bio->bi_iter.bi_sector	= PTR_OFFSET(&b->key, 0);
	bio->bi_bdev		= PTR_CACHE(c, &b->key, 0)->bdev;

	b->submit_time_us = local_clock_us();
	closure_bio_submit(bio, bio->bi_private);
}

void bch_submit_bbio(struct bio *bio, struct cache_set *c,
		     struct bkey *k, unsigned ptr)
{
	struct bbio *b = container_of(bio, struct bbio, bio);
	bch_bkey_copy_single_ptr(&b->key, k, ptr);
	__bch_submit_bbio(bio, c);
}

/* IO errors */

void bch_count_io_errors(struct cache *ca, int error, const char *m)
{
	/*
	 * The halflife of an error is:
	 * log2(1/2)/log2(127/128) * refresh ~= 88 * refresh
	 */

	if (ca->set->error_decay) {
		unsigned count = atomic_inc_return(&ca->io_count);

		while (count > ca->set->error_decay) {
			unsigned errors;
			unsigned old = count;
			unsigned new = count - ca->set->error_decay;

			/*
			 * First we subtract refresh from count; each time we
			 * succesfully do so, we rescale the errors once:
			 */

			count = atomic_cmpxchg(&ca->io_count, old, new);

			if (count == old) {
				count = new;

				errors = atomic_read(&ca->io_errors);
				do {
					old = errors;
					new = ((uint64_t) errors * 127) / 128;
					errors = atomic_cmpxchg(&ca->io_errors,
								old, new);
				} while (old != errors);
			}
		}
	}

	if (error) {
		char buf[BDEVNAME_SIZE];
		unsigned errors = atomic_add_return(1 << IO_ERROR_SHIFT,
						    &ca->io_errors);
		errors >>= IO_ERROR_SHIFT;

		if (errors < ca->set->error_limit)
			pr_err("%s: IO error on %s, recovering",
			       bdevname(ca->bdev, buf), m);
		else
			bch_cache_set_error(ca->set,
					    "%s: too many IO errors %s",
					    bdevname(ca->bdev, buf), m);
	}
}

void bch_bbio_count_io_errors(struct cache_set *c, struct bio *bio,
			      int error, const char *m)
{
	struct bbio *b = container_of(bio, struct bbio, bio);
	struct cache *ca = PTR_CACHE(c, &b->key, 0);

	unsigned threshold = bio->bi_rw & REQ_WRITE
		? c->congested_write_threshold_us
		: c->congested_read_threshold_us;

	if (threshold) {
		unsigned t = local_clock_us();

		int us = t - b->submit_time_us;
		int congested = atomic_read(&c->congested);

		if (us > (int) threshold) {
			int ms = us / 1024;
			c->congested_last_us = t;

			ms = min(ms, CONGESTED_MAX + congested);
			atomic_sub(ms, &c->congested);
		} else if (congested < 0)
			atomic_inc(&c->congested);
	}

	bch_count_io_errors(ca, error, m);
}

void bch_bbio_endio(struct cache_set *c, struct bio *bio,
		    int error, const char *m)
{
	struct closure *cl = bio->bi_private;

	bch_bbio_count_io_errors(c, bio, error, m);
	bio_put(bio);
	closure_put(cl);
}
Commit	Line	Data
cafe5635 KO	1	/*
	2	* Some low level IO code, and hacks for various block layer limitations
	3	*
	4	* Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
	5	* Copyright 2012 Google, Inc.
	6	*/
	7
	8	#include "bcache.h"
	9	#include "bset.h"
	10	#include "debug.h"
	11
c37511b8 KO	12	#include <linux/blkdev.h>
c37511b8 KO	13
cafe5635 KO	14	/* Bios with headers */
	15
	16	void bch_bbio_free(struct bio bio, struct cache_set c)
	17	{
	18	struct bbio *b = container_of(bio, struct bbio, bio);
	19	mempool_free(b, c->bio_meta);
	20	}
	21
	22	struct bio bch_bbio_alloc(struct cache_set c)
	23	{
	24	struct bbio *b = mempool_alloc(c->bio_meta, GFP_NOIO);
	25	struct bio *bio = &b->bio;
	26
	27	bio_init(bio);
	28	bio->bi_flags \|= BIO_POOL_NONE << BIO_POOL_OFFSET;
	29	bio->bi_max_vecs = bucket_pages(c);
	30	bio->bi_io_vec = bio->bi_inline_vecs;
	31
	32	return bio;
	33	}
	34
	35	void __bch_submit_bbio(struct bio bio, struct cache_set c)
	36	{
	37	struct bbio *b = container_of(bio, struct bbio, bio);
	38
4f024f37 KO	39	bio->bi_iter.bi_sector = PTR_OFFSET(&b->key, 0);
4f024f37 KO	40	bio->bi_bdev = PTR_CACHE(c, &b->key, 0)->bdev;
cafe5635 KO	41
cafe5635 KO	42	b->submit_time_us = local_clock_us();
749b61da	43	closure_bio_submit(bio, bio->bi_private);
cafe5635 KO	44	}
	45
	46	void bch_submit_bbio(struct bio bio, struct cache_set c,
	47	struct bkey *k, unsigned ptr)
	48	{
	49	struct bbio *b = container_of(bio, struct bbio, bio);
	50	bch_bkey_copy_single_ptr(&b->key, k, ptr);
	51	__bch_submit_bbio(bio, c);
	52	}
	53
	54	/* IO errors */
	55
	56	void bch_count_io_errors(struct cache ca, int error, const char m)
	57	{
	58	/*
	59	* The halflife of an error is:
	60	* log2(1/2)/log2(127/128) * refresh ~= 88 * refresh
	61	*/
	62
	63	if (ca->set->error_decay) {
	64	unsigned count = atomic_inc_return(&ca->io_count);
	65
	66	while (count > ca->set->error_decay) {
	67	unsigned errors;
	68	unsigned old = count;
	69	unsigned new = count - ca->set->error_decay;
	70
	71	/*
	72	* First we subtract refresh from count; each time we
	73	* succesfully do so, we rescale the errors once:
	74	*/
	75
	76	count = atomic_cmpxchg(&ca->io_count, old, new);
	77
	78	if (count == old) {
	79	count = new;
	80
	81	errors = atomic_read(&ca->io_errors);
	82	do {
	83	old = errors;
	84	new = ((uint64_t) errors * 127) / 128;
	85	errors = atomic_cmpxchg(&ca->io_errors,
	86	old, new);
	87	} while (old != errors);
	88	}
	89	}
	90	}
	91
	92	if (error) {
	93	char buf[BDEVNAME_SIZE];
	94	unsigned errors = atomic_add_return(1 << IO_ERROR_SHIFT,
	95	&ca->io_errors);
	96	errors >>= IO_ERROR_SHIFT;
	97
	98	if (errors < ca->set->error_limit)
	99	pr_err("%s: IO error on %s, recovering",
	100	bdevname(ca->bdev, buf), m);
	101	else
	102	bch_cache_set_error(ca->set,
	103	"%s: too many IO errors %s",
	104	bdevname(ca->bdev, buf), m);
	105	}
	106	}
	107
108	void bch_bbio_count_io_errors(struct cache_set c, struct bio bio,
109	int error, const char *m)
110	{
111	struct bbio *b = container_of(bio, struct bbio, bio);
112	struct cache *ca = PTR_CACHE(c, &b->key, 0);
113
114	unsigned threshold = bio->bi_rw & REQ_WRITE
115	? c->congested_write_threshold_us
116	: c->congested_read_threshold_us;
117
118	if (threshold) {
119	unsigned t = local_clock_us();
120
121	int us = t - b->submit_time_us;
122	int congested = atomic_read(&c->congested);
123
124	if (us > (int) threshold) {
125	int ms = us / 1024;
126	c->congested_last_us = t;
127
128	ms = min(ms, CONGESTED_MAX + congested);
129	atomic_sub(ms, &c->congested);
130	} else if (congested < 0)
131	atomic_inc(&c->congested);
132	}
133
134	bch_count_io_errors(ca, error, m);
135	}
136
137	void bch_bbio_endio(struct cache_set c, struct bio bio,
138	int error, const char *m)
139	{
140	struct closure *cl = bio->bi_private;
141
142	bch_bbio_count_io_errors(c, bio, error, m);
143	bio_put(bio);
144	closure_put(cl);
145	}