[linux-2.6-block.git] / drivers / md / raid1-10.c

// SPDX-License-Identifier: GPL-2.0
/* Maximum size of each resync request */
#define RESYNC_BLOCK_SIZE (64*1024)
#define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)

/*
 * Number of guaranteed raid bios in case of extreme VM load:
 */
#define	NR_RAID_BIOS 256

/* when we get a read error on a read-only array, we redirect to another
 * device without failing the first device, or trying to over-write to
 * correct the read error.  To keep track of bad blocks on a per-bio
 * level, we store IO_BLOCKED in the appropriate 'bios' pointer
 */
#define IO_BLOCKED ((struct bio *)1)
/* When we successfully write to a known bad-block, we need to remove the
 * bad-block marking which must be done from process context.  So we record
 * the success by setting devs[n].bio to IO_MADE_GOOD
 */
#define IO_MADE_GOOD ((struct bio *)2)

#define BIO_SPECIAL(bio) ((unsigned long)bio <= 2)

/* When there are this many requests queue to be written by
 * the raid thread, we become 'congested' to provide back-pressure
 * for writeback.
 */
static int max_queued_requests = 1024;

/* for managing resync I/O pages */
struct resync_pages {
	void		*raid_bio;
	struct page	*pages[RESYNC_PAGES];
};

static void rbio_pool_free(void *rbio, void *data)
{
	kfree(rbio);
}

static inline int resync_alloc_pages(struct resync_pages *rp,
				     gfp_t gfp_flags)
{
	int i;

	for (i = 0; i < RESYNC_PAGES; i++) {
		rp->pages[i] = alloc_page(gfp_flags);
		if (!rp->pages[i])
			goto out_free;
	}

	return 0;

out_free:
	while (--i >= 0)
		put_page(rp->pages[i]);
	return -ENOMEM;
}

static inline void resync_free_pages(struct resync_pages *rp)
{
	int i;

	for (i = 0; i < RESYNC_PAGES; i++)
		put_page(rp->pages[i]);
}

static inline void resync_get_all_pages(struct resync_pages *rp)
{
	int i;

	for (i = 0; i < RESYNC_PAGES; i++)
		get_page(rp->pages[i]);
}

static inline struct page *resync_fetch_page(struct resync_pages *rp,
					     unsigned idx)
{
	if (WARN_ON_ONCE(idx >= RESYNC_PAGES))
		return NULL;
	return rp->pages[idx];
}

/*
 * 'strct resync_pages' stores actual pages used for doing the resync
 *  IO, and it is per-bio, so make .bi_private points to it.
 */
static inline struct resync_pages *get_resync_pages(struct bio *bio)
{
	return bio->bi_private;
}

/* generally called after bio_reset() for reseting bvec */
static void md_bio_reset_resync_pages(struct bio *bio, struct resync_pages *rp,
			       int size)
{
	int idx = 0;

	/* initialize bvec table again */
	do {
		struct page *page = resync_fetch_page(rp, idx);
		int len = min_t(int, size, PAGE_SIZE);

		/*
		 * won't fail because the vec table is big
		 * enough to hold all these pages
		 */
		bio_add_page(bio, page, len, 0);
		size -= len;
	} while (idx++ < RESYNC_PAGES && size > 0);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
be453e77 ML	2	/* Maximum size of each resync request */
	3	#define RESYNC_BLOCK_SIZE (64*1024)
	4	#define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
	5
3f677f9c MPS	6	/*
	7	* Number of guaranteed raid bios in case of extreme VM load:
	8	*/
	9	#define NR_RAID_BIOS 256
	10
	11	/* when we get a read error on a read-only array, we redirect to another
	12	* device without failing the first device, or trying to over-write to
	13	* correct the read error. To keep track of bad blocks on a per-bio
	14	* level, we store IO_BLOCKED in the appropriate 'bios' pointer
	15	*/
	16	#define IO_BLOCKED ((struct bio *)1)
	17	/* When we successfully write to a known bad-block, we need to remove the
	18	* bad-block marking which must be done from process context. So we record
	19	* the success by setting devs[n].bio to IO_MADE_GOOD
	20	*/
	21	#define IO_MADE_GOOD ((struct bio *)2)
	22
	23	#define BIO_SPECIAL(bio) ((unsigned long)bio <= 2)
	24
	25	/* When there are this many requests queue to be written by
	26	* the raid thread, we become 'congested' to provide back-pressure
	27	* for writeback.
	28	*/
	29	static int max_queued_requests = 1024;
	30
be453e77 ML	31	/* for managing resync I/O pages */
	32	struct resync_pages {
	33	void *raid_bio;
	34	struct page *pages[RESYNC_PAGES];
	35	};
	36
c7afa803 MPS	37	static void rbio_pool_free(void rbio, void data)
	38	{
	39	kfree(rbio);
	40	}
	41
be453e77 ML	42	static inline int resync_alloc_pages(struct resync_pages *rp,
	43	gfp_t gfp_flags)
	44	{
	45	int i;
	46
	47	for (i = 0; i < RESYNC_PAGES; i++) {
	48	rp->pages[i] = alloc_page(gfp_flags);
	49	if (!rp->pages[i])
	50	goto out_free;
	51	}
	52
	53	return 0;
	54
	55	out_free:
	56	while (--i >= 0)
	57	put_page(rp->pages[i]);
	58	return -ENOMEM;
	59	}
	60
	61	static inline void resync_free_pages(struct resync_pages *rp)
	62	{
	63	int i;
	64
	65	for (i = 0; i < RESYNC_PAGES; i++)
	66	put_page(rp->pages[i]);
	67	}
	68
	69	static inline void resync_get_all_pages(struct resync_pages *rp)
	70	{
	71	int i;
	72
	73	for (i = 0; i < RESYNC_PAGES; i++)
	74	get_page(rp->pages[i]);
	75	}
	76
	77	static inline struct page resync_fetch_page(struct resync_pages rp,
	78	unsigned idx)
	79	{
	80	if (WARN_ON_ONCE(idx >= RESYNC_PAGES))
	81	return NULL;
	82	return rp->pages[idx];
	83	}
	84
	85	/*
	86	* 'strct resync_pages' stores actual pages used for doing the resync
	87	* IO, and it is per-bio, so make .bi_private points to it.
	88	*/
	89	static inline struct resync_pages get_resync_pages(struct bio bio)
	90	{
	91	return bio->bi_private;
	92	}
	93
fb0eb5df ML	94	/* generally called after bio_reset() for reseting bvec */
	95	static void md_bio_reset_resync_pages(struct bio bio, struct resync_pages rp,
	96	int size)
	97	{
	98	int idx = 0;
	99
	100	/* initialize bvec table again */
	101	do {
	102	struct page *page = resync_fetch_page(rp, idx);
	103	int len = min_t(int, size, PAGE_SIZE);
	104
	105	/*
	106	* won't fail because the vec table is big
	107	* enough to hold all these pages
	108	*/
	109	bio_add_page(bio, page, len, 0);
	110	size -= len;
	111	} while (idx++ < RESYNC_PAGES && size > 0);
	112	}