Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Ming Lei | be453e7 | 2017-07-14 16:14:44 +0800 | [diff] [blame] | 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 | |
Marcos Paulo de Souza | 3f677f9 | 2019-06-14 15:41:04 -0700 | [diff] [blame] | 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 | |
Ming Lei | be453e7 | 2017-07-14 16:14:44 +0800 | [diff] [blame] | 31 | /* for managing resync I/O pages */ |
| 32 | struct resync_pages { |
| 33 | void *raid_bio; |
| 34 | struct page *pages[RESYNC_PAGES]; |
| 35 | }; |
| 36 | |
Marcos Paulo de Souza | c7afa80 | 2019-06-14 15:41:10 -0700 | [diff] [blame] | 37 | static void rbio_pool_free(void *rbio, void *data) |
| 38 | { |
| 39 | kfree(rbio); |
| 40 | } |
| 41 | |
Ming Lei | be453e7 | 2017-07-14 16:14:44 +0800 | [diff] [blame] | 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 | |
Ming Lei | fb0eb5d | 2017-07-14 16:14:43 +0800 | [diff] [blame] | 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 | } |