Merge tag 'pwm/for-5.14-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry...
[linux-2.6-microblaze.git] / drivers / md / raid1-10.c
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  */
29 static int max_queued_requests = 1024;
30
31 /* for managing resync I/O pages */
32 struct resync_pages {
33         void            *raid_bio;
34         struct page     *pages[RESYNC_PAGES];
35 };
36
37 static void rbio_pool_free(void *rbio, void *data)
38 {
39         kfree(rbio);
40 }
41
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
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 }