Lines Matching defs:bio
74 static void end_reshape_write(struct bio *bio);
83 * for resync bio, r10bio pointer can be retrieved from the per-bio
86 static inline struct r10bio *get_resync_r10bio(struct bio *bio)
88 return get_resync_pages(bio)->raid_bio;
120 struct bio *bio;
148 bio = bio_kmalloc(gfp_flags, RESYNC_PAGES);
149 if (!bio)
151 r10_bio->devs[j].bio = bio;
154 bio = bio_kmalloc(gfp_flags, RESYNC_PAGES);
155 if (!bio)
157 r10_bio->devs[j].repl_bio = bio;
164 struct bio *rbio = r10_bio->devs[j].repl_bio;
171 bio = r10_bio->devs[j].bio;
183 bio->bi_private = rp;
199 if (r10_bio->devs[j].bio)
200 bio_put(r10_bio->devs[j].bio);
218 struct bio *bio = r10bio->devs[j].bio;
220 if (bio) {
221 rp = get_resync_pages(bio);
223 bio_put(bio);
226 bio = r10bio->devs[j].repl_bio;
227 if (bio)
228 bio_put(bio);
231 /* resync pages array stored in the 1st bio's .bi_private */
242 struct bio **bio = & r10_bio->devs[i].bio;
243 if (!BIO_SPECIAL(*bio))
244 bio_put(*bio);
245 *bio = NULL;
246 bio = &r10_bio->devs[i].repl_bio;
247 if (r10_bio->read_slot < 0 && !BIO_SPECIAL(*bio))
248 bio_put(*bio);
249 *bio = NULL;
294 struct bio *bio = r10_bio->master_bio;
298 bio->bi_status = BLK_STS_IOERR;
300 bio_endio(bio);
322 * Find the disk number which triggered given bio
325 struct bio *bio, int *slotp, int *replp)
331 if (r10_bio->devs[slot].bio == bio)
333 if (r10_bio->devs[slot].repl_bio == bio) {
349 static void raid10_end_read_request(struct bio *bio)
351 int uptodate = !bio->bi_status;
352 struct r10bio *r10_bio = bio->bi_private;
366 * Set R10BIO_Uptodate in our master bio, so that
372 * wait for the 'master' bio.
427 static void raid10_end_write_request(struct bio *bio)
429 struct r10bio *r10_bio = bio->bi_private;
435 struct bio *to_put = NULL;
438 discard_error = bio->bi_status && bio_op(bio) == REQ_OP_DISCARD;
440 dev = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
452 if (bio->bi_status && !discard_error) {
466 (bio->bi_opf & MD_FAILFAST)) {
479 r10_bio->devs[slot].bio = NULL;
480 to_put = bio;
486 * Set R10BIO_Uptodate in our master bio, so that
492 * wait for the 'master' bio.
514 bio_put(bio);
518 r10_bio->devs[slot].bio = IO_MADE_GOOD;
749 if (r10_bio->devs[slot].bio == IO_BLOCKED)
868 struct bio *bio;
870 bio = bio_list_get(&conf->pending_bio_list);
891 while (bio) { /* submit pending writes */
892 struct bio *next = bio->bi_next;
893 struct md_rdev *rdev = (void*)bio->bi_disk;
894 bio->bi_next = NULL;
895 bio_set_dev(bio, rdev->bdev);
897 bio_io_error(bio);
898 } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
899 !blk_queue_discard(bio->bi_disk->queue)))
901 bio_endio(bio);
903 submit_bio_noacct(bio);
904 bio = next;
973 * pre-process bio queue isn't empty,
1067 struct bio *bio;
1081 bio = bio_list_get(&plug->pending);
1085 while (bio) { /* submit pending writes */
1086 struct bio *next = bio->bi_next;
1087 struct md_rdev *rdev = (void*)bio->bi_disk;
1088 bio->bi_next = NULL;
1089 bio_set_dev(bio, rdev->bdev);
1091 bio_io_error(bio);
1092 } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
1093 !blk_queue_discard(bio->bi_disk->queue)))
1095 bio_endio(bio);
1097 submit_bio_noacct(bio);
1098 bio = next;
1111 struct bio *bio, sector_t sectors)
1115 bio->bi_iter.bi_sector < conf->reshape_progress &&
1116 bio->bi_iter.bi_sector + sectors > conf->reshape_progress) {
1120 conf->reshape_progress <= bio->bi_iter.bi_sector ||
1121 conf->reshape_progress >= bio->bi_iter.bi_sector +
1127 static void raid10_read_request(struct mddev *mddev, struct bio *bio,
1131 struct bio *read_bio;
1132 const int op = bio_op(bio);
1133 const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
1169 regular_request_wait(mddev, conf, bio, r10_bio->sectors);
1185 if (max_sectors < bio_sectors(bio)) {
1186 struct bio *split = bio_split(bio, max_sectors,
1188 bio_chain(split, bio);
1190 submit_bio_noacct(bio);
1192 bio = split;
1193 r10_bio->master_bio = bio;
1198 read_bio = bio_clone_fast(bio, gfp, &mddev->bio_set);
1200 r10_bio->devs[slot].bio = read_bio;
1222 struct bio *bio, bool replacement,
1225 const int op = bio_op(bio);
1226 const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
1227 const unsigned long do_fua = (bio->bi_opf & REQ_FUA);
1234 struct bio *mbio;
1246 mbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
1250 r10_bio->devs[n_copy].bio = mbio;
1289 static void raid10_write_request(struct mddev *mddev, struct bio *bio,
1300 bio->bi_iter.bi_sector,
1301 bio_end_sector(bio)))) {
1307 bio->bi_iter.bi_sector, bio_end_sector(bio)))
1315 regular_request_wait(mddev, conf, bio, sectors);
1318 ? (bio->bi_iter.bi_sector < conf->reshape_safe &&
1319 bio->bi_iter.bi_sector + sectors > conf->reshape_progress)
1320 : (bio->bi_iter.bi_sector + sectors > conf->reshape_safe &&
1321 bio->bi_iter.bi_sector < conf->reshape_progress))) {
1342 * bios[x] to bio
1385 r10_bio->devs[i].bio = NULL;
1434 r10_bio->devs[i].bio = bio;
1438 r10_bio->devs[i].repl_bio = bio;
1450 if (r10_bio->devs[j].bio) {
1476 if (r10_bio->sectors < bio_sectors(bio)) {
1477 struct bio *split = bio_split(bio, r10_bio->sectors,
1479 bio_chain(split, bio);
1481 submit_bio_noacct(bio);
1483 bio = split;
1484 r10_bio->master_bio = bio;
1491 if (r10_bio->devs[i].bio)
1492 raid10_write_one_disk(mddev, r10_bio, bio, false, i);
1494 raid10_write_one_disk(mddev, r10_bio, bio, true, i);
1499 static void __make_request(struct mddev *mddev, struct bio *bio, int sectors)
1506 r10_bio->master_bio = bio;
1510 r10_bio->sector = bio->bi_iter.bi_sector;
1515 if (bio_data_dir(bio) == READ)
1516 raid10_read_request(mddev, bio, r10_bio);
1518 raid10_write_request(mddev, bio, r10_bio);
1521 static bool raid10_make_request(struct mddev *mddev, struct bio *bio)
1526 int sectors = bio_sectors(bio);
1528 if (unlikely(bio->bi_opf & REQ_PREFLUSH)
1529 && md_flush_request(mddev, bio))
1532 if (!md_write_start(mddev, bio))
1539 if (unlikely((bio->bi_iter.bi_sector & chunk_mask) +
1545 (bio->bi_iter.bi_sector &
1547 __make_request(mddev, bio, sectors);
1886 static void __end_sync_read(struct r10bio *r10_bio, struct bio *bio, int d)
1890 if (!bio->bi_status)
1912 static void end_sync_read(struct bio *bio)
1914 struct r10bio *r10_bio = get_resync_r10bio(bio);
1916 int d = find_bio_disk(conf, r10_bio, bio, NULL, NULL);
1918 __end_sync_read(r10_bio, bio, d);
1921 static void end_reshape_read(struct bio *bio)
1923 /* reshape read bio isn't allocated from r10buf_pool */
1924 struct r10bio *r10_bio = bio->bi_private;
1926 __end_sync_read(r10_bio, bio, r10_bio->read_slot);
1956 static void end_sync_write(struct bio *bio)
1958 struct r10bio *r10_bio = get_resync_r10bio(bio);
1968 d = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
1974 if (bio->bi_status) {
2015 struct bio *tbio, *fbio;
2023 if (!r10_bio->devs[i].bio->bi_status)
2030 fbio = r10_bio->devs[i].bio;
2042 tbio = r10_bio->devs[i].bio;
2052 if (!r10_bio->devs[i].bio->bi_status) {
2079 /* Ok, we need to write this bio, either to correct an
2117 if (r10_bio->devs[i].bio->bi_end_io != end_sync_write
2118 && r10_bio->devs[i].bio != fbio)
2155 struct bio *bio = r10_bio->devs[0].bio;
2161 struct page **pages = get_resync_pages(bio)->pages;
2231 struct bio *wbio = r10_bio->devs[1].bio;
2232 struct bio *wbio2 = r10_bio->devs[1].repl_bio;
2251 * share the pages with the first bio
2366 r10_bio->devs[r10_bio->read_slot].bio = IO_BLOCKED;
2424 r10_bio->devs[r10_bio->read_slot].bio
2523 struct bio *bio = r10_bio->master_bio;
2527 /* bio has the data to be written to slot 'i' where
2529 * We repeatedly clone the bio and trim down to one block,
2532 * It is conceivable that the bio doesn't exactly align with
2555 struct bio *wbio;
2560 wbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
2561 bio_trim(wbio, sector - bio->bi_iter.bi_sector, sectors);
2585 struct bio *bio;
2597 bio = r10_bio->devs[slot].bio;
2598 bio_put(bio);
2599 r10_bio->devs[slot].bio = NULL;
2602 r10_bio->devs[slot].bio = IO_BLOCKED;
2632 if (r10_bio->devs[m].bio == NULL ||
2633 r10_bio->devs[m].bio->bi_end_io == NULL)
2635 if (!r10_bio->devs[m].bio->bi_status) {
2670 struct bio *bio = r10_bio->devs[m].bio;
2672 if (bio == IO_MADE_GOOD) {
2678 } else if (bio != NULL && bio->bi_status) {
2687 bio = r10_bio->devs[m].repl_bio;
2689 if (rdev && bio == IO_MADE_GOOD) {
2813 struct bio *bio;
2824 bio = r10bio->devs[i].bio;
2825 rp = bio->bi_private;
2826 bio_reset(bio);
2827 bio->bi_private = rp;
2828 bio = r10bio->devs[i].repl_bio;
2829 if (bio) {
2830 rp = bio->bi_private;
2831 bio_reset(bio);
2832 bio->bi_private = rp;
2896 * As we setup these structures, we collect all bio's together into a list
2912 struct bio *biolist = NULL, *bio;
3114 r10_bio->master_bio = (struct bio*)rb2;
3167 bio = r10_bio->devs[0].bio;
3168 bio->bi_next = biolist;
3169 biolist = bio;
3170 bio->bi_end_io = end_sync_read;
3171 bio_set_op_attrs(bio, REQ_OP_READ, 0);
3173 bio->bi_opf |= MD_FAILFAST;
3175 bio->bi_iter.bi_sector = from_addr +
3177 bio_set_dev(bio, rdev->bdev);
3192 bio = r10_bio->devs[1].bio;
3193 bio->bi_next = biolist;
3194 biolist = bio;
3195 bio->bi_end_io = end_sync_write;
3196 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3197 bio->bi_iter.bi_sector = to_addr
3199 bio_set_dev(bio, mrdev->bdev);
3202 r10_bio->devs[1].bio->bi_end_io = NULL;
3205 bio = r10_bio->devs[1].repl_bio;
3206 if (bio)
3207 bio->bi_end_io = NULL;
3208 /* Note: if replace is not NULL, then bio
3214 bio->bi_next = biolist;
3215 biolist = bio;
3216 bio->bi_end_io = end_sync_write;
3217 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3218 bio->bi_iter.bi_sector = to_addr +
3220 bio_set_dev(bio, mreplace->bdev);
3270 if (r10_bio->devs[0].bio->bi_opf & MD_FAILFAST) {
3284 r10_bio->devs[0].bio->bi_opf
3345 bio = r10_bio->devs[i].bio;
3346 bio->bi_status = BLK_STS_IOERR;
3368 bio->bi_next = biolist;
3369 biolist = bio;
3370 bio->bi_end_io = end_sync_read;
3371 bio_set_op_attrs(bio, REQ_OP_READ, 0);
3373 bio->bi_opf |= MD_FAILFAST;
3374 bio->bi_iter.bi_sector = sector + rdev->data_offset;
3375 bio_set_dev(bio, rdev->bdev);
3386 bio = r10_bio->devs[i].repl_bio;
3387 bio->bi_status = BLK_STS_IOERR;
3390 bio->bi_next = biolist;
3391 biolist = bio;
3392 bio->bi_end_io = end_sync_write;
3393 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3395 bio->bi_opf |= MD_FAILFAST;
3396 bio->bi_iter.bi_sector = sector + rdev->data_offset;
3397 bio_set_dev(bio, rdev->bdev);
3405 if (r10_bio->devs[i].bio->bi_end_io)
3430 for (bio= biolist ; bio ; bio=bio->bi_next) {
3431 struct resync_pages *rp = get_resync_pages(bio);
3437 bio_add_page(bio, page, len, 0);
3491 bio = biolist;
3494 bio->bi_next = NULL;
3495 r10_bio = get_resync_r10bio(bio);
3498 if (bio->bi_end_io == end_sync_read) {
3499 md_sync_acct_bio(bio, nr_sectors);
3500 bio->bi_status = 0;
3501 submit_bio_noacct(bio);
4421 * We store the read-in bio in ->master_bio and the others in
4422 * ->devs[x].bio and ->devs[x].repl_bio.
4432 struct bio *blist;
4433 struct bio *bio, *read_bio;
4600 struct bio *b;
4608 b = r10_bio->devs[s/2].bio;
4625 pages = get_resync_pages(r10_bio->devs[0].bio)->pages;
4631 for (bio = blist; bio ; bio = bio->bi_next) {
4636 bio_add_page(bio, page, len, 0);
4691 struct bio *b;
4700 b = r10_bio->devs[s/2].bio;
4764 /* reshape IOs share pages from .devs[0].bio */
4765 pages = get_resync_pages(r10_bio->devs[0].bio)->pages;
4822 static void end_reshape_write(struct bio *bio)
4824 struct r10bio *r10_bio = get_resync_r10bio(bio);
4832 d = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
4840 if (bio->bi_status) {