Re: [dm-devel] [PATCH 23/42] md/raid: set bi_op to REQ_OP

Shaun Tancheff
2016-04-23T23:27:04Z

[-- Attachment #1.1: Type: text/plain, Size: 37466 bytes --]

On Fri, Apr 15, 2016 at 5:39 AM, <mchristi@redhat.com> wrote:

> From: Mike Christie <mchristi@redhat.com>
>
> This patch has md use bio->bi_op for REQ_OPs and rq_flag_bits
> to bio->bi_rw.
>
> Signed-off-by: Mike Christie <mchristi@redhat.com>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Hannes Reinecke <hare@suse.com>
> ---
> drivers/md/bitmap.c | 2 +-
> drivers/md/dm-raid.c | 5 +++--
> drivers/md/md.c | 11 +++++++----
> drivers/md/md.h | 3 ++-
> drivers/md/raid1.c | 34 ++++++++++++++++----------------
> drivers/md/raid10.c | 50
> ++++++++++++++++++++++++++----------------------
> drivers/md/raid5-cache.c | 25 +++++++++++++++---------
> drivers/md/raid5.c | 48
> ++++++++++++++++++++++++++--------------------
> 8 files changed, 101 insertions(+), 77 deletions(-)
>
>
Sorry I though this would thread propertly:
https://lkml.kernel.org/r/1461452709-6702-1-git-send-email-shaun@tancheff.com

In raid0.c, raid10.c and raid5.c

A couple of checks for REQ_PREFLUSH flag should also check for
bi_op matching REQ_OP_FLUSH.

In raid1.c [r1_sync_page_io()] and raid10.c [r10_sync_page_io()]

Wrappers for sync_page_io() are passed READ/WRITE but need to
be passed REQ_OP_READ and REQ_OP_WRITE.

Anyway my raid testing was getting weird hangs and corruption
without the patch.

Thanks!

> diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
> index 8b2e16f..9e8019e 100644
> --- a/drivers/md/bitmap.c
> +++ b/drivers/md/bitmap.c
> @@ -159,7 +159,7 @@ static int read_sb_page(struct mddev *mddev, loff_t
> offset,
>
> if (sync_page_io(rdev, target,
> roundup(size,
> bdev_logical_block_size(rdev->bdev)),
> - page, READ, true)) {
> + page, REQ_OP_READ, 0, true)) {
> page->index = index;
> return 0;
> }
> diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
> index a090121..43a749c 100644
> --- a/drivers/md/dm-raid.c
> +++ b/drivers/md/dm-raid.c
> @@ -792,7 +792,7 @@ static int read_disk_sb(struct md_rdev *rdev, int size)
> if (rdev->sb_loaded)
> return 0;
>
> - if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, 1)) {
> + if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0,
> 1)) {
> DMERR("Failed to read superblock of device at position %d",
> rdev->raid_disk);
> md_error(rdev->mddev, rdev);
> @@ -1646,7 +1646,8 @@ static void attempt_restore_of_faulty_devices(struct
> raid_set *rs)
> for (i = 0; i < rs->md.raid_disks; i++) {
> r = &rs->dev[i].rdev;
> if (test_bit(Faulty, &r->flags) && r->sb_page &&
> - sync_page_io(r, 0, r->sb_size, r->sb_page, READ, 1)) {
> + sync_page_io(r, 0, r->sb_size, r->sb_page,
> REQ_OP_READ, 0,
> + 1)) {
> DMINFO("Faulty %s device #%d has readable super
> block."
> " Attempting to revive it.",
> rs->raid_type->name, i);
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index ec3c98d..9c40368 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -392,6 +392,7 @@ static void submit_flushes(struct work_struct *ws)
> bi->bi_end_io = md_end_flush;
> bi->bi_private = rdev;
> bi->bi_bdev = rdev->bdev;
> + bi->bi_op = REQ_OP_WRITE;
> bi->bi_rw = WRITE_FLUSH;
> atomic_inc(&mddev->flush_pending);
> submit_bio(bi);
> @@ -741,6 +742,7 @@ void md_super_write(struct mddev *mddev, struct
> md_rdev *rdev,
> bio_add_page(bio, page, size, 0);
> bio->bi_private = rdev;
> bio->bi_end_io = super_written;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_rw = WRITE_FLUSH_FUA;
>
> atomic_inc(&mddev->pending_writes);
> @@ -754,14 +756,15 @@ void md_super_wait(struct mddev *mddev)
> }
>
> int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
> - struct page *page, int rw, bool metadata_op)
> + struct page *page, int op, int op_flags, bool metadata_op)
> {
> struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
> int ret;
>
> bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
> rdev->meta_bdev : rdev->bdev;
> - bio->bi_rw = rw;
> + bio->bi_op = op;
> + bio->bi_rw = op_flags;
> if (metadata_op)
> bio->bi_iter.bi_sector = sector + rdev->sb_start;
> else if (rdev->mddev->reshape_position != MaxSector &&
> @@ -787,7 +790,7 @@ static int read_disk_sb(struct md_rdev *rdev, int size)
> if (rdev->sb_loaded)
> return 0;
>
> - if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
> + if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0,
> true))
> goto fail;
> rdev->sb_loaded = 1;
> return 0;
> @@ -1473,7 +1476,7 @@ static int super_1_load(struct md_rdev *rdev, struct
> md_rdev *refdev, int minor_
> return -EINVAL;
> bb_sector = (long long)offset;
> if (!sync_page_io(rdev, bb_sector, sectors << 9,
> - rdev->bb_page, READ, true))
> + rdev->bb_page, REQ_OP_READ, 0, true))
> return -EIO;
> bbp = (u64 *)page_address(rdev->bb_page);
> rdev->badblocks.shift = sb->bblog_shift;
> diff --git a/drivers/md/md.h b/drivers/md/md.h
> index b5c4be7..2e0918f 100644
> --- a/drivers/md/md.h
> +++ b/drivers/md/md.h
> @@ -618,7 +618,8 @@ extern void md_super_write(struct mddev *mddev, struct
> md_rdev *rdev,
> sector_t sector, int size, struct page *page);
> extern void md_super_wait(struct mddev *mddev);
> extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
> - struct page *page, int rw, bool metadata_op);
> + struct page *page, int op, int op_flags,
> + bool metadata_op);
> extern void md_do_sync(struct md_thread *thread);
> extern void md_new_event(struct mddev *mddev);
> extern int md_allow_write(struct mddev *mddev);
> diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
> index 424df7e..c7abd2d 100644
> --- a/drivers/md/raid1.c
> +++ b/drivers/md/raid1.c
> @@ -759,7 +759,7 @@ static void flush_pending_writes(struct r1conf *conf)
> while (bio) { /* submit pending writes */
> struct bio *next = bio->bi_next;
> bio->bi_next = NULL;
> - if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> + if (unlikely((bio->bi_op == REQ_OP_DISCARD) &&
>
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> bio_endio(bio);
> @@ -1033,7 +1033,7 @@ static void raid1_unplug(struct blk_plug_cb *cb,
> bool from_schedule)
> while (bio) { /* submit pending writes */
> struct bio *next = bio->bi_next;
> bio->bi_next = NULL;
> - if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> + if (unlikely((bio->bi_op == REQ_OP_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> bio_endio(bio);
> @@ -1053,12 +1053,11 @@ static void raid1_make_request(struct mddev
> *mddev, struct bio * bio)
> int i, disks;
> struct bitmap *bitmap;
> unsigned long flags;
> + const int op = bio->bi_op;
> const int rw = bio_data_dir(bio);
> const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
> const unsigned long do_flush_fua = (bio->bi_rw & (REQ_FLUSH |
> REQ_FUA));
> - const unsigned long do_discard = (bio->bi_rw
> - & (REQ_DISCARD | REQ_SECURE));
> - const unsigned long do_same = (bio->bi_rw & REQ_WRITE_SAME);
> + const unsigned long do_sec = (bio->bi_rw & REQ_SECURE);
> struct md_rdev *blocked_rdev;
> struct blk_plug_cb *cb;
> struct raid1_plug_cb *plug = NULL;
> @@ -1166,7 +1165,8 @@ read_again:
> mirror->rdev->data_offset;
> read_bio->bi_bdev = mirror->rdev->bdev;
> read_bio->bi_end_io = raid1_end_read_request;
> - read_bio->bi_rw = READ | do_sync;
> + read_bio->bi_op = op;
> + read_bio->bi_rw = do_sync;
> read_bio->bi_private = r1_bio;
>
> if (max_sectors < r1_bio->sectors) {
> @@ -1376,8 +1376,9 @@ read_again:
> conf->mirrors[i].rdev->data_offset);
> mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
> mbio->bi_end_io = raid1_end_write_request;
> + mbio->bi_op = op;
> mbio->bi_rw =
> - WRITE | do_flush_fua | do_sync | do_discard |
> do_same;
> + do_flush_fua | do_sync | do_sec;
> mbio->bi_private = r1_bio;
>
> atomic_inc(&r1_bio->remaining);
> @@ -1771,7 +1772,7 @@ static void end_sync_write(struct bio *bio)
> static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector,
> int sectors, struct page *page, int rw)
> {
> - if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
> + if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))
> /* success */
> return 1;
> if (rw == WRITE) {
> @@ -1825,7 +1826,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio)
> rdev = conf->mirrors[d].rdev;
> if (sync_page_io(rdev, sect, s<<9,
>
> bio->bi_io_vec[idx].bv_page,
> - READ, false)) {
> + REQ_OP_READ, 0, false)) {
> success = 1;
> break;
> }
> @@ -2030,7 +2031,7 @@ static void sync_request_write(struct mddev *mddev,
> struct r1bio *r1_bio)
> !test_bit(MD_RECOVERY_SYNC, &mddev->recovery))))
> continue;
>
> - wbio->bi_rw = WRITE;
> + wbio->bi_op = REQ_OP_WRITE;
> wbio->bi_end_io = end_sync_write;
> atomic_inc(&r1_bio->remaining);
> md_sync_acct(conf->mirrors[i].rdev->bdev,
> bio_sectors(wbio));
> @@ -2090,7 +2091,7 @@ static void fix_read_error(struct r1conf *conf, int
> read_disk,
> is_badblock(rdev, sect, s,
> &first_bad, &bad_sectors) == 0 &&
> sync_page_io(rdev, sect, s<<9,
> - conf->tmppage, READ, false))
> + conf->tmppage, REQ_OP_READ, 0,
> false))
> success = 1;
> else {
> d++;
> @@ -2201,7 +2202,7 @@ static int narrow_write_error(struct r1bio *r1_bio,
> int i)
> wbio = bio_clone_mddev(r1_bio->master_bio,
> GFP_NOIO, mddev);
> }
>
> - wbio->bi_rw = WRITE;
> + wbio->bi_op = REQ_OP_WRITE;
> wbio->bi_iter.bi_sector = r1_bio->sector;
> wbio->bi_iter.bi_size = r1_bio->sectors << 9;
>
> @@ -2344,7 +2345,8 @@ read_more:
> bio->bi_iter.bi_sector = r1_bio->sector +
> rdev->data_offset;
> bio->bi_bdev = rdev->bdev;
> bio->bi_end_io = raid1_end_read_request;
> - bio->bi_rw = READ | do_sync;
> + bio->bi_op = REQ_OP_READ;
> + bio->bi_rw = do_sync;
> bio->bi_private = r1_bio;
> if (max_sectors < r1_bio->sectors) {
> /* Drat - have to split this up more */
> @@ -2572,7 +2574,7 @@ static sector_t raid1_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> if (i < conf->raid_disks)
> still_degraded = 1;
> } else if (!test_bit(In_sync, &rdev->flags)) {
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_end_io = end_sync_write;
> write_targets ++;
> } else {
> @@ -2599,7 +2601,7 @@ static sector_t raid1_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> if (disk < 0)
> disk = i;
> }
> - bio->bi_rw = READ;
> + bio->bi_op = REQ_OP_READ;
> bio->bi_end_io = end_sync_read;
> read_targets++;
> } else if (!test_bit(WriteErrorSeen, &rdev->flags)
> &&
> @@ -2611,7 +2613,7 @@ static sector_t raid1_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> * if we are doing resync or repair.
> Otherwise, leave
> * this device alone for this sync request.
> */
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_end_io = end_sync_write;
> write_targets++;
> }
> diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
> index 4736be8..63cd985 100644
> --- a/drivers/md/raid10.c
> +++ b/drivers/md/raid10.c
> @@ -865,7 +865,7 @@ static void flush_pending_writes(struct r10conf *conf)
> while (bio) { /* submit pending writes */
> struct bio *next = bio->bi_next;
> bio->bi_next = NULL;
> - if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> + if (unlikely((bio->bi_op == REQ_OP_DISCARD) &&
>
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> bio_endio(bio);
> @@ -1041,7 +1041,7 @@ static void raid10_unplug(struct blk_plug_cb *cb,
> bool from_schedule)
> while (bio) { /* submit pending writes */
> struct bio *next = bio->bi_next;
> bio->bi_next = NULL;
> - if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> + if (unlikely((bio->bi_op == REQ_OP_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> bio_endio(bio);
> @@ -1058,12 +1058,11 @@ static void __make_request(struct mddev *mddev,
> struct bio *bio)
> struct r10bio *r10_bio;
> struct bio *read_bio;
> int i;
> + const int op = bio->bi_op;
> const int rw = bio_data_dir(bio);
> const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
> const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
> - const unsigned long do_discard = (bio->bi_rw
> - & (REQ_DISCARD | REQ_SECURE));
> - const unsigned long do_same = (bio->bi_rw & REQ_WRITE_SAME);
> + const unsigned long do_sec = (bio->bi_rw & REQ_SECURE);
> unsigned long flags;
> struct md_rdev *blocked_rdev;
> struct blk_plug_cb *cb;
> @@ -1156,7 +1155,8 @@ read_again:
> choose_data_offset(r10_bio, rdev);
> read_bio->bi_bdev = rdev->bdev;
> read_bio->bi_end_io = raid10_end_read_request;
> - read_bio->bi_rw = READ | do_sync;
> + read_bio->bi_op = op;
> + read_bio->bi_rw = do_sync;
> read_bio->bi_private = r10_bio;
>
> if (max_sectors < r10_bio->sectors) {
> @@ -1363,8 +1363,9 @@ retry_write:
> rdev));
> mbio->bi_bdev = rdev->bdev;
> mbio->bi_end_io = raid10_end_write_request;
> + mbio->bi_op = op;
> mbio->bi_rw =
> - WRITE | do_sync | do_fua | do_discard |
> do_same;
> + do_sync | do_fua | do_sec;
> mbio->bi_private = r10_bio;
>
> atomic_inc(&r10_bio->remaining);
> @@ -1406,8 +1407,9 @@ retry_write:
> r10_bio, rdev));
> mbio->bi_bdev = rdev->bdev;
> mbio->bi_end_io = raid10_end_write_request;
> + mbio->bi_op = op;
> mbio->bi_rw =
> - WRITE | do_sync | do_fua | do_discard |
> do_same;
> + do_sync | do_fua | do_sec;
> mbio->bi_private = r10_bio;
>
> atomic_inc(&r10_bio->remaining);
> @@ -1992,7 +1994,7 @@ static void sync_request_write(struct mddev *mddev,
> struct r10bio *r10_bio)
>
> tbio->bi_vcnt = vcnt;
> tbio->bi_iter.bi_size = fbio->bi_iter.bi_size;
> - tbio->bi_rw = WRITE;
> + tbio->bi_op = REQ_OP_WRITE;
> tbio->bi_private = r10_bio;
> tbio->bi_iter.bi_sector = r10_bio->devs[i].addr;
> tbio->bi_end_io = end_sync_write;
> @@ -2078,7 +2080,7 @@ static void fix_recovery_read_error(struct r10bio
> *r10_bio)
> addr,
> s << 9,
> bio->bi_io_vec[idx].bv_page,
> - READ, false);
> + REQ_OP_READ, 0, false);
> if (ok) {
> rdev = conf->mirrors[dw].rdev;
> addr = r10_bio->devs[1].addr + sect;
> @@ -2086,7 +2088,7 @@ static void fix_recovery_read_error(struct r10bio
> *r10_bio)
> addr,
> s << 9,
> bio->bi_io_vec[idx].bv_page,
> - WRITE, false);
> + REQ_OP_WRITE, 0, false);
> if (!ok) {
> set_bit(WriteErrorSeen, &rdev->flags);
> if (!test_and_set_bit(WantReplacement,
> @@ -2213,7 +2215,7 @@ static int r10_sync_page_io(struct md_rdev *rdev,
> sector_t sector,
> if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
> && (rw == READ || test_bit(WriteErrorSeen, &rdev->flags)))
> return -1;
> - if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
> + if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))
> /* success */
> return 1;
> if (rw == WRITE) {
> @@ -2299,7 +2301,8 @@ static void fix_read_error(struct r10conf *conf,
> struct mddev *mddev, struct r10
>
> r10_bio->devs[sl].addr +
> sect,
> s<<9,
> - conf->tmppage,
> READ, false);
> + conf->tmppage,
> + REQ_OP_READ, 0,
> false);
> rdev_dec_pending(rdev, mddev);
> rcu_read_lock();
> if (success)
> @@ -2474,7 +2477,7 @@ static int narrow_write_error(struct r10bio
> *r10_bio, int i)
> choose_data_offset(r10_bio, rdev) +
> (sector - r10_bio->sector));
> wbio->bi_bdev = rdev->bdev;
> - wbio->bi_rw = WRITE;
> + wbio->bi_op = REQ_OP_WRITE;
>
> if (submit_bio_wait(wbio) < 0)
> /* Failure! */
> @@ -2550,7 +2553,8 @@ read_more:
> bio->bi_iter.bi_sector = r10_bio->devs[slot].addr
> + choose_data_offset(r10_bio, rdev);
> bio->bi_bdev = rdev->bdev;
> - bio->bi_rw = READ | do_sync;
> + bio->bi_op = REQ_OP_READ;
> + bio->bi_rw = do_sync;
> bio->bi_private = r10_bio;
> bio->bi_end_io = raid10_end_read_request;
> if (max_sectors < r10_bio->sectors) {
> @@ -3040,7 +3044,7 @@ static sector_t raid10_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> biolist = bio;
> bio->bi_private = r10_bio;
> bio->bi_end_io = end_sync_read;
> - bio->bi_rw = READ;
> + bio->bi_op = REQ_OP_READ;
> from_addr = r10_bio->devs[j].addr;
> bio->bi_iter.bi_sector = from_addr +
> rdev->data_offset;
> @@ -3066,7 +3070,7 @@ static sector_t raid10_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> biolist = bio;
> bio->bi_private = r10_bio;
> bio->bi_end_io = end_sync_write;
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_iter.bi_sector = to_addr
> + rdev->data_offset;
> bio->bi_bdev = rdev->bdev;
> @@ -3095,7 +3099,7 @@ static sector_t raid10_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> biolist = bio;
> bio->bi_private = r10_bio;
> bio->bi_end_io = end_sync_write;
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_iter.bi_sector = to_addr +
> rdev->data_offset;
> bio->bi_bdev = rdev->bdev;
> @@ -3215,7 +3219,7 @@ static sector_t raid10_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> biolist = bio;
> bio->bi_private = r10_bio;
> bio->bi_end_io = end_sync_read;
> - bio->bi_rw = READ;
> + bio->bi_op = REQ_OP_READ;
> bio->bi_iter.bi_sector = sector +
> conf->mirrors[d].rdev->data_offset;
> bio->bi_bdev = conf->mirrors[d].rdev->bdev;
> @@ -3237,7 +3241,7 @@ static sector_t raid10_sync_request(struct mddev
> *mddev, sector_t sector_nr,
> biolist = bio;
> bio->bi_private = r10_bio;
> bio->bi_end_io = end_sync_write;
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_iter.bi_sector = sector +
> conf->mirrors[d].replacement->data_offset;
> bio->bi_bdev = conf->mirrors[d].replacement->bdev;
> @@ -4320,7 +4324,7 @@ read_more:
> + rdev->data_offset);
> read_bio->bi_private = r10_bio;
> read_bio->bi_end_io = end_sync_read;
> - read_bio->bi_rw = READ;
> + read_bio->bi_op = REQ_OP_READ;
> read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
> read_bio->bi_error = 0;
> read_bio->bi_vcnt = 0;
> @@ -4354,7 +4358,7 @@ read_more:
> rdev2->new_data_offset;
> b->bi_private = r10_bio;
> b->bi_end_io = end_reshape_write;
> - b->bi_rw = WRITE;
> + b->bi_op = REQ_OP_WRITE;
> b->bi_next = blist;
> blist = b;
> }
> @@ -4522,7 +4526,7 @@ static int handle_reshape_read_error(struct mddev
> *mddev,
> addr,
> s << 9,
> bvec[idx].bv_page,
> - READ, false);
> + REQ_OP_READ, 0, false);
> if (success)
> break;
> failed:
> diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c
> index 90c2618..56b20c3 100644
> --- a/drivers/md/raid5-cache.c
> +++ b/drivers/md/raid5-cache.c
> @@ -261,7 +261,7 @@ static struct bio *r5l_bio_alloc(struct r5l_log *log)
> {
> struct bio *bio = bio_alloc_bioset(GFP_NOIO, BIO_MAX_PAGES,
> log->bs);
>
> - bio->bi_rw = WRITE;
> + bio->bi_op = REQ_OP_WRITE;
> bio->bi_bdev = log->rdev->bdev;
> bio->bi_iter.bi_sector = log->rdev->data_offset + log->log_start;
>
> @@ -686,6 +686,7 @@ void r5l_flush_stripe_to_raid(struct r5l_log *log)
> bio_reset(&log->flush_bio);
> log->flush_bio.bi_bdev = log->rdev->bdev;
> log->flush_bio.bi_end_io = r5l_log_flush_endio;
> + log->flush_bio.bi_op = REQ_OP_WRITE;
> log->flush_bio.bi_rw = WRITE_FLUSH;
> submit_bio(&log->flush_bio);
> }
> @@ -882,7 +883,8 @@ static int r5l_read_meta_block(struct r5l_log *log,
> struct r5l_meta_block *mb;
> u32 crc, stored_crc;
>
> - if (!sync_page_io(log->rdev, ctx->pos, PAGE_SIZE, page, READ,
> false))
> + if (!sync_page_io(log->rdev, ctx->pos, PAGE_SIZE, page,
> REQ_OP_READ, 0,
> + false))
> return -EIO;
>
> mb = page_address(page);
> @@ -927,7 +929,8 @@ static int r5l_recovery_flush_one_stripe(struct
> r5l_log *log,
> &disk_index, sh);
>
> sync_page_io(log->rdev, *log_offset, PAGE_SIZE,
> - sh->dev[disk_index].page, READ,
> false);
> + sh->dev[disk_index].page,
> REQ_OP_READ, 0,
> + false);
> sh->dev[disk_index].log_checksum =
> le32_to_cpu(payload->checksum[0]);
> set_bit(R5_Wantwrite, &sh->dev[disk_index].flags);
> @@ -935,7 +938,8 @@ static int r5l_recovery_flush_one_stripe(struct
> r5l_log *log,
> } else {
> disk_index = sh->pd_idx;
> sync_page_io(log->rdev, *log_offset, PAGE_SIZE,
> - sh->dev[disk_index].page, READ,
> false);
> + sh->dev[disk_index].page,
> REQ_OP_READ, 0,
> + false);
> sh->dev[disk_index].log_checksum =
> le32_to_cpu(payload->checksum[0]);
> set_bit(R5_Wantwrite, &sh->dev[disk_index].flags);
> @@ -945,7 +949,7 @@ static int r5l_recovery_flush_one_stripe(struct
> r5l_log *log,
> sync_page_io(log->rdev,
> r5l_ring_add(log,
> *log_offset, BLOCK_SECTORS),
> PAGE_SIZE,
> sh->dev[disk_index].page,
> - READ, false);
> + REQ_OP_READ, 0, false);
> sh->dev[disk_index].log_checksum =
> le32_to_cpu(payload->checksum[1]);
> set_bit(R5_Wantwrite,
> @@ -987,11 +991,13 @@ static int r5l_recovery_flush_one_stripe(struct
> r5l_log *log,
> rdev = rcu_dereference(conf->disks[disk_index].rdev);
> if (rdev)
> sync_page_io(rdev, stripe_sect, PAGE_SIZE,
> - sh->dev[disk_index].page, WRITE,
> false);
> + sh->dev[disk_index].page,
> REQ_OP_WRITE, 0,
> + false);
> rrdev =
> rcu_dereference(conf->disks[disk_index].replacement);
> if (rrdev)
> sync_page_io(rrdev, stripe_sect, PAGE_SIZE,
> - sh->dev[disk_index].page, WRITE,
> false);
> + sh->dev[disk_index].page,
> REQ_OP_WRITE, 0,
> + false);
> }
> raid5_release_stripe(sh);
> return 0;
> @@ -1063,7 +1069,8 @@ static int r5l_log_write_empty_meta_block(struct
> r5l_log *log, sector_t pos,
> crc = crc32c_le(log->uuid_checksum, mb, PAGE_SIZE);
> mb->checksum = cpu_to_le32(crc);
>
> - if (!sync_page_io(log->rdev, pos, PAGE_SIZE, page, WRITE_FUA,
> false)) {
> + if (!sync_page_io(log->rdev, pos, PAGE_SIZE, page, REQ_OP_WRITE,
> + WRITE_FUA, false)) {
> __free_page(page);
> return -EIO;
> }
> @@ -1138,7 +1145,7 @@ static int r5l_load_log(struct r5l_log *log)
> if (!page)
> return -ENOMEM;
>
> - if (!sync_page_io(rdev, cp, PAGE_SIZE, page, READ, false)) {
> + if (!sync_page_io(rdev, cp, PAGE_SIZE, page, REQ_OP_READ, 0,
> false)) {
> ret = -EIO;
> goto ioerr;
> }
> diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
> index 8ab8b65..c36b817 100644
> --- a/drivers/md/raid5.c
> +++ b/drivers/md/raid5.c
> @@ -806,7 +806,8 @@ static void stripe_add_to_batch_list(struct r5conf
> *conf, struct stripe_head *sh
> dd_idx = 0;
> while (dd_idx == sh->pd_idx || dd_idx == sh->qd_idx)
> dd_idx++;
> - if (head->dev[dd_idx].towrite->bi_rw !=
> sh->dev[dd_idx].towrite->bi_rw)
> + if (head->dev[dd_idx].towrite->bi_rw !=
> sh->dev[dd_idx].towrite->bi_rw ||
> + head->dev[dd_idx].towrite->bi_op !=
> sh->dev[dd_idx].towrite->bi_op)
> goto unlock_out;
>
> if (head->batch_head) {
> @@ -891,29 +892,32 @@ static void ops_run_io(struct stripe_head *sh,
> struct stripe_head_state *s)
> if (r5l_write_stripe(conf->log, sh) == 0)
> return;
> for (i = disks; i--; ) {
> - int rw;
> + int op;
> + int op_flags = 0;
> int replace_only = 0;
> struct bio *bi, *rbi;
> struct md_rdev *rdev, *rrdev = NULL;
>
> sh = head_sh;
> if (test_and_clear_bit(R5_Wantwrite, &sh->dev[i].flags)) {
> - if (test_and_clear_bit(R5_WantFUA,
> &sh->dev[i].flags))
> - rw = WRITE_FUA;
> - else
> - rw = WRITE;
> + if (test_and_clear_bit(R5_WantFUA,
> &sh->dev[i].flags)) {
> + op = REQ_OP_WRITE;
> + op_flags = WRITE_FUA;
> + } else {
> + op = REQ_OP_WRITE;
> + }
> if (test_bit(R5_Discard, &sh->dev[i].flags))
> - rw |= REQ_DISCARD;
> + op = REQ_OP_DISCARD;
> } else if (test_and_clear_bit(R5_Wantread,
> &sh->dev[i].flags))
> - rw = READ;
> + op = REQ_OP_READ;
> else if (test_and_clear_bit(R5_WantReplace,
> &sh->dev[i].flags)) {
> - rw = WRITE;
> + op = REQ_OP_WRITE;
> replace_only = 1;
> } else
> continue;
> if (test_and_clear_bit(R5_SyncIO, &sh->dev[i].flags))
> - rw |= REQ_SYNC;
> + op_flags |= REQ_SYNC;
>
> again:
> bi = &sh->dev[i].req;
> @@ -927,7 +931,7 @@ again:
> rdev = rrdev;
> rrdev = NULL;
> }
> - if (rw & WRITE) {
> + if (op_is_write(op)) {
> if (replace_only)
> rdev = NULL;
> if (rdev == rrdev)
> @@ -953,7 +957,7 @@ again:
> * need to check for writes. We never accept write errors
> * on the replacement, so we don't to check rrdev.
> */
> - while ((rw & WRITE) && rdev &&
> + while (op_is_write(op) && rdev &&
> test_bit(WriteErrorSeen, &rdev->flags)) {
> sector_t first_bad;
> int bad_sectors;
> @@ -995,8 +999,9 @@ again:
>
> bio_reset(bi);
> bi->bi_bdev = rdev->bdev;
> - bi->bi_rw = rw;
> - bi->bi_end_io = (rw & WRITE)
> + bi->bi_op = op;
> + bi->bi_rw = op_flags;
> + bi->bi_end_io = op_is_write(op)
> ? raid5_end_write_request
> : raid5_end_read_request;
> bi->bi_private = sh;
> @@ -1027,7 +1032,7 @@ again:
> * If this is discard request, set bi_vcnt 0. We
> don't
> * want to confuse SCSI because SCSI will replace
> payload
> */
> - if (rw & REQ_DISCARD)
> + if (op == REQ_OP_DISCARD)
> bi->bi_vcnt = 0;
> if (rrdev)
> set_bit(R5_DOUBLE_LOCKED,
> &sh->dev[i].flags);
> @@ -1047,8 +1052,9 @@ again:
>
> bio_reset(rbi);
> rbi->bi_bdev = rrdev->bdev;
> - rbi->bi_rw = rw;
> - BUG_ON(!(rw & WRITE));
> + rbi->bi_op = op;
> + rbi->bi_rw = op_flags;
> + BUG_ON(!op_is_write(op));
> rbi->bi_end_io = raid5_end_write_request;
> rbi->bi_private = sh;
>
> @@ -1076,7 +1082,7 @@ again:
> * If this is discard request, set bi_vcnt 0. We
> don't
> * want to confuse SCSI because SCSI will replace
> payload
> */
> - if (rw & REQ_DISCARD)
> + if (op == REQ_OP_DISCARD)
> rbi->bi_vcnt = 0;
> if (conf->mddev->gendisk)
>
> trace_block_bio_remap(bdev_get_queue(rbi->bi_bdev),
> @@ -1085,7 +1091,7 @@ again:
> generic_make_request(rbi);
> }
> if (!rdev && !rrdev) {
> - if (rw & WRITE)
> + if (op_is_write(op))
> set_bit(STRIPE_DEGRADED, &sh->state);
> pr_debug("skip op %ld on disc %d for sector
> %llu\n",
> bi->bi_rw, i, (unsigned long
> long)sh->sector);
> @@ -1623,7 +1629,7 @@ again:
> set_bit(R5_WantFUA, &dev->flags);
> if (wbi->bi_rw & REQ_SYNC)
> set_bit(R5_SyncIO, &dev->flags);
> - if (wbi->bi_rw & REQ_DISCARD)
> + if (wbi->bi_op == REQ_OP_DISCARD)
> set_bit(R5_Discard, &dev->flags);
> else {
> tx = async_copy_data(1, wbi,
> &dev->page,
> @@ -5178,7 +5184,7 @@ static void raid5_make_request(struct mddev *mddev,
> struct bio * bi)
> return;
> }
>
> - if (unlikely(bi->bi_rw & REQ_DISCARD)) {
> + if (unlikely(bi->bi_op == REQ_OP_DISCARD)) {
> make_discard_request(mddev, bi);
> return;
> }
> --
> 2.7.2
>
> --
> dm-devel mailing list
> dm-devel@redhat.com
> https://www.redhat.com/mailman/listinfo/dm-devel
>

--
Shaun Tancheff

[-- Attachment #1.2: Type: text/html, Size: 48914 bytes --]

[-- Attachment #2: Type: text/plain, Size: 121 bytes --]