Lines Matching defs:bio
9 #include "dm-bio-record.h"
126 static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw)
135 bio_list_add(bl, bio);
145 struct bio *bio;
147 while ((bio = bio_list_pop(bio_list)))
148 queue_bio(ms, bio, WRITE);
168 static struct mirror *bio_get_m(struct bio *bio)
170 return (struct mirror *) bio->bi_next;
173 static void bio_set_m(struct bio *bio, struct mirror *m)
175 bio->bi_next = (struct bio *) m;
445 static int mirror_available(struct mirror_set *ms, struct bio *bio)
448 region_t region = dm_rh_bio_to_region(ms->rh, bio);
451 return choose_mirror(ms, bio->bi_iter.bi_sector) ? 1 : 0;
459 static sector_t map_sector(struct mirror *m, struct bio *bio)
461 if (unlikely(!bio->bi_iter.bi_size))
463 return m->offset + dm_target_offset(m->ms->ti, bio->bi_iter.bi_sector);
466 static void map_bio(struct mirror *m, struct bio *bio)
468 bio_set_dev(bio, m->dev->bdev);
469 bio->bi_iter.bi_sector = map_sector(m, bio);
473 struct bio *bio)
476 io->sector = map_sector(m, bio);
477 io->count = bio_sectors(bio);
480 static void hold_bio(struct mirror_set *ms, struct bio *bio)
492 * If device is suspended, complete the bio.
495 bio->bi_status = BLK_STS_DM_REQUEUE;
497 bio->bi_status = BLK_STS_IOERR;
499 bio_endio(bio);
504 * Hold bio until the suspend is complete.
506 bio_list_add(&ms->holds, bio);
517 struct bio *bio = context;
520 m = bio_get_m(bio);
521 bio_set_m(bio, NULL);
524 bio_endio(bio);
530 if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
533 queue_bio(m->ms, bio, bio_data_dir(bio));
539 bio_io_error(bio);
543 static void read_async_bio(struct mirror *m, struct bio *bio)
549 .mem.ptr.bio = bio,
551 .notify.context = bio,
555 map_region(&io, m, bio);
556 bio_set_m(bio, m);
570 struct bio *bio;
573 while ((bio = bio_list_pop(reads))) {
574 region = dm_rh_bio_to_region(ms->rh, bio);
581 m = choose_mirror(ms, bio->bi_iter.bi_sector);
586 read_async_bio(m, bio);
588 bio_io_error(bio);
607 struct bio *bio = context;
612 ms = bio_get_m(bio)->ms;
613 bio_set_m(bio, NULL);
622 bio_endio(bio);
627 * If the bio is discard, return an error, but do not
630 if (bio_op(bio) == REQ_OP_DISCARD) {
631 bio->bi_status = BLK_STS_NOTSUPP;
632 bio_endio(bio);
648 bio_list_add(&ms->failures, bio);
654 static void do_write(struct mirror_set *ms, struct bio *bio)
659 blk_opf_t op_flags = bio->bi_opf & (REQ_FUA | REQ_PREFLUSH);
663 .mem.ptr.bio = bio,
665 .notify.context = bio,
669 if (bio_op(bio) == REQ_OP_DISCARD) {
676 map_region(dest++, m, bio);
682 bio_set_m(bio, get_default_mirror(ms));
690 struct bio *bio;
707 while ((bio = bio_list_pop(writes))) {
708 if ((bio->bi_opf & REQ_PREFLUSH) ||
709 (bio_op(bio) == REQ_OP_DISCARD)) {
710 bio_list_add(&sync, bio);
714 region = dm_rh_bio_to_region(ms->rh, bio);
718 bio_list_add(&requeue, bio);
738 bio_list_add(this_list, bio);
776 while ((bio = bio_list_pop(&sync)))
777 do_write(ms, bio);
779 while ((bio = bio_list_pop(&recover)))
780 dm_rh_delay(ms->rh, bio);
782 while ((bio = bio_list_pop(&nosync))) {
785 bio_list_add(&ms->failures, bio);
789 map_bio(get_default_mirror(ms), bio);
790 submit_bio_noacct(bio);
797 struct bio *bio;
819 while ((bio = bio_list_pop(failures))) {
822 dm_rh_mark_nosync(ms->rh, bio);
831 * isn't enabled, hold the bio and wait for userspace to
839 bio_io_error(bio);
841 hold_bio(ms, bio);
843 bio_endio(bio);
1196 static int mirror_map(struct dm_target *ti, struct bio *bio)
1198 int r, rw = bio_data_dir(bio);
1203 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1209 bio_record->write_region = dm_rh_bio_to_region(ms->rh, bio);
1210 queue_bio(ms, bio, rw);
1214 r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
1219 * If region is not in-sync queue the bio.
1222 if (bio->bi_opf & REQ_RAHEAD)
1225 queue_bio(ms, bio, rw);
1233 m = choose_mirror(ms, bio->bi_iter.bi_sector);
1237 dm_bio_record(&bio_record->details, bio);
1240 map_bio(m, bio);
1245 static int mirror_end_io(struct dm_target *ti, struct bio *bio,
1248 int rw = bio_data_dir(bio);
1253 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1259 if (!(bio->bi_opf & REQ_PREFLUSH) &&
1260 bio_op(bio) != REQ_OP_DISCARD)
1268 if (bio->bi_opf & REQ_RAHEAD)
1293 if (default_ok(m) || mirror_available(ms, bio)) {
1296 dm_bio_restore(bd, bio);
1298 bio->bi_status = 0;
1300 queue_bio(ms, bio, rw);
1318 struct bio *bio;
1324 * for bios in the hold list. After the process, no bio has
1333 while ((bio = bio_list_pop(&holds)))
1334 hold_bio(ms, bio);