1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2012 Fusion-io All rights reserved.
4 * Copyright (C) 2012 Intel Corp. All rights reserved.
7 #include <linux/sched.h>
9 #include <linux/slab.h>
10 #include <linux/blkdev.h>
11 #include <linux/raid/pq.h>
12 #include <linux/hash.h>
13 #include <linux/list_sort.h>
14 #include <linux/raid/xor.h>
20 #include "async-thread.h"
22 /* set when additional merges to this rbio are not allowed */
23 #define RBIO_RMW_LOCKED_BIT 1
26 * set when this rbio is sitting in the hash, but it is just a cache
29 #define RBIO_CACHE_BIT 2
32 * set when it is safe to trust the stripe_pages for caching
34 #define RBIO_CACHE_READY_BIT 3
36 #define RBIO_CACHE_SIZE 1024
40 BTRFS_RBIO_READ_REBUILD,
41 BTRFS_RBIO_PARITY_SCRUB,
42 BTRFS_RBIO_REBUILD_MISSING,
45 struct btrfs_raid_bio {
46 struct btrfs_fs_info *fs_info;
47 struct btrfs_bio *bbio;
49 /* while we're doing rmw on a stripe
50 * we put it into a hash table so we can
51 * lock the stripe and merge more rbios
54 struct list_head hash_list;
57 * LRU list for the stripe cache
59 struct list_head stripe_cache;
62 * for scheduling work in the helper threads
64 struct btrfs_work work;
67 * bio list and bio_list_lock are used
68 * to add more bios into the stripe
69 * in hopes of avoiding the full rmw
71 struct bio_list bio_list;
72 spinlock_t bio_list_lock;
74 /* also protected by the bio_list_lock, the
75 * plug list is used by the plugging code
76 * to collect partial bios while plugged. The
77 * stripe locking code also uses it to hand off
78 * the stripe lock to the next pending IO
80 struct list_head plug_list;
83 * flags that tell us if it is safe to
88 /* size of each individual stripe on disk */
91 /* number of data stripes (no p/q) */
98 * set if we're doing a parity rebuild
99 * for a read from higher up, which is handled
100 * differently from a parity rebuild as part of
103 enum btrfs_rbio_ops operation;
105 /* first bad stripe */
108 /* second bad stripe (for raid6 use) */
113 * number of pages needed to represent the full
119 * size of all the bios in the bio_list. This
120 * helps us decide if the rbio maps to a full
129 atomic_t stripes_pending;
133 * these are two arrays of pointers. We allocate the
134 * rbio big enough to hold them both and setup their
135 * locations when the rbio is allocated
138 /* pointers to pages that we allocated for
139 * reading/writing stripes directly from the disk (including P/Q)
141 struct page **stripe_pages;
144 * pointers to the pages in the bio_list. Stored
145 * here for faster lookup
147 struct page **bio_pages;
150 * bitmap to record which horizontal stripe has data
152 unsigned long *dbitmap;
154 /* allocated with real_stripes-many pointers for finish_*() calls */
155 void **finish_pointers;
157 /* allocated with stripe_npages-many bits for finish_*() calls */
158 unsigned long *finish_pbitmap;
161 static int __raid56_parity_recover(struct btrfs_raid_bio *rbio);
162 static noinline void finish_rmw(struct btrfs_raid_bio *rbio);
163 static void rmw_work(struct btrfs_work *work);
164 static void read_rebuild_work(struct btrfs_work *work);
165 static int fail_bio_stripe(struct btrfs_raid_bio *rbio, struct bio *bio);
166 static int fail_rbio_index(struct btrfs_raid_bio *rbio, int failed);
167 static void __free_raid_bio(struct btrfs_raid_bio *rbio);
168 static void index_rbio_pages(struct btrfs_raid_bio *rbio);
169 static int alloc_rbio_pages(struct btrfs_raid_bio *rbio);
171 static noinline void finish_parity_scrub(struct btrfs_raid_bio *rbio,
173 static void scrub_parity_work(struct btrfs_work *work);
175 static void start_async_work(struct btrfs_raid_bio *rbio, btrfs_func_t work_func)
177 btrfs_init_work(&rbio->work, btrfs_rmw_helper, work_func, NULL, NULL);
178 btrfs_queue_work(rbio->fs_info->rmw_workers, &rbio->work);
182 * the stripe hash table is used for locking, and to collect
183 * bios in hopes of making a full stripe
185 int btrfs_alloc_stripe_hash_table(struct btrfs_fs_info *info)
187 struct btrfs_stripe_hash_table *table;
188 struct btrfs_stripe_hash_table *x;
189 struct btrfs_stripe_hash *cur;
190 struct btrfs_stripe_hash *h;
191 int num_entries = 1 << BTRFS_STRIPE_HASH_TABLE_BITS;
195 if (info->stripe_hash_table)
199 * The table is large, starting with order 4 and can go as high as
200 * order 7 in case lock debugging is turned on.
202 * Try harder to allocate and fallback to vmalloc to lower the chance
203 * of a failing mount.
205 table_size = sizeof(*table) + sizeof(*h) * num_entries;
206 table = kvzalloc(table_size, GFP_KERNEL);
210 spin_lock_init(&table->cache_lock);
211 INIT_LIST_HEAD(&table->stripe_cache);
215 for (i = 0; i < num_entries; i++) {
217 INIT_LIST_HEAD(&cur->hash_list);
218 spin_lock_init(&cur->lock);
221 x = cmpxchg(&info->stripe_hash_table, NULL, table);
228 * caching an rbio means to copy anything from the
229 * bio_pages array into the stripe_pages array. We
230 * use the page uptodate bit in the stripe cache array
231 * to indicate if it has valid data
233 * once the caching is done, we set the cache ready
236 static void cache_rbio_pages(struct btrfs_raid_bio *rbio)
243 ret = alloc_rbio_pages(rbio);
247 for (i = 0; i < rbio->nr_pages; i++) {
248 if (!rbio->bio_pages[i])
251 s = kmap(rbio->bio_pages[i]);
252 d = kmap(rbio->stripe_pages[i]);
256 kunmap(rbio->bio_pages[i]);
257 kunmap(rbio->stripe_pages[i]);
258 SetPageUptodate(rbio->stripe_pages[i]);
260 set_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
264 * we hash on the first logical address of the stripe
266 static int rbio_bucket(struct btrfs_raid_bio *rbio)
268 u64 num = rbio->bbio->raid_map[0];
271 * we shift down quite a bit. We're using byte
272 * addressing, and most of the lower bits are zeros.
273 * This tends to upset hash_64, and it consistently
274 * returns just one or two different values.
276 * shifting off the lower bits fixes things.
278 return hash_64(num >> 16, BTRFS_STRIPE_HASH_TABLE_BITS);
282 * stealing an rbio means taking all the uptodate pages from the stripe
283 * array in the source rbio and putting them into the destination rbio
285 static void steal_rbio(struct btrfs_raid_bio *src, struct btrfs_raid_bio *dest)
291 if (!test_bit(RBIO_CACHE_READY_BIT, &src->flags))
294 for (i = 0; i < dest->nr_pages; i++) {
295 s = src->stripe_pages[i];
296 if (!s || !PageUptodate(s)) {
300 d = dest->stripe_pages[i];
304 dest->stripe_pages[i] = s;
305 src->stripe_pages[i] = NULL;
310 * merging means we take the bio_list from the victim and
311 * splice it into the destination. The victim should
312 * be discarded afterwards.
314 * must be called with dest->rbio_list_lock held
316 static void merge_rbio(struct btrfs_raid_bio *dest,
317 struct btrfs_raid_bio *victim)
319 bio_list_merge(&dest->bio_list, &victim->bio_list);
320 dest->bio_list_bytes += victim->bio_list_bytes;
321 /* Also inherit the bitmaps from @victim. */
322 bitmap_or(dest->dbitmap, victim->dbitmap, dest->dbitmap,
323 dest->stripe_npages);
324 dest->generic_bio_cnt += victim->generic_bio_cnt;
325 bio_list_init(&victim->bio_list);
329 * used to prune items that are in the cache. The caller
330 * must hold the hash table lock.
332 static void __remove_rbio_from_cache(struct btrfs_raid_bio *rbio)
334 int bucket = rbio_bucket(rbio);
335 struct btrfs_stripe_hash_table *table;
336 struct btrfs_stripe_hash *h;
340 * check the bit again under the hash table lock.
342 if (!test_bit(RBIO_CACHE_BIT, &rbio->flags))
345 table = rbio->fs_info->stripe_hash_table;
346 h = table->table + bucket;
348 /* hold the lock for the bucket because we may be
349 * removing it from the hash table
354 * hold the lock for the bio list because we need
355 * to make sure the bio list is empty
357 spin_lock(&rbio->bio_list_lock);
359 if (test_and_clear_bit(RBIO_CACHE_BIT, &rbio->flags)) {
360 list_del_init(&rbio->stripe_cache);
361 table->cache_size -= 1;
364 /* if the bio list isn't empty, this rbio is
365 * still involved in an IO. We take it out
366 * of the cache list, and drop the ref that
367 * was held for the list.
369 * If the bio_list was empty, we also remove
370 * the rbio from the hash_table, and drop
371 * the corresponding ref
373 if (bio_list_empty(&rbio->bio_list)) {
374 if (!list_empty(&rbio->hash_list)) {
375 list_del_init(&rbio->hash_list);
376 refcount_dec(&rbio->refs);
377 BUG_ON(!list_empty(&rbio->plug_list));
382 spin_unlock(&rbio->bio_list_lock);
383 spin_unlock(&h->lock);
386 __free_raid_bio(rbio);
390 * prune a given rbio from the cache
392 static void remove_rbio_from_cache(struct btrfs_raid_bio *rbio)
394 struct btrfs_stripe_hash_table *table;
397 if (!test_bit(RBIO_CACHE_BIT, &rbio->flags))
400 table = rbio->fs_info->stripe_hash_table;
402 spin_lock_irqsave(&table->cache_lock, flags);
403 __remove_rbio_from_cache(rbio);
404 spin_unlock_irqrestore(&table->cache_lock, flags);
408 * remove everything in the cache
410 static void btrfs_clear_rbio_cache(struct btrfs_fs_info *info)
412 struct btrfs_stripe_hash_table *table;
414 struct btrfs_raid_bio *rbio;
416 table = info->stripe_hash_table;
418 spin_lock_irqsave(&table->cache_lock, flags);
419 while (!list_empty(&table->stripe_cache)) {
420 rbio = list_entry(table->stripe_cache.next,
421 struct btrfs_raid_bio,
423 __remove_rbio_from_cache(rbio);
425 spin_unlock_irqrestore(&table->cache_lock, flags);
429 * remove all cached entries and free the hash table
432 void btrfs_free_stripe_hash_table(struct btrfs_fs_info *info)
434 if (!info->stripe_hash_table)
436 btrfs_clear_rbio_cache(info);
437 kvfree(info->stripe_hash_table);
438 info->stripe_hash_table = NULL;
442 * insert an rbio into the stripe cache. It
443 * must have already been prepared by calling
446 * If this rbio was already cached, it gets
447 * moved to the front of the lru.
449 * If the size of the rbio cache is too big, we
452 static void cache_rbio(struct btrfs_raid_bio *rbio)
454 struct btrfs_stripe_hash_table *table;
457 if (!test_bit(RBIO_CACHE_READY_BIT, &rbio->flags))
460 table = rbio->fs_info->stripe_hash_table;
462 spin_lock_irqsave(&table->cache_lock, flags);
463 spin_lock(&rbio->bio_list_lock);
465 /* bump our ref if we were not in the list before */
466 if (!test_and_set_bit(RBIO_CACHE_BIT, &rbio->flags))
467 refcount_inc(&rbio->refs);
469 if (!list_empty(&rbio->stripe_cache)){
470 list_move(&rbio->stripe_cache, &table->stripe_cache);
472 list_add(&rbio->stripe_cache, &table->stripe_cache);
473 table->cache_size += 1;
476 spin_unlock(&rbio->bio_list_lock);
478 if (table->cache_size > RBIO_CACHE_SIZE) {
479 struct btrfs_raid_bio *found;
481 found = list_entry(table->stripe_cache.prev,
482 struct btrfs_raid_bio,
486 __remove_rbio_from_cache(found);
489 spin_unlock_irqrestore(&table->cache_lock, flags);
493 * helper function to run the xor_blocks api. It is only
494 * able to do MAX_XOR_BLOCKS at a time, so we need to
497 static void run_xor(void **pages, int src_cnt, ssize_t len)
501 void *dest = pages[src_cnt];
504 xor_src_cnt = min(src_cnt, MAX_XOR_BLOCKS);
505 xor_blocks(xor_src_cnt, len, dest, pages + src_off);
507 src_cnt -= xor_src_cnt;
508 src_off += xor_src_cnt;
513 * Returns true if the bio list inside this rbio covers an entire stripe (no
516 static int rbio_is_full(struct btrfs_raid_bio *rbio)
519 unsigned long size = rbio->bio_list_bytes;
522 spin_lock_irqsave(&rbio->bio_list_lock, flags);
523 if (size != rbio->nr_data * rbio->stripe_len)
525 BUG_ON(size > rbio->nr_data * rbio->stripe_len);
526 spin_unlock_irqrestore(&rbio->bio_list_lock, flags);
532 * returns 1 if it is safe to merge two rbios together.
533 * The merging is safe if the two rbios correspond to
534 * the same stripe and if they are both going in the same
535 * direction (read vs write), and if neither one is
536 * locked for final IO
538 * The caller is responsible for locking such that
539 * rmw_locked is safe to test
541 static int rbio_can_merge(struct btrfs_raid_bio *last,
542 struct btrfs_raid_bio *cur)
544 if (test_bit(RBIO_RMW_LOCKED_BIT, &last->flags) ||
545 test_bit(RBIO_RMW_LOCKED_BIT, &cur->flags))
549 * we can't merge with cached rbios, since the
550 * idea is that when we merge the destination
551 * rbio is going to run our IO for us. We can
552 * steal from cached rbios though, other functions
555 if (test_bit(RBIO_CACHE_BIT, &last->flags) ||
556 test_bit(RBIO_CACHE_BIT, &cur->flags))
559 if (last->bbio->raid_map[0] !=
560 cur->bbio->raid_map[0])
563 /* we can't merge with different operations */
564 if (last->operation != cur->operation)
567 * We've need read the full stripe from the drive.
568 * check and repair the parity and write the new results.
570 * We're not allowed to add any new bios to the
571 * bio list here, anyone else that wants to
572 * change this stripe needs to do their own rmw.
574 if (last->operation == BTRFS_RBIO_PARITY_SCRUB)
577 if (last->operation == BTRFS_RBIO_REBUILD_MISSING)
580 if (last->operation == BTRFS_RBIO_READ_REBUILD) {
581 int fa = last->faila;
582 int fb = last->failb;
583 int cur_fa = cur->faila;
584 int cur_fb = cur->failb;
586 if (last->faila >= last->failb) {
591 if (cur->faila >= cur->failb) {
596 if (fa != cur_fa || fb != cur_fb)
602 static int rbio_stripe_page_index(struct btrfs_raid_bio *rbio, int stripe,
605 return stripe * rbio->stripe_npages + index;
609 * these are just the pages from the rbio array, not from anything
610 * the FS sent down to us
612 static struct page *rbio_stripe_page(struct btrfs_raid_bio *rbio, int stripe,
615 return rbio->stripe_pages[rbio_stripe_page_index(rbio, stripe, index)];
619 * helper to index into the pstripe
621 static struct page *rbio_pstripe_page(struct btrfs_raid_bio *rbio, int index)
623 return rbio_stripe_page(rbio, rbio->nr_data, index);
627 * helper to index into the qstripe, returns null
628 * if there is no qstripe
630 static struct page *rbio_qstripe_page(struct btrfs_raid_bio *rbio, int index)
632 if (rbio->nr_data + 1 == rbio->real_stripes)
634 return rbio_stripe_page(rbio, rbio->nr_data + 1, index);
638 * The first stripe in the table for a logical address
639 * has the lock. rbios are added in one of three ways:
641 * 1) Nobody has the stripe locked yet. The rbio is given
642 * the lock and 0 is returned. The caller must start the IO
645 * 2) Someone has the stripe locked, but we're able to merge
646 * with the lock owner. The rbio is freed and the IO will
647 * start automatically along with the existing rbio. 1 is returned.
649 * 3) Someone has the stripe locked, but we're not able to merge.
650 * The rbio is added to the lock owner's plug list, or merged into
651 * an rbio already on the plug list. When the lock owner unlocks,
652 * the next rbio on the list is run and the IO is started automatically.
655 * If we return 0, the caller still owns the rbio and must continue with
656 * IO submission. If we return 1, the caller must assume the rbio has
657 * already been freed.
659 static noinline int lock_stripe_add(struct btrfs_raid_bio *rbio)
661 int bucket = rbio_bucket(rbio);
662 struct btrfs_stripe_hash *h = rbio->fs_info->stripe_hash_table->table + bucket;
663 struct btrfs_raid_bio *cur;
664 struct btrfs_raid_bio *pending;
666 struct btrfs_raid_bio *freeit = NULL;
667 struct btrfs_raid_bio *cache_drop = NULL;
670 spin_lock_irqsave(&h->lock, flags);
671 list_for_each_entry(cur, &h->hash_list, hash_list) {
672 if (cur->bbio->raid_map[0] == rbio->bbio->raid_map[0]) {
673 spin_lock(&cur->bio_list_lock);
675 /* can we steal this cached rbio's pages? */
676 if (bio_list_empty(&cur->bio_list) &&
677 list_empty(&cur->plug_list) &&
678 test_bit(RBIO_CACHE_BIT, &cur->flags) &&
679 !test_bit(RBIO_RMW_LOCKED_BIT, &cur->flags)) {
680 list_del_init(&cur->hash_list);
681 refcount_dec(&cur->refs);
683 steal_rbio(cur, rbio);
685 spin_unlock(&cur->bio_list_lock);
690 /* can we merge into the lock owner? */
691 if (rbio_can_merge(cur, rbio)) {
692 merge_rbio(cur, rbio);
693 spin_unlock(&cur->bio_list_lock);
701 * we couldn't merge with the running
702 * rbio, see if we can merge with the
703 * pending ones. We don't have to
704 * check for rmw_locked because there
705 * is no way they are inside finish_rmw
708 list_for_each_entry(pending, &cur->plug_list,
710 if (rbio_can_merge(pending, rbio)) {
711 merge_rbio(pending, rbio);
712 spin_unlock(&cur->bio_list_lock);
719 /* no merging, put us on the tail of the plug list,
720 * our rbio will be started with the currently
721 * running rbio unlocks
723 list_add_tail(&rbio->plug_list, &cur->plug_list);
724 spin_unlock(&cur->bio_list_lock);
730 refcount_inc(&rbio->refs);
731 list_add(&rbio->hash_list, &h->hash_list);
733 spin_unlock_irqrestore(&h->lock, flags);
735 remove_rbio_from_cache(cache_drop);
737 __free_raid_bio(freeit);
742 * called as rmw or parity rebuild is completed. If the plug list has more
743 * rbios waiting for this stripe, the next one on the list will be started
745 static noinline void unlock_stripe(struct btrfs_raid_bio *rbio)
748 struct btrfs_stripe_hash *h;
752 bucket = rbio_bucket(rbio);
753 h = rbio->fs_info->stripe_hash_table->table + bucket;
755 if (list_empty(&rbio->plug_list))
758 spin_lock_irqsave(&h->lock, flags);
759 spin_lock(&rbio->bio_list_lock);
761 if (!list_empty(&rbio->hash_list)) {
763 * if we're still cached and there is no other IO
764 * to perform, just leave this rbio here for others
765 * to steal from later
767 if (list_empty(&rbio->plug_list) &&
768 test_bit(RBIO_CACHE_BIT, &rbio->flags)) {
770 clear_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
771 BUG_ON(!bio_list_empty(&rbio->bio_list));
775 list_del_init(&rbio->hash_list);
776 refcount_dec(&rbio->refs);
779 * we use the plug list to hold all the rbios
780 * waiting for the chance to lock this stripe.
781 * hand the lock over to one of them.
783 if (!list_empty(&rbio->plug_list)) {
784 struct btrfs_raid_bio *next;
785 struct list_head *head = rbio->plug_list.next;
787 next = list_entry(head, struct btrfs_raid_bio,
790 list_del_init(&rbio->plug_list);
792 list_add(&next->hash_list, &h->hash_list);
793 refcount_inc(&next->refs);
794 spin_unlock(&rbio->bio_list_lock);
795 spin_unlock_irqrestore(&h->lock, flags);
797 if (next->operation == BTRFS_RBIO_READ_REBUILD)
798 start_async_work(next, read_rebuild_work);
799 else if (next->operation == BTRFS_RBIO_REBUILD_MISSING) {
800 steal_rbio(rbio, next);
801 start_async_work(next, read_rebuild_work);
802 } else if (next->operation == BTRFS_RBIO_WRITE) {
803 steal_rbio(rbio, next);
804 start_async_work(next, rmw_work);
805 } else if (next->operation == BTRFS_RBIO_PARITY_SCRUB) {
806 steal_rbio(rbio, next);
807 start_async_work(next, scrub_parity_work);
814 spin_unlock(&rbio->bio_list_lock);
815 spin_unlock_irqrestore(&h->lock, flags);
819 remove_rbio_from_cache(rbio);
822 static void __free_raid_bio(struct btrfs_raid_bio *rbio)
826 if (!refcount_dec_and_test(&rbio->refs))
829 WARN_ON(!list_empty(&rbio->stripe_cache));
830 WARN_ON(!list_empty(&rbio->hash_list));
831 WARN_ON(!bio_list_empty(&rbio->bio_list));
833 for (i = 0; i < rbio->nr_pages; i++) {
834 if (rbio->stripe_pages[i]) {
835 __free_page(rbio->stripe_pages[i]);
836 rbio->stripe_pages[i] = NULL;
840 btrfs_put_bbio(rbio->bbio);
844 static void rbio_endio_bio_list(struct bio *cur, blk_status_t err)
851 cur->bi_status = err;
858 * this frees the rbio and runs through all the bios in the
859 * bio_list and calls end_io on them
861 static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, blk_status_t err)
863 struct bio *cur = bio_list_get(&rbio->bio_list);
866 if (rbio->generic_bio_cnt)
867 btrfs_bio_counter_sub(rbio->fs_info, rbio->generic_bio_cnt);
869 * Clear the data bitmap, as the rbio may be cached for later usage.
870 * do this before before unlock_stripe() so there will be no new bio
873 bitmap_clear(rbio->dbitmap, 0, rbio->stripe_npages);
876 * At this moment, rbio->bio_list is empty, however since rbio does not
877 * always have RBIO_RMW_LOCKED_BIT set and rbio is still linked on the
878 * hash list, rbio may be merged with others so that rbio->bio_list
880 * Once unlock_stripe() is done, rbio->bio_list will not be updated any
881 * more and we can call bio_endio() on all queued bios.
884 extra = bio_list_get(&rbio->bio_list);
885 __free_raid_bio(rbio);
887 rbio_endio_bio_list(cur, err);
889 rbio_endio_bio_list(extra, err);
893 * end io function used by finish_rmw. When we finally
894 * get here, we've written a full stripe
896 static void raid_write_end_io(struct bio *bio)
898 struct btrfs_raid_bio *rbio = bio->bi_private;
899 blk_status_t err = bio->bi_status;
903 fail_bio_stripe(rbio, bio);
907 if (!atomic_dec_and_test(&rbio->stripes_pending))
912 /* OK, we have read all the stripes we need to. */
913 max_errors = (rbio->operation == BTRFS_RBIO_PARITY_SCRUB) ?
914 0 : rbio->bbio->max_errors;
915 if (atomic_read(&rbio->error) > max_errors)
918 rbio_orig_end_io(rbio, err);
922 * the read/modify/write code wants to use the original bio for
923 * any pages it included, and then use the rbio for everything
924 * else. This function decides if a given index (stripe number)
925 * and page number in that stripe fall inside the original bio
928 * if you set bio_list_only, you'll get a NULL back for any ranges
929 * that are outside the bio_list
931 * This doesn't take any refs on anything, you get a bare page pointer
932 * and the caller must bump refs as required.
934 * You must call index_rbio_pages once before you can trust
935 * the answers from this function.
937 static struct page *page_in_rbio(struct btrfs_raid_bio *rbio,
938 int index, int pagenr, int bio_list_only)
941 struct page *p = NULL;
943 chunk_page = index * (rbio->stripe_len >> PAGE_SHIFT) + pagenr;
945 spin_lock_irq(&rbio->bio_list_lock);
946 p = rbio->bio_pages[chunk_page];
947 spin_unlock_irq(&rbio->bio_list_lock);
949 if (p || bio_list_only)
952 return rbio->stripe_pages[chunk_page];
956 * number of pages we need for the entire stripe across all the
959 static unsigned long rbio_nr_pages(unsigned long stripe_len, int nr_stripes)
961 return DIV_ROUND_UP(stripe_len, PAGE_SIZE) * nr_stripes;
965 * allocation and initial setup for the btrfs_raid_bio. Not
966 * this does not allocate any pages for rbio->pages.
968 static struct btrfs_raid_bio *alloc_rbio(struct btrfs_fs_info *fs_info,
969 struct btrfs_bio *bbio,
972 struct btrfs_raid_bio *rbio;
974 int real_stripes = bbio->num_stripes - bbio->num_tgtdevs;
975 int num_pages = rbio_nr_pages(stripe_len, real_stripes);
976 int stripe_npages = DIV_ROUND_UP(stripe_len, PAGE_SIZE);
979 rbio = kzalloc(sizeof(*rbio) +
980 sizeof(*rbio->stripe_pages) * num_pages +
981 sizeof(*rbio->bio_pages) * num_pages +
982 sizeof(*rbio->finish_pointers) * real_stripes +
983 sizeof(*rbio->dbitmap) * BITS_TO_LONGS(stripe_npages) +
984 sizeof(*rbio->finish_pbitmap) *
985 BITS_TO_LONGS(stripe_npages),
988 return ERR_PTR(-ENOMEM);
990 bio_list_init(&rbio->bio_list);
991 INIT_LIST_HEAD(&rbio->plug_list);
992 spin_lock_init(&rbio->bio_list_lock);
993 INIT_LIST_HEAD(&rbio->stripe_cache);
994 INIT_LIST_HEAD(&rbio->hash_list);
996 rbio->fs_info = fs_info;
997 rbio->stripe_len = stripe_len;
998 rbio->nr_pages = num_pages;
999 rbio->real_stripes = real_stripes;
1000 rbio->stripe_npages = stripe_npages;
1003 refcount_set(&rbio->refs, 1);
1004 atomic_set(&rbio->error, 0);
1005 atomic_set(&rbio->stripes_pending, 0);
1008 * the stripe_pages, bio_pages, etc arrays point to the extra
1009 * memory we allocated past the end of the rbio
1012 #define CONSUME_ALLOC(ptr, count) do { \
1014 p = (unsigned char *)p + sizeof(*(ptr)) * (count); \
1016 CONSUME_ALLOC(rbio->stripe_pages, num_pages);
1017 CONSUME_ALLOC(rbio->bio_pages, num_pages);
1018 CONSUME_ALLOC(rbio->finish_pointers, real_stripes);
1019 CONSUME_ALLOC(rbio->dbitmap, BITS_TO_LONGS(stripe_npages));
1020 CONSUME_ALLOC(rbio->finish_pbitmap, BITS_TO_LONGS(stripe_npages));
1021 #undef CONSUME_ALLOC
1023 if (bbio->map_type & BTRFS_BLOCK_GROUP_RAID5)
1024 nr_data = real_stripes - 1;
1025 else if (bbio->map_type & BTRFS_BLOCK_GROUP_RAID6)
1026 nr_data = real_stripes - 2;
1030 rbio->nr_data = nr_data;
1034 /* allocate pages for all the stripes in the bio, including parity */
1035 static int alloc_rbio_pages(struct btrfs_raid_bio *rbio)
1040 for (i = 0; i < rbio->nr_pages; i++) {
1041 if (rbio->stripe_pages[i])
1043 page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
1046 rbio->stripe_pages[i] = page;
1051 /* only allocate pages for p/q stripes */
1052 static int alloc_rbio_parity_pages(struct btrfs_raid_bio *rbio)
1057 i = rbio_stripe_page_index(rbio, rbio->nr_data, 0);
1059 for (; i < rbio->nr_pages; i++) {
1060 if (rbio->stripe_pages[i])
1062 page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
1065 rbio->stripe_pages[i] = page;
1071 * add a single page from a specific stripe into our list of bios for IO
1072 * this will try to merge into existing bios if possible, and returns
1073 * zero if all went well.
1075 static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
1076 struct bio_list *bio_list,
1079 unsigned long page_index,
1080 unsigned long bio_max_len)
1082 struct bio *last = bio_list->tail;
1086 struct btrfs_bio_stripe *stripe;
1089 stripe = &rbio->bbio->stripes[stripe_nr];
1090 disk_start = stripe->physical + (page_index << PAGE_SHIFT);
1092 /* if the device is missing, just fail this stripe */
1093 if (!stripe->dev->bdev)
1094 return fail_rbio_index(rbio, stripe_nr);
1096 /* see if we can add this page onto our existing bio */
1098 last_end = (u64)last->bi_iter.bi_sector << 9;
1099 last_end += last->bi_iter.bi_size;
1102 * we can't merge these if they are from different
1103 * devices or if they are not contiguous
1105 if (last_end == disk_start && stripe->dev->bdev &&
1107 last->bi_disk == stripe->dev->bdev->bd_disk &&
1108 last->bi_partno == stripe->dev->bdev->bd_partno) {
1109 ret = bio_add_page(last, page, PAGE_SIZE, 0);
1110 if (ret == PAGE_SIZE)
1115 /* put a new bio on the list */
1116 bio = btrfs_io_bio_alloc(bio_max_len >> PAGE_SHIFT ?: 1);
1117 bio->bi_iter.bi_size = 0;
1118 bio_set_dev(bio, stripe->dev->bdev);
1119 bio->bi_iter.bi_sector = disk_start >> 9;
1121 bio_add_page(bio, page, PAGE_SIZE, 0);
1122 bio_list_add(bio_list, bio);
1127 * while we're doing the read/modify/write cycle, we could
1128 * have errors in reading pages off the disk. This checks
1129 * for errors and if we're not able to read the page it'll
1130 * trigger parity reconstruction. The rmw will be finished
1131 * after we've reconstructed the failed stripes
1133 static void validate_rbio_for_rmw(struct btrfs_raid_bio *rbio)
1135 if (rbio->faila >= 0 || rbio->failb >= 0) {
1136 BUG_ON(rbio->faila == rbio->real_stripes - 1);
1137 __raid56_parity_recover(rbio);
1144 * helper function to walk our bio list and populate the bio_pages array with
1145 * the result. This seems expensive, but it is faster than constantly
1146 * searching through the bio list as we setup the IO in finish_rmw or stripe
1149 * This must be called before you trust the answers from page_in_rbio
1151 static void index_rbio_pages(struct btrfs_raid_bio *rbio)
1155 unsigned long stripe_offset;
1156 unsigned long page_index;
1158 spin_lock_irq(&rbio->bio_list_lock);
1159 bio_list_for_each(bio, &rbio->bio_list) {
1160 struct bio_vec bvec;
1161 struct bvec_iter iter;
1164 start = (u64)bio->bi_iter.bi_sector << 9;
1165 stripe_offset = start - rbio->bbio->raid_map[0];
1166 page_index = stripe_offset >> PAGE_SHIFT;
1168 if (bio_flagged(bio, BIO_CLONED))
1169 bio->bi_iter = btrfs_io_bio(bio)->iter;
1171 bio_for_each_segment(bvec, bio, iter) {
1172 rbio->bio_pages[page_index + i] = bvec.bv_page;
1176 spin_unlock_irq(&rbio->bio_list_lock);
1180 * this is called from one of two situations. We either
1181 * have a full stripe from the higher layers, or we've read all
1182 * the missing bits off disk.
1184 * This will calculate the parity and then send down any
1187 static noinline void finish_rmw(struct btrfs_raid_bio *rbio)
1189 struct btrfs_bio *bbio = rbio->bbio;
1190 void **pointers = rbio->finish_pointers;
1191 int nr_data = rbio->nr_data;
1195 struct bio_list bio_list;
1199 bio_list_init(&bio_list);
1201 if (rbio->real_stripes - rbio->nr_data == 1)
1202 has_qstripe = false;
1203 else if (rbio->real_stripes - rbio->nr_data == 2)
1208 /* We should have at least one data sector. */
1209 ASSERT(bitmap_weight(rbio->dbitmap, rbio->stripe_npages));
1211 /* at this point we either have a full stripe,
1212 * or we've read the full stripe from the drive.
1213 * recalculate the parity and write the new results.
1215 * We're not allowed to add any new bios to the
1216 * bio list here, anyone else that wants to
1217 * change this stripe needs to do their own rmw.
1219 spin_lock_irq(&rbio->bio_list_lock);
1220 set_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
1221 spin_unlock_irq(&rbio->bio_list_lock);
1223 atomic_set(&rbio->error, 0);
1226 * now that we've set rmw_locked, run through the
1227 * bio list one last time and map the page pointers
1229 * We don't cache full rbios because we're assuming
1230 * the higher layers are unlikely to use this area of
1231 * the disk again soon. If they do use it again,
1232 * hopefully they will send another full bio.
1234 index_rbio_pages(rbio);
1235 if (!rbio_is_full(rbio))
1236 cache_rbio_pages(rbio);
1238 clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
1240 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
1242 /* first collect one page from each data stripe */
1243 for (stripe = 0; stripe < nr_data; stripe++) {
1244 p = page_in_rbio(rbio, stripe, pagenr, 0);
1245 pointers[stripe] = kmap(p);
1248 /* then add the parity stripe */
1249 p = rbio_pstripe_page(rbio, pagenr);
1251 pointers[stripe++] = kmap(p);
1256 * raid6, add the qstripe and call the
1257 * library function to fill in our p/q
1259 p = rbio_qstripe_page(rbio, pagenr);
1261 pointers[stripe++] = kmap(p);
1263 raid6_call.gen_syndrome(rbio->real_stripes, PAGE_SIZE,
1267 copy_page(pointers[nr_data], pointers[0]);
1268 run_xor(pointers + 1, nr_data - 1, PAGE_SIZE);
1272 for (stripe = 0; stripe < rbio->real_stripes; stripe++)
1273 kunmap(page_in_rbio(rbio, stripe, pagenr, 0));
1277 * time to start writing. Make bios for everything from the
1278 * higher layers (the bio_list in our rbio) and our p/q. Ignore
1281 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
1282 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
1285 /* This vertical stripe has no data, skip it. */
1286 if (!test_bit(pagenr, rbio->dbitmap))
1289 if (stripe < rbio->nr_data) {
1290 page = page_in_rbio(rbio, stripe, pagenr, 1);
1294 page = rbio_stripe_page(rbio, stripe, pagenr);
1297 ret = rbio_add_io_page(rbio, &bio_list,
1298 page, stripe, pagenr, rbio->stripe_len);
1304 if (likely(!bbio->num_tgtdevs))
1307 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
1308 if (!bbio->tgtdev_map[stripe])
1311 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
1314 /* This vertical stripe has no data, skip it. */
1315 if (!test_bit(pagenr, rbio->dbitmap))
1318 if (stripe < rbio->nr_data) {
1319 page = page_in_rbio(rbio, stripe, pagenr, 1);
1323 page = rbio_stripe_page(rbio, stripe, pagenr);
1326 ret = rbio_add_io_page(rbio, &bio_list, page,
1327 rbio->bbio->tgtdev_map[stripe],
1328 pagenr, rbio->stripe_len);
1335 atomic_set(&rbio->stripes_pending, bio_list_size(&bio_list));
1336 BUG_ON(atomic_read(&rbio->stripes_pending) == 0);
1339 bio = bio_list_pop(&bio_list);
1343 bio->bi_private = rbio;
1344 bio->bi_end_io = raid_write_end_io;
1345 bio->bi_opf = REQ_OP_WRITE;
1352 rbio_orig_end_io(rbio, BLK_STS_IOERR);
1354 while ((bio = bio_list_pop(&bio_list)))
1359 * helper to find the stripe number for a given bio. Used to figure out which
1360 * stripe has failed. This expects the bio to correspond to a physical disk,
1361 * so it looks up based on physical sector numbers.
1363 static int find_bio_stripe(struct btrfs_raid_bio *rbio,
1366 u64 physical = bio->bi_iter.bi_sector;
1369 struct btrfs_bio_stripe *stripe;
1373 for (i = 0; i < rbio->bbio->num_stripes; i++) {
1374 stripe = &rbio->bbio->stripes[i];
1375 stripe_start = stripe->physical;
1376 if (physical >= stripe_start &&
1377 physical < stripe_start + rbio->stripe_len &&
1378 stripe->dev->bdev &&
1379 bio->bi_disk == stripe->dev->bdev->bd_disk &&
1380 bio->bi_partno == stripe->dev->bdev->bd_partno) {
1388 * helper to find the stripe number for a given
1389 * bio (before mapping). Used to figure out which stripe has
1390 * failed. This looks up based on logical block numbers.
1392 static int find_logical_bio_stripe(struct btrfs_raid_bio *rbio,
1395 u64 logical = bio->bi_iter.bi_sector;
1401 for (i = 0; i < rbio->nr_data; i++) {
1402 stripe_start = rbio->bbio->raid_map[i];
1403 if (logical >= stripe_start &&
1404 logical < stripe_start + rbio->stripe_len) {
1412 * returns -EIO if we had too many failures
1414 static int fail_rbio_index(struct btrfs_raid_bio *rbio, int failed)
1416 unsigned long flags;
1419 spin_lock_irqsave(&rbio->bio_list_lock, flags);
1421 /* we already know this stripe is bad, move on */
1422 if (rbio->faila == failed || rbio->failb == failed)
1425 if (rbio->faila == -1) {
1426 /* first failure on this rbio */
1427 rbio->faila = failed;
1428 atomic_inc(&rbio->error);
1429 } else if (rbio->failb == -1) {
1430 /* second failure on this rbio */
1431 rbio->failb = failed;
1432 atomic_inc(&rbio->error);
1437 spin_unlock_irqrestore(&rbio->bio_list_lock, flags);
1443 * helper to fail a stripe based on a physical disk
1446 static int fail_bio_stripe(struct btrfs_raid_bio *rbio,
1449 int failed = find_bio_stripe(rbio, bio);
1454 return fail_rbio_index(rbio, failed);
1458 * this sets each page in the bio uptodate. It should only be used on private
1459 * rbio pages, nothing that comes in from the higher layers
1461 static void set_bio_pages_uptodate(struct bio *bio)
1463 struct bio_vec *bvec;
1466 ASSERT(!bio_flagged(bio, BIO_CLONED));
1468 bio_for_each_segment_all(bvec, bio, i)
1469 SetPageUptodate(bvec->bv_page);
1473 * end io for the read phase of the rmw cycle. All the bios here are physical
1474 * stripe bios we've read from the disk so we can recalculate the parity of the
1477 * This will usually kick off finish_rmw once all the bios are read in, but it
1478 * may trigger parity reconstruction if we had any errors along the way
1480 static void raid_rmw_end_io(struct bio *bio)
1482 struct btrfs_raid_bio *rbio = bio->bi_private;
1485 fail_bio_stripe(rbio, bio);
1487 set_bio_pages_uptodate(bio);
1491 if (!atomic_dec_and_test(&rbio->stripes_pending))
1494 if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
1498 * this will normally call finish_rmw to start our write
1499 * but if there are any failed stripes we'll reconstruct
1502 validate_rbio_for_rmw(rbio);
1507 rbio_orig_end_io(rbio, BLK_STS_IOERR);
1511 * the stripe must be locked by the caller. It will
1512 * unlock after all the writes are done
1514 static int raid56_rmw_stripe(struct btrfs_raid_bio *rbio)
1516 int bios_to_read = 0;
1517 struct bio_list bio_list;
1523 bio_list_init(&bio_list);
1525 ret = alloc_rbio_pages(rbio);
1529 index_rbio_pages(rbio);
1531 atomic_set(&rbio->error, 0);
1533 * build a list of bios to read all the missing parts of this
1536 for (stripe = 0; stripe < rbio->nr_data; stripe++) {
1537 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
1540 * we want to find all the pages missing from
1541 * the rbio and read them from the disk. If
1542 * page_in_rbio finds a page in the bio list
1543 * we don't need to read it off the stripe.
1545 page = page_in_rbio(rbio, stripe, pagenr, 1);
1549 page = rbio_stripe_page(rbio, stripe, pagenr);
1551 * the bio cache may have handed us an uptodate
1552 * page. If so, be happy and use it
1554 if (PageUptodate(page))
1557 ret = rbio_add_io_page(rbio, &bio_list, page,
1558 stripe, pagenr, rbio->stripe_len);
1564 bios_to_read = bio_list_size(&bio_list);
1565 if (!bios_to_read) {
1567 * this can happen if others have merged with
1568 * us, it means there is nothing left to read.
1569 * But if there are missing devices it may not be
1570 * safe to do the full stripe write yet.
1576 * the bbio may be freed once we submit the last bio. Make sure
1577 * not to touch it after that
1579 atomic_set(&rbio->stripes_pending, bios_to_read);
1581 bio = bio_list_pop(&bio_list);
1585 bio->bi_private = rbio;
1586 bio->bi_end_io = raid_rmw_end_io;
1587 bio->bi_opf = REQ_OP_READ;
1589 btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
1593 /* the actual write will happen once the reads are done */
1597 rbio_orig_end_io(rbio, BLK_STS_IOERR);
1599 while ((bio = bio_list_pop(&bio_list)))
1605 validate_rbio_for_rmw(rbio);
1610 * if the upper layers pass in a full stripe, we thank them by only allocating
1611 * enough pages to hold the parity, and sending it all down quickly.
1613 static int full_stripe_write(struct btrfs_raid_bio *rbio)
1617 ret = alloc_rbio_parity_pages(rbio);
1619 __free_raid_bio(rbio);
1623 ret = lock_stripe_add(rbio);
1630 * partial stripe writes get handed over to async helpers.
1631 * We're really hoping to merge a few more writes into this
1632 * rbio before calculating new parity
1634 static int partial_stripe_write(struct btrfs_raid_bio *rbio)
1638 ret = lock_stripe_add(rbio);
1640 start_async_work(rbio, rmw_work);
1645 * sometimes while we were reading from the drive to
1646 * recalculate parity, enough new bios come into create
1647 * a full stripe. So we do a check here to see if we can
1648 * go directly to finish_rmw
1650 static int __raid56_parity_write(struct btrfs_raid_bio *rbio)
1652 /* head off into rmw land if we don't have a full stripe */
1653 if (!rbio_is_full(rbio))
1654 return partial_stripe_write(rbio);
1655 return full_stripe_write(rbio);
1659 * We use plugging call backs to collect full stripes.
1660 * Any time we get a partial stripe write while plugged
1661 * we collect it into a list. When the unplug comes down,
1662 * we sort the list by logical block number and merge
1663 * everything we can into the same rbios
1665 struct btrfs_plug_cb {
1666 struct blk_plug_cb cb;
1667 struct btrfs_fs_info *info;
1668 struct list_head rbio_list;
1669 struct btrfs_work work;
1673 * rbios on the plug list are sorted for easier merging.
1675 static int plug_cmp(void *priv, struct list_head *a, struct list_head *b)
1677 struct btrfs_raid_bio *ra = container_of(a, struct btrfs_raid_bio,
1679 struct btrfs_raid_bio *rb = container_of(b, struct btrfs_raid_bio,
1681 u64 a_sector = ra->bio_list.head->bi_iter.bi_sector;
1682 u64 b_sector = rb->bio_list.head->bi_iter.bi_sector;
1684 if (a_sector < b_sector)
1686 if (a_sector > b_sector)
1691 static void run_plug(struct btrfs_plug_cb *plug)
1693 struct btrfs_raid_bio *cur;
1694 struct btrfs_raid_bio *last = NULL;
1697 * sort our plug list then try to merge
1698 * everything we can in hopes of creating full
1701 list_sort(NULL, &plug->rbio_list, plug_cmp);
1702 while (!list_empty(&plug->rbio_list)) {
1703 cur = list_entry(plug->rbio_list.next,
1704 struct btrfs_raid_bio, plug_list);
1705 list_del_init(&cur->plug_list);
1707 if (rbio_is_full(cur)) {
1710 /* we have a full stripe, send it down */
1711 ret = full_stripe_write(cur);
1716 if (rbio_can_merge(last, cur)) {
1717 merge_rbio(last, cur);
1718 __free_raid_bio(cur);
1722 __raid56_parity_write(last);
1727 __raid56_parity_write(last);
1733 * if the unplug comes from schedule, we have to push the
1734 * work off to a helper thread
1736 static void unplug_work(struct btrfs_work *work)
1738 struct btrfs_plug_cb *plug;
1739 plug = container_of(work, struct btrfs_plug_cb, work);
1743 static void btrfs_raid_unplug(struct blk_plug_cb *cb, bool from_schedule)
1745 struct btrfs_plug_cb *plug;
1746 plug = container_of(cb, struct btrfs_plug_cb, cb);
1748 if (from_schedule) {
1749 btrfs_init_work(&plug->work, btrfs_rmw_helper,
1750 unplug_work, NULL, NULL);
1751 btrfs_queue_work(plug->info->rmw_workers,
1758 /* Add the original bio into rbio->bio_list, and update rbio::dbitmap. */
1759 static void rbio_add_bio(struct btrfs_raid_bio *rbio, struct bio *orig_bio)
1761 const struct btrfs_fs_info *fs_info = rbio->fs_info;
1762 const u64 orig_logical = orig_bio->bi_iter.bi_sector << SECTOR_SHIFT;
1763 const u64 full_stripe_start = rbio->bbio->raid_map[0];
1764 const u32 orig_len = orig_bio->bi_iter.bi_size;
1765 const u32 sectorsize = fs_info->sectorsize;
1768 ASSERT(orig_logical >= full_stripe_start &&
1769 orig_logical + orig_len <= full_stripe_start +
1770 rbio->nr_data * rbio->stripe_len);
1772 bio_list_add(&rbio->bio_list, orig_bio);
1773 rbio->bio_list_bytes += orig_bio->bi_iter.bi_size;
1775 /* Update the dbitmap. */
1776 for (cur_logical = orig_logical; cur_logical < orig_logical + orig_len;
1777 cur_logical += sectorsize) {
1778 int bit = ((u32)(cur_logical - full_stripe_start) >>
1779 PAGE_SHIFT) % rbio->stripe_npages;
1781 set_bit(bit, rbio->dbitmap);
1786 * our main entry point for writes from the rest of the FS.
1788 int raid56_parity_write(struct btrfs_fs_info *fs_info, struct bio *bio,
1789 struct btrfs_bio *bbio, u64 stripe_len)
1791 struct btrfs_raid_bio *rbio;
1792 struct btrfs_plug_cb *plug = NULL;
1793 struct blk_plug_cb *cb;
1796 rbio = alloc_rbio(fs_info, bbio, stripe_len);
1798 btrfs_put_bbio(bbio);
1799 return PTR_ERR(rbio);
1801 rbio->operation = BTRFS_RBIO_WRITE;
1802 rbio_add_bio(rbio, bio);
1804 btrfs_bio_counter_inc_noblocked(fs_info);
1805 rbio->generic_bio_cnt = 1;
1808 * don't plug on full rbios, just get them out the door
1809 * as quickly as we can
1811 if (rbio_is_full(rbio)) {
1812 ret = full_stripe_write(rbio);
1814 btrfs_bio_counter_dec(fs_info);
1818 cb = blk_check_plugged(btrfs_raid_unplug, fs_info, sizeof(*plug));
1820 plug = container_of(cb, struct btrfs_plug_cb, cb);
1822 plug->info = fs_info;
1823 INIT_LIST_HEAD(&plug->rbio_list);
1825 list_add_tail(&rbio->plug_list, &plug->rbio_list);
1828 ret = __raid56_parity_write(rbio);
1830 btrfs_bio_counter_dec(fs_info);
1836 * all parity reconstruction happens here. We've read in everything
1837 * we can find from the drives and this does the heavy lifting of
1838 * sorting the good from the bad.
1840 static void __raid_recover_end_io(struct btrfs_raid_bio *rbio)
1844 int faila = -1, failb = -1;
1849 pointers = kcalloc(rbio->real_stripes, sizeof(void *), GFP_NOFS);
1851 err = BLK_STS_RESOURCE;
1855 faila = rbio->faila;
1856 failb = rbio->failb;
1858 if (rbio->operation == BTRFS_RBIO_READ_REBUILD ||
1859 rbio->operation == BTRFS_RBIO_REBUILD_MISSING) {
1860 spin_lock_irq(&rbio->bio_list_lock);
1861 set_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
1862 spin_unlock_irq(&rbio->bio_list_lock);
1865 index_rbio_pages(rbio);
1867 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
1869 * Now we just use bitmap to mark the horizontal stripes in
1870 * which we have data when doing parity scrub.
1872 if (rbio->operation == BTRFS_RBIO_PARITY_SCRUB &&
1873 !test_bit(pagenr, rbio->dbitmap))
1876 /* setup our array of pointers with pages
1879 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
1881 * if we're rebuilding a read, we have to use
1882 * pages from the bio list
1884 if ((rbio->operation == BTRFS_RBIO_READ_REBUILD ||
1885 rbio->operation == BTRFS_RBIO_REBUILD_MISSING) &&
1886 (stripe == faila || stripe == failb)) {
1887 page = page_in_rbio(rbio, stripe, pagenr, 0);
1889 page = rbio_stripe_page(rbio, stripe, pagenr);
1891 pointers[stripe] = kmap(page);
1894 /* all raid6 handling here */
1895 if (rbio->bbio->map_type & BTRFS_BLOCK_GROUP_RAID6) {
1897 * single failure, rebuild from parity raid5
1901 if (faila == rbio->nr_data) {
1903 * Just the P stripe has failed, without
1904 * a bad data or Q stripe.
1905 * TODO, we should redo the xor here.
1907 err = BLK_STS_IOERR;
1911 * a single failure in raid6 is rebuilt
1912 * in the pstripe code below
1917 /* make sure our ps and qs are in order */
1918 if (faila > failb) {
1924 /* if the q stripe is failed, do a pstripe reconstruction
1926 * If both the q stripe and the P stripe are failed, we're
1927 * here due to a crc mismatch and we can't give them the
1930 if (rbio->bbio->raid_map[failb] == RAID6_Q_STRIPE) {
1931 if (rbio->bbio->raid_map[faila] ==
1933 err = BLK_STS_IOERR;
1937 * otherwise we have one bad data stripe and
1938 * a good P stripe. raid5!
1943 if (rbio->bbio->raid_map[failb] == RAID5_P_STRIPE) {
1944 raid6_datap_recov(rbio->real_stripes,
1945 PAGE_SIZE, faila, pointers);
1947 raid6_2data_recov(rbio->real_stripes,
1948 PAGE_SIZE, faila, failb,
1954 /* rebuild from P stripe here (raid5 or raid6) */
1955 BUG_ON(failb != -1);
1957 /* Copy parity block into failed block to start with */
1958 copy_page(pointers[faila], pointers[rbio->nr_data]);
1960 /* rearrange the pointer array */
1961 p = pointers[faila];
1962 for (stripe = faila; stripe < rbio->nr_data - 1; stripe++)
1963 pointers[stripe] = pointers[stripe + 1];
1964 pointers[rbio->nr_data - 1] = p;
1966 /* xor in the rest */
1967 run_xor(pointers, rbio->nr_data - 1, PAGE_SIZE);
1969 /* if we're doing this rebuild as part of an rmw, go through
1970 * and set all of our private rbio pages in the
1971 * failed stripes as uptodate. This way finish_rmw will
1972 * know they can be trusted. If this was a read reconstruction,
1973 * other endio functions will fiddle the uptodate bits
1975 if (rbio->operation == BTRFS_RBIO_WRITE) {
1976 for (i = 0; i < rbio->stripe_npages; i++) {
1978 page = rbio_stripe_page(rbio, faila, i);
1979 SetPageUptodate(page);
1982 page = rbio_stripe_page(rbio, failb, i);
1983 SetPageUptodate(page);
1987 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
1989 * if we're rebuilding a read, we have to use
1990 * pages from the bio list
1992 if ((rbio->operation == BTRFS_RBIO_READ_REBUILD ||
1993 rbio->operation == BTRFS_RBIO_REBUILD_MISSING) &&
1994 (stripe == faila || stripe == failb)) {
1995 page = page_in_rbio(rbio, stripe, pagenr, 0);
1997 page = rbio_stripe_page(rbio, stripe, pagenr);
2009 * Similar to READ_REBUILD, REBUILD_MISSING at this point also has a
2010 * valid rbio which is consistent with ondisk content, thus such a
2011 * valid rbio can be cached to avoid further disk reads.
2013 if (rbio->operation == BTRFS_RBIO_READ_REBUILD ||
2014 rbio->operation == BTRFS_RBIO_REBUILD_MISSING) {
2016 * - In case of two failures, where rbio->failb != -1:
2018 * Do not cache this rbio since the above read reconstruction
2019 * (raid6_datap_recov() or raid6_2data_recov()) may have
2020 * changed some content of stripes which are not identical to
2021 * on-disk content any more, otherwise, a later write/recover
2022 * may steal stripe_pages from this rbio and end up with
2023 * corruptions or rebuild failures.
2025 * - In case of single failure, where rbio->failb == -1:
2027 * Cache this rbio iff the above read reconstruction is
2028 * excuted without problems.
2030 if (err == BLK_STS_OK && rbio->failb < 0)
2031 cache_rbio_pages(rbio);
2033 clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
2035 rbio_orig_end_io(rbio, err);
2036 } else if (err == BLK_STS_OK) {
2040 if (rbio->operation == BTRFS_RBIO_WRITE)
2042 else if (rbio->operation == BTRFS_RBIO_PARITY_SCRUB)
2043 finish_parity_scrub(rbio, 0);
2047 rbio_orig_end_io(rbio, err);
2052 * This is called only for stripes we've read from disk to
2053 * reconstruct the parity.
2055 static void raid_recover_end_io(struct bio *bio)
2057 struct btrfs_raid_bio *rbio = bio->bi_private;
2060 * we only read stripe pages off the disk, set them
2061 * up to date if there were no errors
2064 fail_bio_stripe(rbio, bio);
2066 set_bio_pages_uptodate(bio);
2069 if (!atomic_dec_and_test(&rbio->stripes_pending))
2072 if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
2073 rbio_orig_end_io(rbio, BLK_STS_IOERR);
2075 __raid_recover_end_io(rbio);
2079 * reads everything we need off the disk to reconstruct
2080 * the parity. endio handlers trigger final reconstruction
2081 * when the IO is done.
2083 * This is used both for reads from the higher layers and for
2084 * parity construction required to finish a rmw cycle.
2086 static int __raid56_parity_recover(struct btrfs_raid_bio *rbio)
2088 int bios_to_read = 0;
2089 struct bio_list bio_list;
2095 bio_list_init(&bio_list);
2097 ret = alloc_rbio_pages(rbio);
2101 atomic_set(&rbio->error, 0);
2104 * Read everything that hasn't failed. However this time we will
2105 * not trust any cached sector.
2106 * As we may read out some stale data but higher layer is not reading
2109 * So here we always re-read everything in recovery path.
2111 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
2112 if (rbio->faila == stripe || rbio->failb == stripe) {
2113 atomic_inc(&rbio->error);
2117 for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
2118 ret = rbio_add_io_page(rbio, &bio_list,
2119 rbio_stripe_page(rbio, stripe, pagenr),
2120 stripe, pagenr, rbio->stripe_len);
2126 bios_to_read = bio_list_size(&bio_list);
2127 if (!bios_to_read) {
2129 * we might have no bios to read just because the pages
2130 * were up to date, or we might have no bios to read because
2131 * the devices were gone.
2133 if (atomic_read(&rbio->error) <= rbio->bbio->max_errors) {
2134 __raid_recover_end_io(rbio);
2142 * the bbio may be freed once we submit the last bio. Make sure
2143 * not to touch it after that
2145 atomic_set(&rbio->stripes_pending, bios_to_read);
2147 bio = bio_list_pop(&bio_list);
2151 bio->bi_private = rbio;
2152 bio->bi_end_io = raid_recover_end_io;
2153 bio->bi_opf = REQ_OP_READ;
2155 btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
2163 if (rbio->operation == BTRFS_RBIO_READ_REBUILD ||
2164 rbio->operation == BTRFS_RBIO_REBUILD_MISSING)
2165 rbio_orig_end_io(rbio, BLK_STS_IOERR);
2167 while ((bio = bio_list_pop(&bio_list)))
2174 * the main entry point for reads from the higher layers. This
2175 * is really only called when the normal read path had a failure,
2176 * so we assume the bio they send down corresponds to a failed part
2179 int raid56_parity_recover(struct btrfs_fs_info *fs_info, struct bio *bio,
2180 struct btrfs_bio *bbio, u64 stripe_len,
2181 int mirror_num, int generic_io)
2183 struct btrfs_raid_bio *rbio;
2187 ASSERT(bbio->mirror_num == mirror_num);
2188 btrfs_io_bio(bio)->mirror_num = mirror_num;
2191 rbio = alloc_rbio(fs_info, bbio, stripe_len);
2194 btrfs_put_bbio(bbio);
2195 return PTR_ERR(rbio);
2198 rbio->operation = BTRFS_RBIO_READ_REBUILD;
2199 rbio_add_bio(rbio, bio);
2201 rbio->faila = find_logical_bio_stripe(rbio, bio);
2202 if (rbio->faila == -1) {
2204 "%s could not find the bad stripe in raid56 so that we cannot recover any more (bio has logical %llu len %llu, bbio has map_type %llu)",
2205 __func__, (u64)bio->bi_iter.bi_sector << 9,
2206 (u64)bio->bi_iter.bi_size, bbio->map_type);
2208 btrfs_put_bbio(bbio);
2214 btrfs_bio_counter_inc_noblocked(fs_info);
2215 rbio->generic_bio_cnt = 1;
2217 btrfs_get_bbio(bbio);
2222 * for 'mirror == 2', reconstruct from all other stripes.
2223 * for 'mirror_num > 2', select a stripe to fail on every retry.
2225 if (mirror_num > 2) {
2227 * 'mirror == 3' is to fail the p stripe and
2228 * reconstruct from the q stripe. 'mirror > 3' is to
2229 * fail a data stripe and reconstruct from p+q stripe.
2231 rbio->failb = rbio->real_stripes - (mirror_num - 1);
2232 ASSERT(rbio->failb > 0);
2233 if (rbio->failb <= rbio->faila)
2237 ret = lock_stripe_add(rbio);
2240 * __raid56_parity_recover will end the bio with
2241 * any errors it hits. We don't want to return
2242 * its error value up the stack because our caller
2243 * will end up calling bio_endio with any nonzero
2247 __raid56_parity_recover(rbio);
2249 * our rbio has been added to the list of
2250 * rbios that will be handled after the
2251 * currently lock owner is done
2257 static void rmw_work(struct btrfs_work *work)
2259 struct btrfs_raid_bio *rbio;
2261 rbio = container_of(work, struct btrfs_raid_bio, work);
2262 raid56_rmw_stripe(rbio);
2265 static void read_rebuild_work(struct btrfs_work *work)
2267 struct btrfs_raid_bio *rbio;
2269 rbio = container_of(work, struct btrfs_raid_bio, work);
2270 __raid56_parity_recover(rbio);
2274 * The following code is used to scrub/replace the parity stripe
2276 * Caller must have already increased bio_counter for getting @bbio.
2278 * Note: We need make sure all the pages that add into the scrub/replace
2279 * raid bio are correct and not be changed during the scrub/replace. That
2280 * is those pages just hold metadata or file data with checksum.
2283 struct btrfs_raid_bio *
2284 raid56_parity_alloc_scrub_rbio(struct btrfs_fs_info *fs_info, struct bio *bio,
2285 struct btrfs_bio *bbio, u64 stripe_len,
2286 struct btrfs_device *scrub_dev,
2287 unsigned long *dbitmap, int stripe_nsectors)
2289 struct btrfs_raid_bio *rbio;
2292 rbio = alloc_rbio(fs_info, bbio, stripe_len);
2295 bio_list_add(&rbio->bio_list, bio);
2297 * This is a special bio which is used to hold the completion handler
2298 * and make the scrub rbio is similar to the other types
2300 ASSERT(!bio->bi_iter.bi_size);
2301 rbio->operation = BTRFS_RBIO_PARITY_SCRUB;
2304 * After mapping bbio with BTRFS_MAP_WRITE, parities have been sorted
2305 * to the end position, so this search can start from the first parity
2308 for (i = rbio->nr_data; i < rbio->real_stripes; i++) {
2309 if (bbio->stripes[i].dev == scrub_dev) {
2314 ASSERT(i < rbio->real_stripes);
2316 /* Now we just support the sectorsize equals to page size */
2317 ASSERT(fs_info->sectorsize == PAGE_SIZE);
2318 ASSERT(rbio->stripe_npages == stripe_nsectors);
2319 bitmap_copy(rbio->dbitmap, dbitmap, stripe_nsectors);
2322 * We have already increased bio_counter when getting bbio, record it
2323 * so we can free it at rbio_orig_end_io().
2325 rbio->generic_bio_cnt = 1;
2330 /* Used for both parity scrub and missing. */
2331 void raid56_add_scrub_pages(struct btrfs_raid_bio *rbio, struct page *page,
2337 ASSERT(logical >= rbio->bbio->raid_map[0]);
2338 ASSERT(logical + PAGE_SIZE <= rbio->bbio->raid_map[0] +
2339 rbio->stripe_len * rbio->nr_data);
2340 stripe_offset = (int)(logical - rbio->bbio->raid_map[0]);
2341 index = stripe_offset >> PAGE_SHIFT;
2342 rbio->bio_pages[index] = page;
2346 * We just scrub the parity that we have correct data on the same horizontal,
2347 * so we needn't allocate all pages for all the stripes.
2349 static int alloc_rbio_essential_pages(struct btrfs_raid_bio *rbio)
2356 for_each_set_bit(bit, rbio->dbitmap, rbio->stripe_npages) {
2357 for (i = 0; i < rbio->real_stripes; i++) {
2358 index = i * rbio->stripe_npages + bit;
2359 if (rbio->stripe_pages[index])
2362 page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
2365 rbio->stripe_pages[index] = page;
2371 static noinline void finish_parity_scrub(struct btrfs_raid_bio *rbio,
2374 struct btrfs_bio *bbio = rbio->bbio;
2375 void **pointers = rbio->finish_pointers;
2376 unsigned long *pbitmap = rbio->finish_pbitmap;
2377 int nr_data = rbio->nr_data;
2381 struct page *p_page = NULL;
2382 struct page *q_page = NULL;
2383 struct bio_list bio_list;
2388 bio_list_init(&bio_list);
2390 if (rbio->real_stripes - rbio->nr_data == 1)
2391 has_qstripe = false;
2392 else if (rbio->real_stripes - rbio->nr_data == 2)
2397 if (bbio->num_tgtdevs && bbio->tgtdev_map[rbio->scrubp]) {
2399 bitmap_copy(pbitmap, rbio->dbitmap, rbio->stripe_npages);
2403 * Because the higher layers(scrubber) are unlikely to
2404 * use this area of the disk again soon, so don't cache
2407 clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
2412 p_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
2415 SetPageUptodate(p_page);
2418 /* RAID6, allocate and map temp space for the Q stripe */
2419 q_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
2421 __free_page(p_page);
2424 SetPageUptodate(q_page);
2425 pointers[rbio->real_stripes - 1] = kmap(q_page);
2428 atomic_set(&rbio->error, 0);
2430 /* Map the parity stripe just once */
2431 pointers[nr_data] = kmap(p_page);
2433 for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
2436 /* first collect one page from each data stripe */
2437 for (stripe = 0; stripe < nr_data; stripe++) {
2438 p = page_in_rbio(rbio, stripe, pagenr, 0);
2439 pointers[stripe] = kmap(p);
2443 /* RAID6, call the library function to fill in our P/Q */
2444 raid6_call.gen_syndrome(rbio->real_stripes, PAGE_SIZE,
2448 copy_page(pointers[nr_data], pointers[0]);
2449 run_xor(pointers + 1, nr_data - 1, PAGE_SIZE);
2452 /* Check scrubbing parity and repair it */
2453 p = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
2455 if (memcmp(parity, pointers[rbio->scrubp], PAGE_SIZE))
2456 copy_page(parity, pointers[rbio->scrubp]);
2458 /* Parity is right, needn't writeback */
2459 bitmap_clear(rbio->dbitmap, pagenr, 1);
2462 for (stripe = 0; stripe < nr_data; stripe++)
2463 kunmap(page_in_rbio(rbio, stripe, pagenr, 0));
2467 __free_page(p_page);
2470 __free_page(q_page);
2475 * time to start writing. Make bios for everything from the
2476 * higher layers (the bio_list in our rbio) and our p/q. Ignore
2479 for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
2482 page = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
2483 ret = rbio_add_io_page(rbio, &bio_list,
2484 page, rbio->scrubp, pagenr, rbio->stripe_len);
2492 for_each_set_bit(pagenr, pbitmap, rbio->stripe_npages) {
2495 page = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
2496 ret = rbio_add_io_page(rbio, &bio_list, page,
2497 bbio->tgtdev_map[rbio->scrubp],
2498 pagenr, rbio->stripe_len);
2504 nr_data = bio_list_size(&bio_list);
2506 /* Every parity is right */
2507 rbio_orig_end_io(rbio, BLK_STS_OK);
2511 atomic_set(&rbio->stripes_pending, nr_data);
2514 bio = bio_list_pop(&bio_list);
2518 bio->bi_private = rbio;
2519 bio->bi_end_io = raid_write_end_io;
2520 bio->bi_opf = REQ_OP_WRITE;
2527 rbio_orig_end_io(rbio, BLK_STS_IOERR);
2529 while ((bio = bio_list_pop(&bio_list)))
2533 static inline int is_data_stripe(struct btrfs_raid_bio *rbio, int stripe)
2535 if (stripe >= 0 && stripe < rbio->nr_data)
2541 * While we're doing the parity check and repair, we could have errors
2542 * in reading pages off the disk. This checks for errors and if we're
2543 * not able to read the page it'll trigger parity reconstruction. The
2544 * parity scrub will be finished after we've reconstructed the failed
2547 static void validate_rbio_for_parity_scrub(struct btrfs_raid_bio *rbio)
2549 if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
2552 if (rbio->faila >= 0 || rbio->failb >= 0) {
2553 int dfail = 0, failp = -1;
2555 if (is_data_stripe(rbio, rbio->faila))
2557 else if (is_parity_stripe(rbio->faila))
2558 failp = rbio->faila;
2560 if (is_data_stripe(rbio, rbio->failb))
2562 else if (is_parity_stripe(rbio->failb))
2563 failp = rbio->failb;
2566 * Because we can not use a scrubbing parity to repair
2567 * the data, so the capability of the repair is declined.
2568 * (In the case of RAID5, we can not repair anything)
2570 if (dfail > rbio->bbio->max_errors - 1)
2574 * If all data is good, only parity is correctly, just
2575 * repair the parity.
2578 finish_parity_scrub(rbio, 0);
2583 * Here means we got one corrupted data stripe and one
2584 * corrupted parity on RAID6, if the corrupted parity
2585 * is scrubbing parity, luckily, use the other one to repair
2586 * the data, or we can not repair the data stripe.
2588 if (failp != rbio->scrubp)
2591 __raid_recover_end_io(rbio);
2593 finish_parity_scrub(rbio, 1);
2598 rbio_orig_end_io(rbio, BLK_STS_IOERR);
2602 * end io for the read phase of the rmw cycle. All the bios here are physical
2603 * stripe bios we've read from the disk so we can recalculate the parity of the
2606 * This will usually kick off finish_rmw once all the bios are read in, but it
2607 * may trigger parity reconstruction if we had any errors along the way
2609 static void raid56_parity_scrub_end_io(struct bio *bio)
2611 struct btrfs_raid_bio *rbio = bio->bi_private;
2614 fail_bio_stripe(rbio, bio);
2616 set_bio_pages_uptodate(bio);
2620 if (!atomic_dec_and_test(&rbio->stripes_pending))
2624 * this will normally call finish_rmw to start our write
2625 * but if there are any failed stripes we'll reconstruct
2628 validate_rbio_for_parity_scrub(rbio);
2631 static void raid56_parity_scrub_stripe(struct btrfs_raid_bio *rbio)
2633 int bios_to_read = 0;
2634 struct bio_list bio_list;
2640 bio_list_init(&bio_list);
2642 ret = alloc_rbio_essential_pages(rbio);
2646 atomic_set(&rbio->error, 0);
2648 * build a list of bios to read all the missing parts of this
2651 for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
2652 for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
2655 * we want to find all the pages missing from
2656 * the rbio and read them from the disk. If
2657 * page_in_rbio finds a page in the bio list
2658 * we don't need to read it off the stripe.
2660 page = page_in_rbio(rbio, stripe, pagenr, 1);
2664 page = rbio_stripe_page(rbio, stripe, pagenr);
2666 * the bio cache may have handed us an uptodate
2667 * page. If so, be happy and use it
2669 if (PageUptodate(page))
2672 ret = rbio_add_io_page(rbio, &bio_list, page,
2673 stripe, pagenr, rbio->stripe_len);
2679 bios_to_read = bio_list_size(&bio_list);
2680 if (!bios_to_read) {
2682 * this can happen if others have merged with
2683 * us, it means there is nothing left to read.
2684 * But if there are missing devices it may not be
2685 * safe to do the full stripe write yet.
2691 * the bbio may be freed once we submit the last bio. Make sure
2692 * not to touch it after that
2694 atomic_set(&rbio->stripes_pending, bios_to_read);
2696 bio = bio_list_pop(&bio_list);
2700 bio->bi_private = rbio;
2701 bio->bi_end_io = raid56_parity_scrub_end_io;
2702 bio->bi_opf = REQ_OP_READ;
2704 btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
2708 /* the actual write will happen once the reads are done */
2712 rbio_orig_end_io(rbio, BLK_STS_IOERR);
2714 while ((bio = bio_list_pop(&bio_list)))
2720 validate_rbio_for_parity_scrub(rbio);
2723 static void scrub_parity_work(struct btrfs_work *work)
2725 struct btrfs_raid_bio *rbio;
2727 rbio = container_of(work, struct btrfs_raid_bio, work);
2728 raid56_parity_scrub_stripe(rbio);
2731 void raid56_parity_submit_scrub_rbio(struct btrfs_raid_bio *rbio)
2733 if (!lock_stripe_add(rbio))
2734 start_async_work(rbio, scrub_parity_work);
2737 /* The following code is used for dev replace of a missing RAID 5/6 device. */
2739 struct btrfs_raid_bio *
2740 raid56_alloc_missing_rbio(struct btrfs_fs_info *fs_info, struct bio *bio,
2741 struct btrfs_bio *bbio, u64 length)
2743 struct btrfs_raid_bio *rbio;
2745 rbio = alloc_rbio(fs_info, bbio, length);
2749 rbio->operation = BTRFS_RBIO_REBUILD_MISSING;
2750 bio_list_add(&rbio->bio_list, bio);
2752 * This is a special bio which is used to hold the completion handler
2753 * and make the scrub rbio is similar to the other types
2755 ASSERT(!bio->bi_iter.bi_size);
2757 rbio->faila = find_logical_bio_stripe(rbio, bio);
2758 if (rbio->faila == -1) {
2765 * When we get bbio, we have already increased bio_counter, record it
2766 * so we can free it at rbio_orig_end_io()
2768 rbio->generic_bio_cnt = 1;
2773 void raid56_submit_missing_rbio(struct btrfs_raid_bio *rbio)
2775 if (!lock_stripe_add(rbio))
2776 start_async_work(rbio, read_rebuild_work);