Lines Matching defs:stripe
26 #include "raid-stripe-tree.h"
96 * Set for data stripes if it's triggered from P/Q stripe.
125 * How many data/meta extents are in this stripe. Only for scrub status
136 * Indicate the states of the stripe. Bits are defined in
145 * The errors hit during the initial read of the stripe.
177 * Checksum for the whole stripe if this stripe is inside a data block
231 static void release_scrub_stripe(struct scrub_stripe *stripe)
233 if (!stripe)
237 if (stripe->pages[i])
238 __free_page(stripe->pages[i]);
239 stripe->pages[i] = NULL;
241 kfree(stripe->sectors);
242 kfree(stripe->csums);
243 stripe->sectors = NULL;
244 stripe->csums = NULL;
245 stripe->sctx = NULL;
246 stripe->state = 0;
250 struct scrub_stripe *stripe)
254 memset(stripe, 0, sizeof(*stripe));
256 stripe->nr_sectors = BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits;
257 stripe->state = 0;
259 init_waitqueue_head(&stripe->io_wait);
260 init_waitqueue_head(&stripe->repair_wait);
261 atomic_set(&stripe->pending_io, 0);
262 spin_lock_init(&stripe->write_error_lock);
264 ret = btrfs_alloc_page_array(SCRUB_STRIPE_PAGES, stripe->pages, 0);
268 stripe->sectors = kcalloc(stripe->nr_sectors,
271 if (!stripe->sectors)
274 stripe->csums = kcalloc(BTRFS_STRIPE_LEN >> fs_info->sectorsize_bits,
276 if (!stripe->csums)
280 release_scrub_stripe(stripe);
284 static void wait_scrub_stripe_io(struct scrub_stripe *stripe)
286 wait_event(stripe->io_wait, atomic_read(&stripe->pending_io) == 0);
582 static struct page *scrub_stripe_get_page(struct scrub_stripe *stripe, int sector_nr)
584 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
587 return stripe->pages[page_index];
590 static unsigned int scrub_stripe_get_page_offset(struct scrub_stripe *stripe,
593 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
598 static void scrub_verify_one_metadata(struct scrub_stripe *stripe, int sector_nr)
600 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
602 const u64 logical = stripe->logical + (sector_nr << fs_info->sectorsize_bits);
603 const struct page *first_page = scrub_stripe_get_page(stripe, sector_nr);
604 const unsigned int first_off = scrub_stripe_get_page_offset(stripe, sector_nr);
619 bitmap_set(&stripe->csum_error_bitmap, sector_nr, sectors_per_tree);
620 bitmap_set(&stripe->error_bitmap, sector_nr, sectors_per_tree);
623 logical, stripe->mirror_num,
629 bitmap_set(&stripe->meta_error_bitmap, sector_nr, sectors_per_tree);
630 bitmap_set(&stripe->error_bitmap, sector_nr, sectors_per_tree);
633 logical, stripe->mirror_num,
639 bitmap_set(&stripe->meta_error_bitmap, sector_nr, sectors_per_tree);
640 bitmap_set(&stripe->error_bitmap, sector_nr, sectors_per_tree);
643 logical, stripe->mirror_num,
655 struct page *page = scrub_stripe_get_page(stripe, i);
656 unsigned int page_off = scrub_stripe_get_page_offset(stripe, i);
664 bitmap_set(&stripe->meta_error_bitmap, sector_nr, sectors_per_tree);
665 bitmap_set(&stripe->error_bitmap, sector_nr, sectors_per_tree);
668 logical, stripe->mirror_num,
673 if (stripe->sectors[sector_nr].generation !=
675 bitmap_set(&stripe->meta_error_bitmap, sector_nr, sectors_per_tree);
676 bitmap_set(&stripe->error_bitmap, sector_nr, sectors_per_tree);
679 logical, stripe->mirror_num,
681 stripe->sectors[sector_nr].generation);
684 bitmap_clear(&stripe->error_bitmap, sector_nr, sectors_per_tree);
685 bitmap_clear(&stripe->csum_error_bitmap, sector_nr, sectors_per_tree);
686 bitmap_clear(&stripe->meta_error_bitmap, sector_nr, sectors_per_tree);
689 static void scrub_verify_one_sector(struct scrub_stripe *stripe, int sector_nr)
691 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
692 struct scrub_sector_verification *sector = &stripe->sectors[sector_nr];
694 struct page *page = scrub_stripe_get_page(stripe, sector_nr);
695 unsigned int pgoff = scrub_stripe_get_page_offset(stripe, sector_nr);
699 ASSERT(sector_nr >= 0 && sector_nr < stripe->nr_sectors);
702 if (!test_bit(sector_nr, &stripe->extent_sector_bitmap))
706 if (test_bit(sector_nr, &stripe->io_error_bitmap))
712 * Check if the tree block crosses the stripe boundary. If
717 * are not ensured to be stripe aligned.
719 if (unlikely(sector_nr + sectors_per_tree > stripe->nr_sectors)) {
721 "tree block at %llu crosses stripe boundary %llu",
722 stripe->logical +
724 stripe->logical);
727 scrub_verify_one_metadata(stripe, sector_nr);
736 clear_bit(sector_nr, &stripe->error_bitmap);
742 set_bit(sector_nr, &stripe->csum_error_bitmap);
743 set_bit(sector_nr, &stripe->error_bitmap);
745 clear_bit(sector_nr, &stripe->csum_error_bitmap);
746 clear_bit(sector_nr, &stripe->error_bitmap);
750 /* Verify specified sectors of a stripe. */
751 static void scrub_verify_one_stripe(struct scrub_stripe *stripe, unsigned long bitmap)
753 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
757 for_each_set_bit(sector_nr, &bitmap, stripe->nr_sectors) {
758 scrub_verify_one_sector(stripe, sector_nr);
759 if (stripe->sectors[sector_nr].is_metadata)
764 static int calc_sector_number(struct scrub_stripe *stripe, struct bio_vec *first_bvec)
768 for (i = 0; i < stripe->nr_sectors; i++) {
769 if (scrub_stripe_get_page(stripe, i) == first_bvec->bv_page &&
770 scrub_stripe_get_page_offset(stripe, i) == first_bvec->bv_offset)
773 ASSERT(i < stripe->nr_sectors);
785 struct scrub_stripe *stripe = bbio->private;
786 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
788 int sector_nr = calc_sector_number(stripe, bio_first_bvec_all(&bbio->bio));
792 ASSERT(sector_nr < stripe->nr_sectors);
798 bitmap_set(&stripe->io_error_bitmap, sector_nr,
800 bitmap_set(&stripe->error_bitmap, sector_nr,
803 bitmap_clear(&stripe->io_error_bitmap, sector_nr,
807 if (atomic_dec_and_test(&stripe->pending_io))
808 wake_up(&stripe->io_wait);
817 static void scrub_stripe_submit_repair_read(struct scrub_stripe *stripe,
820 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
822 const unsigned long old_error_bitmap = stripe->error_bitmap;
825 ASSERT(stripe->mirror_num >= 1);
826 ASSERT(atomic_read(&stripe->pending_io) == 0);
828 for_each_set_bit(i, &old_error_bitmap, stripe->nr_sectors) {
833 page = scrub_stripe_get_page(stripe, i);
834 pgoff = scrub_stripe_get_page_offset(stripe, i);
837 if (bbio && ((i > 0 && !test_bit(i - 1, &stripe->error_bitmap)) ||
840 atomic_inc(&stripe->pending_io);
843 wait_scrub_stripe_io(stripe);
848 bbio = btrfs_bio_alloc(stripe->nr_sectors, REQ_OP_READ,
849 fs_info, scrub_repair_read_endio, stripe);
850 bbio->bio.bi_iter.bi_sector = (stripe->logical +
859 atomic_inc(&stripe->pending_io);
862 wait_scrub_stripe_io(stripe);
867 struct scrub_stripe *stripe)
880 if (test_bit(SCRUB_STRIPE_FLAG_NO_REPORT, &stripe->state))
889 if (!bitmap_empty(&stripe->init_error_bitmap, stripe->nr_sectors)) {
892 int stripe_index = stripe->mirror_num - 1;
896 ASSERT(stripe->mirror_num >= 1);
898 stripe->logical, &mapped_len, &bioc,
912 for_each_set_bit(sector_nr, &stripe->extent_sector_bitmap, stripe->nr_sectors) {
915 if (stripe->sectors[sector_nr].is_metadata) {
919 if (!stripe->sectors[sector_nr].csum)
923 if (test_bit(sector_nr, &stripe->init_error_bitmap) &&
924 !test_bit(sector_nr, &stripe->error_bitmap)) {
930 if (!test_bit(sector_nr, &stripe->init_error_bitmap))
941 stripe->logical, btrfs_dev_name(dev),
946 stripe->logical, stripe->mirror_num);
955 stripe->logical, btrfs_dev_name(dev),
960 stripe->logical, stripe->mirror_num);
963 if (test_bit(sector_nr, &stripe->io_error_bitmap))
966 stripe->logical, physical);
967 if (test_bit(sector_nr, &stripe->csum_error_bitmap))
970 stripe->logical, physical);
971 if (test_bit(sector_nr, &stripe->meta_error_bitmap))
974 stripe->logical, physical);
978 sctx->stat.data_extents_scrubbed += stripe->nr_data_extents;
979 sctx->stat.tree_extents_scrubbed += stripe->nr_meta_extents;
983 sctx->stat.read_errors += stripe->init_nr_io_errors;
984 sctx->stat.csum_errors += stripe->init_nr_csum_errors;
985 sctx->stat.verify_errors += stripe->init_nr_meta_errors;
987 bitmap_weight(&stripe->error_bitmap, stripe->nr_sectors);
992 static void scrub_write_sectors(struct scrub_ctx *sctx, struct scrub_stripe *stripe,
1010 struct scrub_stripe *stripe = container_of(work, struct scrub_stripe, work);
1011 struct scrub_ctx *sctx = stripe->sctx;
1013 int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,
1014 stripe->bg->length);
1019 ASSERT(stripe->mirror_num > 0);
1021 wait_scrub_stripe_io(stripe);
1022 scrub_verify_one_stripe(stripe, stripe->extent_sector_bitmap);
1024 stripe->init_error_bitmap = stripe->error_bitmap;
1025 stripe->init_nr_io_errors = bitmap_weight(&stripe->io_error_bitmap,
1026 stripe->nr_sectors);
1027 stripe->init_nr_csum_errors = bitmap_weight(&stripe->csum_error_bitmap,
1028 stripe->nr_sectors);
1029 stripe->init_nr_meta_errors = bitmap_weight(&stripe->meta_error_bitmap,
1030 stripe->nr_sectors);
1032 if (bitmap_empty(&stripe->init_error_bitmap, stripe->nr_sectors))
1041 for (mirror = calc_next_mirror(stripe->mirror_num, num_copies);
1042 mirror != stripe->mirror_num;
1044 const unsigned long old_error_bitmap = stripe->error_bitmap;
1046 scrub_stripe_submit_repair_read(stripe, mirror,
1048 wait_scrub_stripe_io(stripe);
1049 scrub_verify_one_stripe(stripe, old_error_bitmap);
1050 if (bitmap_empty(&stripe->error_bitmap, stripe->nr_sectors))
1065 for (i = 0, mirror = stripe->mirror_num;
1068 const unsigned long old_error_bitmap = stripe->error_bitmap;
1070 scrub_stripe_submit_repair_read(stripe, mirror,
1072 wait_scrub_stripe_io(stripe);
1073 scrub_verify_one_stripe(stripe, old_error_bitmap);
1074 if (bitmap_empty(&stripe->error_bitmap, stripe->nr_sectors))
1082 bitmap_andnot(&repaired, &stripe->init_error_bitmap, &stripe->error_bitmap,
1083 stripe->nr_sectors);
1084 if (!sctx->readonly && !bitmap_empty(&repaired, stripe->nr_sectors)) {
1088 scrub_write_sectors(sctx, stripe, repaired, false);
1089 wait_scrub_stripe_io(stripe);
1093 scrub_stripe_report_errors(sctx, stripe);
1094 set_bit(SCRUB_STRIPE_FLAG_REPAIR_DONE, &stripe->state);
1095 wake_up(&stripe->repair_wait);
1100 struct scrub_stripe *stripe = bbio->private;
1102 int sector_nr = calc_sector_number(stripe, bio_first_bvec_all(&bbio->bio));
1107 ASSERT(sector_nr < stripe->nr_sectors);
1110 num_sectors = bio_size >> stripe->bg->fs_info->sectorsize_bits;
1113 bitmap_set(&stripe->io_error_bitmap, sector_nr, num_sectors);
1114 bitmap_set(&stripe->error_bitmap, sector_nr, num_sectors);
1116 bitmap_clear(&stripe->io_error_bitmap, sector_nr, num_sectors);
1119 if (atomic_dec_and_test(&stripe->pending_io)) {
1120 wake_up(&stripe->io_wait);
1121 INIT_WORK(&stripe->work, scrub_stripe_read_repair_worker);
1122 queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);
1128 struct scrub_stripe *stripe = bbio->private;
1129 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
1131 int sector_nr = calc_sector_number(stripe, bio_first_bvec_all(&bbio->bio));
1141 spin_lock_irqsave(&stripe->write_error_lock, flags);
1142 bitmap_set(&stripe->write_error_bitmap, sector_nr,
1144 spin_unlock_irqrestore(&stripe->write_error_lock, flags);
1148 if (atomic_dec_and_test(&stripe->pending_io))
1149 wake_up(&stripe->io_wait);
1153 struct scrub_stripe *stripe,
1159 stripe->logical;
1161 fill_writer_pointer_gap(sctx, stripe->physical + bio_off);
1162 atomic_inc(&stripe->pending_io);
1163 btrfs_submit_repair_write(bbio, stripe->mirror_num, dev_replace);
1170 wait_scrub_stripe_io(stripe);
1177 &stripe->write_error_bitmap))
1194 static void scrub_write_sectors(struct scrub_ctx *sctx, struct scrub_stripe *stripe,
1197 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
1201 for_each_set_bit(sector_nr, &write_bitmap, stripe->nr_sectors) {
1202 struct page *page = scrub_stripe_get_page(stripe, sector_nr);
1203 unsigned int pgoff = scrub_stripe_get_page_offset(stripe, sector_nr);
1207 ASSERT(test_bit(sector_nr, &stripe->extent_sector_bitmap));
1211 scrub_submit_write_bio(sctx, stripe, bbio, dev_replace);
1215 bbio = btrfs_bio_alloc(stripe->nr_sectors, REQ_OP_WRITE,
1216 fs_info, scrub_write_endio, stripe);
1217 bbio->bio.bi_iter.bi_sector = (stripe->logical +
1225 scrub_submit_write_bio(sctx, stripe, bbio, dev_replace);
1286 * logical offset. if this is a parity stripe, it will return
1287 * the most left data stripe's logical offset.
1289 * return 0 if it is a data stripe, 1 means parity stripe.
1314 /* Work out the disk rotation on this stripe-set */
1316 /* calculate which stripe this data locates */
1365 * return the extent item. This is for data extent crossing stripe boundary.
1483 struct scrub_stripe *stripe,
1487 for (u64 cur_logical = max(stripe->logical, extent_start);
1488 cur_logical < min(stripe->logical + BTRFS_STRIPE_LEN,
1491 const int nr_sector = (cur_logical - stripe->logical) >>
1494 &stripe->sectors[nr_sector];
1496 set_bit(nr_sector, &stripe->extent_sector_bitmap);
1504 static void scrub_stripe_reset_bitmaps(struct scrub_stripe *stripe)
1506 stripe->extent_sector_bitmap = 0;
1507 stripe->init_error_bitmap = 0;
1508 stripe->init_nr_io_errors = 0;
1509 stripe->init_nr_csum_errors = 0;
1510 stripe->init_nr_meta_errors = 0;
1511 stripe->error_bitmap = 0;
1512 stripe->io_error_bitmap = 0;
1513 stripe->csum_error_bitmap = 0;
1514 stripe->meta_error_bitmap = 0;
1518 * Locate one stripe which has at least one extent in its range.
1520 * Return 0 if found such stripe, and store its info into @stripe.
1521 * Return >0 if there is no such stripe in the specified range.
1530 struct scrub_stripe *stripe)
1544 memset(stripe->sectors, 0, sizeof(struct scrub_sector_verification) *
1545 stripe->nr_sectors);
1546 scrub_stripe_reset_bitmaps(stripe);
1559 stripe->nr_meta_extents++;
1561 stripe->nr_data_extents++;
1565 * Round down to stripe boundary.
1570 stripe->logical = round_down(cur_logical - bg->start, BTRFS_STRIPE_LEN) +
1572 stripe->physical = physical + stripe->logical - logical_start;
1573 stripe->dev = dev;
1574 stripe->bg = bg;
1575 stripe->mirror_num = mirror_num;
1576 stripe_end = stripe->logical + BTRFS_STRIPE_LEN - 1;
1578 /* Fill the first extent info into stripe->sectors[] array. */
1579 fill_one_extent_info(fs_info, stripe, extent_start, extent_len,
1596 stripe->nr_meta_extents++;
1598 stripe->nr_data_extents++;
1599 fill_one_extent_info(fs_info, stripe, extent_start, extent_len,
1610 ASSERT(stripe->csums);
1619 stripe->logical, stripe_end,
1620 stripe->csums, &csum_bitmap);
1626 for_each_set_bit(sector_nr, &csum_bitmap, stripe->nr_sectors) {
1627 stripe->sectors[sector_nr].csum = stripe->csums +
1631 set_bit(SCRUB_STRIPE_FLAG_INITIALIZED, &stripe->state);
1636 static void scrub_reset_stripe(struct scrub_stripe *stripe)
1638 scrub_stripe_reset_bitmaps(stripe);
1640 stripe->nr_meta_extents = 0;
1641 stripe->nr_data_extents = 0;
1642 stripe->state = 0;
1644 for (int i = 0; i < stripe->nr_sectors; i++) {
1645 stripe->sectors[i].is_metadata = false;
1646 stripe->sectors[i].csum = NULL;
1647 stripe->sectors[i].generation = 0;
1652 struct scrub_stripe *stripe)
1654 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
1656 unsigned int nr_sectors = min(BTRFS_STRIPE_LEN, stripe->bg->start +
1657 stripe->bg->length - stripe->logical) >>
1660 int mirror = stripe->mirror_num;
1663 atomic_inc(&stripe->pending_io);
1665 for_each_set_bit(i, &stripe->extent_sector_bitmap, stripe->nr_sectors) {
1666 struct page *page = scrub_stripe_get_page(stripe, i);
1667 unsigned int pgoff = scrub_stripe_get_page_offset(stripe, i);
1676 !test_bit(i - 1, &stripe->extent_sector_bitmap)) ||
1679 atomic_inc(&stripe->pending_io);
1687 const u64 logical = stripe->logical +
1691 bbio = btrfs_bio_alloc(stripe->nr_sectors, REQ_OP_READ,
1692 fs_info, scrub_read_endio, stripe);
1712 atomic_inc(&stripe->pending_io);
1716 if (atomic_dec_and_test(&stripe->pending_io)) {
1717 wake_up(&stripe->io_wait);
1718 INIT_WORK(&stripe->work, scrub_stripe_read_repair_worker);
1719 queue_work(stripe->bg->fs_info->scrub_workers, &stripe->work);
1724 struct scrub_stripe *stripe)
1728 unsigned int nr_sectors = min(BTRFS_STRIPE_LEN, stripe->bg->start +
1729 stripe->bg->length - stripe->logical) >>
1731 int mirror = stripe->mirror_num;
1733 ASSERT(stripe->bg);
1734 ASSERT(stripe->mirror_num > 0);
1735 ASSERT(test_bit(SCRUB_STRIPE_FLAG_INITIALIZED, &stripe->state));
1737 if (btrfs_need_stripe_tree_update(fs_info, stripe->bg->flags)) {
1738 scrub_submit_extent_sector_read(sctx, stripe);
1743 scrub_read_endio, stripe);
1745 bbio->bio.bi_iter.bi_sector = stripe->logical >> SECTOR_SHIFT;
1748 struct page *page = scrub_stripe_get_page(stripe, cur);
1749 unsigned int pgoff = scrub_stripe_get_page_offset(stripe, cur);
1756 atomic_inc(&stripe->pending_io);
1765 !stripe->dev->bdev)) {
1766 int num_copies = btrfs_num_copies(fs_info, stripe->bg->start,
1767 stripe->bg->length);
1774 static bool stripe_has_metadata_error(struct scrub_stripe *stripe)
1778 for_each_set_bit(i, &stripe->error_bitmap, stripe->nr_sectors) {
1779 if (stripe->sectors[i].is_metadata) {
1780 struct btrfs_fs_info *fs_info = stripe->bg->fs_info;
1783 "stripe %llu has unrepaired metadata sector at %llu",
1784 stripe->logical,
1785 stripe->logical + (i << fs_info->sectorsize_bits));
1805 struct scrub_stripe *stripe = &sctx->stripes[first_slot + i];
1808 ASSERT(test_bit(SCRUB_STRIPE_FLAG_INITIALIZED, &stripe->state));
1809 scrub_submit_initial_read(sctx, stripe);
1817 struct scrub_stripe *stripe;
1834 stripe = &sctx->stripes[i];
1836 wait_event(stripe->repair_wait,
1837 test_bit(SCRUB_STRIPE_FLAG_REPAIR_DONE, &stripe->state));
1855 stripe = &sctx->stripes[i];
1857 ASSERT(stripe->dev == fs_info->dev_replace.srcdev);
1859 bitmap_andnot(&good, &stripe->extent_sector_bitmap,
1860 &stripe->error_bitmap, stripe->nr_sectors);
1861 scrub_write_sectors(sctx, stripe, good, true);
1867 stripe = &sctx->stripes[i];
1869 wait_scrub_stripe_io(stripe);
1870 scrub_reset_stripe(stripe);
1887 struct scrub_stripe *stripe;
1899 stripe = &sctx->stripes[sctx->cur_stripe];
1900 scrub_reset_stripe(stripe);
1903 mirror_num, logical, length, stripe);
1907 *found_logical_ret = stripe->logical;
1936 struct scrub_stripe *stripe;
1946 * For data stripe search, we cannot re-use the same extent/csum paths,
1947 * as the data stripe bytenr may be smaller than previous extent. Thus
1960 stripe = &sctx->raid56_data_stripes[i];
1967 scrub_reset_stripe(stripe);
1968 set_bit(SCRUB_STRIPE_FLAG_NO_REPORT, &stripe->state);
1972 BTRFS_STRIPE_LEN, stripe);
1976 * No extent in this data stripe, need to manually mark them
1980 stripe->logical = full_stripe_start +
1982 stripe->dev = map->stripes[stripe_index].dev;
1983 stripe->mirror_num = 1;
1984 set_bit(SCRUB_STRIPE_FLAG_INITIALIZED, &stripe->state);
1990 stripe = &sctx->raid56_data_stripes[i];
1991 if (!bitmap_empty(&stripe->extent_sector_bitmap, stripe->nr_sectors)) {
2002 stripe = &sctx->raid56_data_stripes[i];
2003 scrub_submit_initial_read(sctx, stripe);
2006 stripe = &sctx->raid56_data_stripes[i];
2008 wait_event(stripe->repair_wait,
2009 test_bit(SCRUB_STRIPE_FLAG_REPAIR_DONE, &stripe->state));
2024 stripe = &sctx->raid56_data_stripes[i];
2028 * As we may hit an empty data stripe while it's missing.
2030 bitmap_and(&error, &stripe->error_bitmap,
2031 &stripe->extent_sector_bitmap, stripe->nr_sectors);
2032 if (!bitmap_empty(&error, stripe->nr_sectors)) {
2034 "unrepaired sectors detected, full stripe %llu data stripe %u errors %*pbl",
2035 full_stripe_start, i, stripe->nr_sectors,
2041 &stripe->extent_sector_bitmap, stripe->nr_sectors);
2044 /* Now we can check and regenerate the P/Q stripe. */
2068 stripe = &sctx->raid56_data_stripes[i];
2070 raid56_parity_cache_data_pages(rbio, stripe->pages,
2087 * (Including all range in SINGLE/DUP/RAID1/RAID1C*, and each stripe in
2155 /* Calculate the full stripe length for simple stripe based profiles */
2164 /* Get the logical bytenr for the stripe */
2181 /* Get the mirror number for the stripe */
2208 * Inside each stripe, RAID0 is just SINGLE, and RAID10 is
2210 * this stripe.
2217 /* Skip to next stripe which belongs to the target device */
2219 /* For physical offset, we just go to next stripe */
2241 /* The logical increment after finishing one stripe */
2292 * mirrored duplication without stripe.
2313 /* Calculate the logical end of the stripe */
2323 * Due to the rotation, for RAID56 it's better to iterate each stripe
2341 * Now we're at a data stripe, scrub each extents in the range.
2344 * stripe it is no different than SINGLE profile.