1// SPDX-License-Identifier: GPL-2.0
  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
  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 */
 29static int max_queued_requests = 1024;
 30
 31/* for managing resync I/O pages */
 32struct resync_pages {
 33	void		*raid_bio;
 34	struct page	*pages[RESYNC_PAGES];
 35};
 36
 37static void rbio_pool_free(void *rbio, void *data)
 38{
 39	kfree(rbio);
 40}
 41
 42static 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
 55out_free:
 56	while (--i >= 0)
 57		put_page(rp->pages[i]);
 58	return -ENOMEM;
 59}
 60
 61static 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
 69static 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
 77static 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 */
 89static inline struct resync_pages *get_resync_pages(struct bio *bio)
 90{
 91	return bio->bi_private;
 92}
 93
 94/* generally called after bio_reset() for reseting bvec */
 95static 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}

 1// SPDX-License-Identifier: GPL-2.0
 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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 6/* for managing resync I/O pages */
 7struct resync_pages {
 8	void		*raid_bio;
 9	struct page	*pages[RESYNC_PAGES];
10};
 
 
 
 
 
11
12static inline int resync_alloc_pages(struct resync_pages *rp,
13				     gfp_t gfp_flags)
14{
15	int i;
16
17	for (i = 0; i < RESYNC_PAGES; i++) {
18		rp->pages[i] = alloc_page(gfp_flags);
19		if (!rp->pages[i])
20			goto out_free;
21	}
22
23	return 0;
24
25out_free:
26	while (--i >= 0)
27		put_page(rp->pages[i]);
28	return -ENOMEM;
29}
30
31static inline void resync_free_pages(struct resync_pages *rp)
32{
33	int i;
34
35	for (i = 0; i < RESYNC_PAGES; i++)
36		put_page(rp->pages[i]);
37}
38
39static inline void resync_get_all_pages(struct resync_pages *rp)
40{
41	int i;
42
43	for (i = 0; i < RESYNC_PAGES; i++)
44		get_page(rp->pages[i]);
45}
46
47static inline struct page *resync_fetch_page(struct resync_pages *rp,
48					     unsigned idx)
49{
50	if (WARN_ON_ONCE(idx >= RESYNC_PAGES))
51		return NULL;
52	return rp->pages[idx];
53}
54
55/*
56 * 'strct resync_pages' stores actual pages used for doing the resync
57 *  IO, and it is per-bio, so make .bi_private points to it.
58 */
59static inline struct resync_pages *get_resync_pages(struct bio *bio)
60{
61	return bio->bi_private;
62}
63
64/* generally called after bio_reset() for reseting bvec */
65static void md_bio_reset_resync_pages(struct bio *bio, struct resync_pages *rp,
66			       int size)
67{
68	int idx = 0;
69
70	/* initialize bvec table again */
71	do {
72		struct page *page = resync_fetch_page(rp, idx);
73		int len = min_t(int, size, PAGE_SIZE);
74
75		/*
76		 * won't fail because the vec table is big
77		 * enough to hold all these pages
78		 */
79		bio_add_page(bio, page, len, 0);
80		size -= len;
81	} while (idx++ < RESYNC_PAGES && size > 0);
82}