Lines Matching defs:bio
8 #include "dm-bio-record.h"
121 static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw)
130 bio_list_add(bl, bio);
140 struct bio *bio;
142 while ((bio = bio_list_pop(bio_list)))
143 queue_bio(ms, bio, WRITE);
163 static struct mirror *bio_get_m(struct bio *bio)
165 return (struct mirror *) bio->bi_next;
168 static void bio_set_m(struct bio *bio, struct mirror *m)
170 bio->bi_next = (struct bio *) m;
437 static int mirror_available(struct mirror_set *ms, struct bio *bio)
440 region_t region = dm_rh_bio_to_region(ms->rh, bio);
443 return choose_mirror(ms, bio->bi_iter.bi_sector) ? 1 : 0;
451 static sector_t map_sector(struct mirror *m, struct bio *bio)
453 if (unlikely(!bio->bi_iter.bi_size))
455 return m->offset + dm_target_offset(m->ms->ti, bio->bi_iter.bi_sector);
458 static void map_bio(struct mirror *m, struct bio *bio)
460 bio_set_dev(bio, m->dev->bdev);
461 bio->bi_iter.bi_sector = map_sector(m, bio);
465 struct bio *bio)
468 io->sector = map_sector(m, bio);
469 io->count = bio_sectors(bio);
472 static void hold_bio(struct mirror_set *ms, struct bio *bio)
484 * If device is suspended, complete the bio.
487 bio->bi_status = BLK_STS_DM_REQUEUE;
489 bio->bi_status = BLK_STS_IOERR;
491 bio_endio(bio);
496 * Hold bio until the suspend is complete.
498 bio_list_add(&ms->holds, bio);
507 struct bio *bio = context;
510 m = bio_get_m(bio);
511 bio_set_m(bio, NULL);
514 bio_endio(bio);
520 if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
524 queue_bio(m->ms, bio, bio_data_dir(bio));
530 bio_io_error(bio);
534 static void read_async_bio(struct mirror *m, struct bio *bio)
541 .mem.ptr.bio = bio,
543 .notify.context = bio,
547 map_region(&io, m, bio);
548 bio_set_m(bio, m);
562 struct bio *bio;
565 while ((bio = bio_list_pop(reads))) {
566 region = dm_rh_bio_to_region(ms->rh, bio);
573 m = choose_mirror(ms, bio->bi_iter.bi_sector);
578 read_async_bio(m, bio);
580 bio_io_error(bio);
599 struct bio *bio = (struct bio *) context;
604 ms = bio_get_m(bio)->ms;
605 bio_set_m(bio, NULL);
614 bio_endio(bio);
619 * If the bio is discard, return an error, but do not
622 if (bio_op(bio) == REQ_OP_DISCARD) {
623 bio->bi_status = BLK_STS_NOTSUPP;
624 bio_endio(bio);
640 bio_list_add(&ms->failures, bio);
646 static void do_write(struct mirror_set *ms, struct bio *bio)
653 .bi_op_flags = bio->bi_opf & (REQ_FUA | REQ_PREFLUSH),
655 .mem.ptr.bio = bio,
657 .notify.context = bio,
661 if (bio_op(bio) == REQ_OP_DISCARD) {
668 map_region(dest++, m, bio);
674 bio_set_m(bio, get_default_mirror(ms));
682 struct bio *bio;
699 while ((bio = bio_list_pop(writes))) {
700 if ((bio->bi_opf & REQ_PREFLUSH) ||
701 (bio_op(bio) == REQ_OP_DISCARD)) {
702 bio_list_add(&sync, bio);
706 region = dm_rh_bio_to_region(ms->rh, bio);
710 bio_list_add(&requeue, bio);
730 bio_list_add(this_list, bio);
768 while ((bio = bio_list_pop(&sync)))
769 do_write(ms, bio);
771 while ((bio = bio_list_pop(&recover)))
772 dm_rh_delay(ms->rh, bio);
774 while ((bio = bio_list_pop(&nosync))) {
777 bio_list_add(&ms->failures, bio);
781 map_bio(get_default_mirror(ms), bio);
782 submit_bio_noacct(bio);
789 struct bio *bio;
811 while ((bio = bio_list_pop(failures))) {
814 dm_rh_mark_nosync(ms->rh, bio);
823 * isn't enabled, hold the bio and wait for userspace to
831 bio_io_error(bio);
833 hold_bio(ms, bio);
835 bio_endio(bio);
1184 static int mirror_map(struct dm_target *ti, struct bio *bio)
1186 int r, rw = bio_data_dir(bio);
1191 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1197 bio_record->write_region = dm_rh_bio_to_region(ms->rh, bio);
1198 queue_bio(ms, bio, rw);
1202 r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
1207 * If region is not in-sync queue the bio.
1210 if (bio->bi_opf & REQ_RAHEAD)
1213 queue_bio(ms, bio, rw);
1221 m = choose_mirror(ms, bio->bi_iter.bi_sector);
1225 dm_bio_record(&bio_record->details, bio);
1228 map_bio(m, bio);
1233 static int mirror_end_io(struct dm_target *ti, struct bio *bio,
1236 int rw = bio_data_dir(bio);
1241 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1247 if (!(bio->bi_opf & REQ_PREFLUSH) &&
1248 bio_op(bio) != REQ_OP_DISCARD)
1256 if (bio->bi_opf & REQ_RAHEAD)
1281 if (default_ok(m) || mirror_available(ms, bio)) {
1284 dm_bio_restore(bd, bio);
1286 bio->bi_status = 0;
1288 queue_bio(ms, bio, rw);
1306 struct bio *bio;
1312 * for bios in the hold list. After the process, no bio has
1321 while ((bio = bio_list_pop(&holds)))
1322 hold_bio(ms, bio);