block/fs/drivers: remove rw argument from submit_bio
authorMike Christie <mchristi@redhat.com>
Sun, 5 Jun 2016 19:31:41 +0000 (14:31 -0500)
committerJens Axboe <axboe@fb.com>
Tue, 7 Jun 2016 19:41:38 +0000 (13:41 -0600)
This has callers of submit_bio/submit_bio_wait set the bio->bi_rw
instead of passing it in. This makes that use the same as
generic_make_request and how we set the other bio fields.

Signed-off-by: Mike Christie <mchristi@redhat.com>
Fixed up fs/ext4/crypto.c

Signed-off-by: Jens Axboe <axboe@fb.com>
53 files changed:
block/bio.c
block/blk-core.c
block/blk-flush.c
block/blk-lib.c
drivers/block/drbd/drbd_actlog.c
drivers/block/drbd/drbd_bitmap.c
drivers/block/floppy.c
drivers/block/xen-blkback/blkback.c
drivers/block/xen-blkfront.c
drivers/md/bcache/debug.c
drivers/md/bcache/journal.c
drivers/md/bcache/super.c
drivers/md/dm-bufio.c
drivers/md/dm-io.c
drivers/md/dm-log-writes.c
drivers/md/dm-thin.c
drivers/md/md.c
drivers/md/raid1.c
drivers/md/raid10.c
drivers/md/raid5-cache.c
drivers/target/target_core_iblock.c
fs/btrfs/check-integrity.c
fs/btrfs/check-integrity.h
fs/btrfs/disk-io.c
fs/btrfs/extent_io.c
fs/btrfs/raid56.c
fs/btrfs/scrub.c
fs/btrfs/volumes.c
fs/buffer.c
fs/crypto/crypto.c
fs/direct-io.c
fs/ext4/crypto.c
fs/ext4/page-io.c
fs/ext4/readpage.c
fs/f2fs/data.c
fs/f2fs/segment.c
fs/gfs2/lops.c
fs/gfs2/meta_io.c
fs/gfs2/ops_fstype.c
fs/hfsplus/wrapper.c
fs/jfs/jfs_logmgr.c
fs/jfs/jfs_metapage.c
fs/logfs/dev_bdev.c
fs/mpage.c
fs/nfs/blocklayout/blocklayout.c
fs/nilfs2/segbuf.c
fs/ocfs2/cluster/heartbeat.c
fs/xfs/xfs_aops.c
fs/xfs/xfs_buf.c
include/linux/bio.h
include/linux/fs.h
kernel/power/swap.c
mm/page_io.c

index 0e4aa42bc30dc7919a58b5c93b4470d43cf01f85..fc779eba0b95ed401f608dfba970255d709e5f55 100644 (file)
@@ -854,21 +854,20 @@ static void submit_bio_wait_endio(struct bio *bio)
 
 /**
  * submit_bio_wait - submit a bio, and wait until it completes
- * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
  * @bio: The &struct bio which describes the I/O
  *
  * Simple wrapper around submit_bio(). Returns 0 on success, or the error from
  * bio_endio() on failure.
  */
-int submit_bio_wait(int rw, struct bio *bio)
+int submit_bio_wait(struct bio *bio)
 {
        struct submit_bio_ret ret;
 
-       rw |= REQ_SYNC;
        init_completion(&ret.event);
        bio->bi_private = &ret;
        bio->bi_end_io = submit_bio_wait_endio;
-       submit_bio(rw, bio);
+       bio->bi_rw |= REQ_SYNC;
+       submit_bio(bio);
        wait_for_completion_io(&ret.event);
 
        return ret.error;
index 2475b1c72773c53c0c60ebfb466929c82b2a0d2c..e953407895924901533d925d53ab18af61872a23 100644 (file)
@@ -2094,7 +2094,6 @@ EXPORT_SYMBOL(generic_make_request);
 
 /**
  * submit_bio - submit a bio to the block device layer for I/O
- * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
  * @bio: The &struct bio which describes the I/O
  *
  * submit_bio() is very similar in purpose to generic_make_request(), and
@@ -2102,10 +2101,8 @@ EXPORT_SYMBOL(generic_make_request);
  * interfaces; @bio must be presetup and ready for I/O.
  *
  */
-blk_qc_t submit_bio(int rw, struct bio *bio)
+blk_qc_t submit_bio(struct bio *bio)
 {
-       bio->bi_rw |= rw;
-
        /*
         * If it's a regular read/write or a barrier with data attached,
         * go through the normal accounting stuff before submission.
@@ -2113,12 +2110,12 @@ blk_qc_t submit_bio(int rw, struct bio *bio)
        if (bio_has_data(bio)) {
                unsigned int count;
 
-               if (unlikely(rw & REQ_WRITE_SAME))
+               if (unlikely(bio->bi_rw & REQ_WRITE_SAME))
                        count = bdev_logical_block_size(bio->bi_bdev) >> 9;
                else
                        count = bio_sectors(bio);
 
-               if (rw & WRITE) {
+               if (bio->bi_rw & WRITE) {
                        count_vm_events(PGPGOUT, count);
                } else {
                        task_io_account_read(bio->bi_iter.bi_size);
@@ -2129,7 +2126,7 @@ blk_qc_t submit_bio(int rw, struct bio *bio)
                        char b[BDEVNAME_SIZE];
                        printk(KERN_DEBUG "%s(%d): %s block %Lu on %s (%u sectors)\n",
                        current->comm, task_pid_nr(current),
-                               (rw & WRITE) ? "WRITE" : "READ",
+                               (bio->bi_rw & WRITE) ? "WRITE" : "READ",
                                (unsigned long long)bio->bi_iter.bi_sector,
                                bdevname(bio->bi_bdev, b),
                                count);
index b1c91d229e5ed905fd0cdbb7354457eed07889df..3af4a5ad46f5ebac9cad27b47c9105cfe6b0e7ec 100644 (file)
@@ -485,8 +485,9 @@ int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
 
        bio = bio_alloc(gfp_mask, 0);
        bio->bi_bdev = bdev;
+       bio->bi_rw = WRITE_FLUSH;
 
-       ret = submit_bio_wait(WRITE_FLUSH, bio);
+       ret = submit_bio_wait(bio);
 
        /*
         * The driver must store the error location in ->bi_sector, if
index 23d7f301a1967483ec79a383a1a317881caf3358..1f6dec5e097554ee1d642725dab7de281eaec81c 100644 (file)
@@ -9,14 +9,14 @@
 
 #include "blk.h"
 
-static struct bio *next_bio(struct bio *bio, int rw, unsigned int nr_pages,
+static struct bio *next_bio(struct bio *bio, unsigned int nr_pages,
                gfp_t gfp)
 {
        struct bio *new = bio_alloc(gfp, nr_pages);
 
        if (bio) {
                bio_chain(bio, new);
-               submit_bio(rw, bio);
+               submit_bio(bio);
        }
 
        return new;
@@ -62,9 +62,10 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                        req_sects = end_sect - sector;
                }
 
-               bio = next_bio(bio, type, 1, gfp_mask);
+               bio = next_bio(bio, 1, gfp_mask);
                bio->bi_iter.bi_sector = sector;
                bio->bi_bdev = bdev;
+               bio->bi_rw = type;
 
                bio->bi_iter.bi_size = req_sects << 9;
                nr_sects -= req_sects;
@@ -110,7 +111,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
        ret = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, type,
                        &bio);
        if (!ret && bio) {
-               ret = submit_bio_wait(type, bio);
+               ret = submit_bio_wait(bio);
                if (ret == -EOPNOTSUPP)
                        ret = 0;
        }
@@ -147,13 +148,14 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
        max_write_same_sectors = UINT_MAX >> 9;
 
        while (nr_sects) {
-               bio = next_bio(bio, REQ_WRITE | REQ_WRITE_SAME, 1, gfp_mask);
+               bio = next_bio(bio, 1, gfp_mask);
                bio->bi_iter.bi_sector = sector;
                bio->bi_bdev = bdev;
                bio->bi_vcnt = 1;
                bio->bi_io_vec->bv_page = page;
                bio->bi_io_vec->bv_offset = 0;
                bio->bi_io_vec->bv_len = bdev_logical_block_size(bdev);
+               bio->bi_rw = REQ_WRITE | REQ_WRITE_SAME;
 
                if (nr_sects > max_write_same_sectors) {
                        bio->bi_iter.bi_size = max_write_same_sectors << 9;
@@ -166,7 +168,7 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
        }
 
        if (bio)
-               ret = submit_bio_wait(REQ_WRITE | REQ_WRITE_SAME, bio);
+               ret = submit_bio_wait(bio);
        return ret != -EOPNOTSUPP ? ret : 0;
 }
 EXPORT_SYMBOL(blkdev_issue_write_same);
@@ -190,11 +192,11 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
        unsigned int sz;
 
        while (nr_sects != 0) {
-               bio = next_bio(bio, WRITE,
-                               min(nr_sects, (sector_t)BIO_MAX_PAGES),
+               bio = next_bio(bio, min(nr_sects, (sector_t)BIO_MAX_PAGES),
                                gfp_mask);
                bio->bi_iter.bi_sector = sector;
                bio->bi_bdev   = bdev;
+               bio->bi_rw = REQ_WRITE;
 
                while (nr_sects != 0) {
                        sz = min((sector_t) PAGE_SIZE >> 9 , nr_sects);
@@ -207,7 +209,7 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
        }
 
        if (bio)
-               return submit_bio_wait(WRITE, bio);
+               return submit_bio_wait(bio);
        return 0;
 }
 
index 10459a14506224ede01f9bbca97be127397142cd..6069e152c32f14296153b0453fd9424da2a36e83 100644 (file)
@@ -177,7 +177,7 @@ static int _drbd_md_sync_page_io(struct drbd_device *device,
        if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD))
                bio_io_error(bio);
        else
-               submit_bio(rw, bio);
+               submit_bio(bio);
        wait_until_done_or_force_detached(device, bdev, &device->md_io.done);
        if (!bio->bi_error)
                err = device->md_io.error;
index 92d6fc020a657c0694cc02c99d134fdf47c85c12..e8959fee1fa3d42457bc120bd96df08165a4d319 100644 (file)
@@ -1011,12 +1011,12 @@ static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_ho
        bio_add_page(bio, page, len, 0);
        bio->bi_private = ctx;
        bio->bi_end_io = drbd_bm_endio;
+       bio->bi_rw = rw;
 
        if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD)) {
-               bio->bi_rw |= rw;
                bio_io_error(bio);
        } else {
-               submit_bio(rw, bio);
+               submit_bio(bio);
                /* this should not count as user activity and cause the
                 * resync to throttle -- see drbd_rs_should_slow_down(). */
                atomic_add(len >> 9, &device->rs_sect_ev);
index 84708a5f8c520cb86db4ad62a4b845a5ec83b88f..73ded25b82c4048d6a4f93954fd338daa0f561f8 100644 (file)
@@ -3822,8 +3822,9 @@ static int __floppy_read_block_0(struct block_device *bdev, int drive)
        bio.bi_flags |= (1 << BIO_QUIET);
        bio.bi_private = &cbdata;
        bio.bi_end_io = floppy_rb0_cb;
+       bio.bi_rw = READ;
 
-       submit_bio(READ, &bio);
+       submit_bio(&bio);
        process_fd_request();
 
        init_completion(&cbdata.complete);
index 4809c1501d7eda82081d922fa1944d8cd7c76c84..79fe4934f18b2b232ef12bf2042fd5f5dada058a 100644 (file)
@@ -1369,6 +1369,7 @@ static int dispatch_rw_block_io(struct xen_blkif_ring *ring,
                        bio->bi_private = pending_req;
                        bio->bi_end_io  = end_block_io_op;
                        bio->bi_iter.bi_sector  = preq.sector_number;
+                       bio->bi_rw      = operation;
                }
 
                preq.sector_number += seg[i].nsec;
@@ -1386,13 +1387,14 @@ static int dispatch_rw_block_io(struct xen_blkif_ring *ring,
                bio->bi_bdev    = preq.bdev;
                bio->bi_private = pending_req;
                bio->bi_end_io  = end_block_io_op;
+               bio->bi_rw      = operation;
        }
 
        atomic_set(&pending_req->pendcnt, nbio);
        blk_start_plug(&plug);
 
        for (i = 0; i < nbio; i++)
-               submit_bio(operation, biolist[i]);
+               submit_bio(biolist[i]);
 
        /* Let the I/Os go.. */
        blk_finish_plug(&plug);
index ca13df8546396cf6a7dd72c3a288f27623681baf..52963a26660aea99d8c48142dc01facacbd16aba 100644 (file)
@@ -2114,7 +2114,7 @@ static int blkif_recover(struct blkfront_info *info)
                                bio_trim(cloned_bio, offset, size);
                                cloned_bio->bi_private = split_bio;
                                cloned_bio->bi_end_io = split_bio_end;
-                               submit_bio(cloned_bio->bi_rw, cloned_bio);
+                               submit_bio(cloned_bio);
                        }
                        /*
                         * Now we have to wait for all those smaller bios to
@@ -2123,7 +2123,7 @@ static int blkif_recover(struct blkfront_info *info)
                        continue;
                }
                /* We don't need to split this bio */
-               submit_bio(bio->bi_rw, bio);
+               submit_bio(bio);
        }
 
        return 0;
index 8b1f1d5c18198f078dea917f40303c98fce1ee94..52b6bcf6b6c8483a9de42d076d13bf95d7a882ee 100644 (file)
@@ -52,9 +52,10 @@ void bch_btree_verify(struct btree *b)
        bio->bi_bdev            = PTR_CACHE(b->c, &b->key, 0)->bdev;
        bio->bi_iter.bi_sector  = PTR_OFFSET(&b->key, 0);
        bio->bi_iter.bi_size    = KEY_SIZE(&v->key) << 9;
+       bio->bi_rw              = REQ_META|READ_SYNC;
        bch_bio_map(bio, sorted);
 
-       submit_bio_wait(REQ_META|READ_SYNC, bio);
+       submit_bio_wait(bio);
        bch_bbio_free(bio, b->c);
 
        memcpy(ondisk, sorted, KEY_SIZE(&v->key) << 9);
@@ -113,11 +114,12 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio)
        check = bio_clone(bio, GFP_NOIO);
        if (!check)
                return;
+       check->bi_rw |= READ_SYNC;
 
        if (bio_alloc_pages(check, GFP_NOIO))
                goto out_put;
 
-       submit_bio_wait(READ_SYNC, check);
+       submit_bio_wait(check);
 
        bio_for_each_segment(bv, bio, iter) {
                void *p1 = kmap_atomic(bv.bv_page);
index 29eba7219b01a17fd013109eff759b06d6fac34e..af3f9f7f20e2dd109e08b96c389ee45692a042f2 100644 (file)
@@ -418,7 +418,7 @@ static void journal_discard_work(struct work_struct *work)
        struct journal_device *ja =
                container_of(work, struct journal_device, discard_work);
 
-       submit_bio(0, &ja->discard_bio);
+       submit_bio(&ja->discard_bio);
 }
 
 static void do_journal_discard(struct cache *ca)
index f5dbb4e884d893240472ff7dff17cc3489936c66..1eb526a7b8b3ad050340c9d7bf0cf8d9b2adbc20 100644 (file)
@@ -212,7 +212,7 @@ static void __write_super(struct cache_sb *sb, struct bio *bio)
        unsigned i;
 
        bio->bi_iter.bi_sector  = SB_SECTOR;
-       bio->bi_rw              = REQ_SYNC|REQ_META;
+       bio->bi_rw              = REQ_WRITE|REQ_SYNC|REQ_META;
        bio->bi_iter.bi_size    = SB_SIZE;
        bch_bio_map(bio, NULL);
 
@@ -238,7 +238,7 @@ static void __write_super(struct cache_sb *sb, struct bio *bio)
        pr_debug("ver %llu, flags %llu, seq %llu",
                 sb->version, sb->flags, sb->seq);
 
-       submit_bio(REQ_WRITE, bio);
+       submit_bio(bio);
 }
 
 static void bch_write_bdev_super_unlock(struct closure *cl)
index cd77216beff166651c67b0881b747dcdd720c9e7..9d3ee7f6c6c7f87a1233a1ba2c24c2405981a11e 100644 (file)
@@ -634,6 +634,7 @@ static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
         * the dm_buffer's inline bio is local to bufio.
         */
        b->bio.bi_private = end_io;
+       b->bio.bi_rw = rw;
 
        /*
         * We assume that if len >= PAGE_SIZE ptr is page-aligned.
@@ -660,7 +661,7 @@ static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
                ptr += PAGE_SIZE;
        } while (len > 0);
 
-       submit_bio(rw, &b->bio);
+       submit_bio(&b->bio);
 }
 
 static void submit_io(struct dm_buffer *b, int rw, sector_t block,
index 06d426eb5a306b79c1ef9bbac00c9a36578226fb..50f17e32951aba78e616b29b408fb952a1153ce7 100644 (file)
@@ -322,6 +322,7 @@ static void do_region(int rw, unsigned region, struct dm_io_region *where,
                bio->bi_iter.bi_sector = where->sector + (where->count - remaining);
                bio->bi_bdev = where->bdev;
                bio->bi_end_io = endio;
+               bio->bi_rw = rw;
                store_io_and_region_in_bio(bio, io, region);
 
                if (rw & REQ_DISCARD) {
@@ -355,7 +356,7 @@ static void do_region(int rw, unsigned region, struct dm_io_region *where,
                }
 
                atomic_inc(&io->count);
-               submit_bio(rw, bio);
+               submit_bio(bio);
        } while (remaining);
 }
 
index 608302e222af0c3016c5d6d59ceb330294d1644b..addcc4be00b6e29d9c2972a6846b9aae60e2cf29 100644 (file)
@@ -205,6 +205,7 @@ static int write_metadata(struct log_writes_c *lc, void *entry,
        bio->bi_bdev = lc->logdev->bdev;
        bio->bi_end_io = log_end_io;
        bio->bi_private = lc;
+       bio->bi_rw = WRITE;
 
        page = alloc_page(GFP_KERNEL);
        if (!page) {
@@ -226,7 +227,7 @@ static int write_metadata(struct log_writes_c *lc, void *entry,
                DMERR("Couldn't add page to the log block");
                goto error_bio;
        }
-       submit_bio(WRITE, bio);
+       submit_bio(bio);
        return 0;
 error_bio:
        bio_put(bio);
@@ -269,6 +270,7 @@ static int log_one_block(struct log_writes_c *lc,
        bio->bi_bdev = lc->logdev->bdev;
        bio->bi_end_io = log_end_io;
        bio->bi_private = lc;
+       bio->bi_rw = WRITE;
 
        for (i = 0; i < block->vec_cnt; i++) {
                /*
@@ -279,7 +281,7 @@ static int log_one_block(struct log_writes_c *lc,
                                   block->vecs[i].bv_len, 0);
                if (ret != block->vecs[i].bv_len) {
                        atomic_inc(&lc->io_blocks);
-                       submit_bio(WRITE, bio);
+                       submit_bio(bio);
                        bio = bio_alloc(GFP_KERNEL, block->vec_cnt - i);
                        if (!bio) {
                                DMERR("Couldn't alloc log bio");
@@ -290,6 +292,7 @@ static int log_one_block(struct log_writes_c *lc,
                        bio->bi_bdev = lc->logdev->bdev;
                        bio->bi_end_io = log_end_io;
                        bio->bi_private = lc;
+                       bio->bi_rw = WRITE;
 
                        ret = bio_add_page(bio, block->vecs[i].bv_page,
                                           block->vecs[i].bv_len, 0);
@@ -301,7 +304,7 @@ static int log_one_block(struct log_writes_c *lc,
                }
                sector += block->vecs[i].bv_len >> SECTOR_SHIFT;
        }
-       submit_bio(WRITE, bio);
+       submit_bio(bio);
 out:
        kfree(block->data);
        kfree(block);
index fc803d50f9f026e45932f8b131764ad479831237..8c070eed982c51496f2f51a0dfc7db6f19719b70 100644 (file)
@@ -371,7 +371,8 @@ static void end_discard(struct discard_op *op, int r)
                 * need to wait for the chain to complete.
                 */
                bio_chain(op->bio, op->parent_bio);
-               submit_bio(REQ_WRITE | REQ_DISCARD, op->bio);
+               op->bio->bi_rw = REQ_WRITE | REQ_DISCARD;
+               submit_bio(op->bio);
        }
 
        blk_finish_plug(&op->plug);
index 866825f10b4c933f75eb4cbaff46c624f6267826..fb3950be30706de505b2eeb50833ad390ca8bf24 100644 (file)
@@ -394,8 +394,9 @@ 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_rw = WRITE_FLUSH;
                        atomic_inc(&mddev->flush_pending);
-                       submit_bio(WRITE_FLUSH, bi);
+                       submit_bio(bi);
                        rcu_read_lock();
                        rdev_dec_pending(rdev, mddev);
                }
@@ -742,9 +743,10 @@ 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_rw = WRITE_FLUSH_FUA;
 
        atomic_inc(&mddev->pending_writes);
-       submit_bio(WRITE_FLUSH_FUA, bio);
+       submit_bio(bio);
 }
 
 void md_super_wait(struct mddev *mddev)
@@ -761,6 +763,7 @@ int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
 
        bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
                rdev->meta_bdev : rdev->bdev;
+       bio->bi_rw = rw;
        if (metadata_op)
                bio->bi_iter.bi_sector = sector + rdev->sb_start;
        else if (rdev->mddev->reshape_position != MaxSector &&
@@ -770,7 +773,8 @@ int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
        else
                bio->bi_iter.bi_sector = sector + rdev->data_offset;
        bio_add_page(bio, page, size, 0);
-       submit_bio_wait(rw, bio);
+
+       submit_bio_wait(bio);
 
        ret = !bio->bi_error;
        bio_put(bio);
index c7c8cde0ab21128527cd74a1d7df4a0e388dc718..bc95d4dd600b1fc9c9a4bddf7280a5ae24c9d906 100644 (file)
@@ -2208,7 +2208,8 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
                bio_trim(wbio, sector - r1_bio->sector, sectors);
                wbio->bi_iter.bi_sector += rdev->data_offset;
                wbio->bi_bdev = rdev->bdev;
-               if (submit_bio_wait(WRITE, wbio) < 0)
+
+               if (submit_bio_wait(wbio) < 0)
                        /* failure! */
                        ok = rdev_set_badblocks(rdev, sector,
                                                sectors, 0)
index c7de2a53e6259499dc18f64d7783d3cacad5c029..0be6497d8e34eb7aacd6f429e72f5dd60709be05 100644 (file)
@@ -2474,7 +2474,9 @@ 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;
-               if (submit_bio_wait(WRITE, wbio) < 0)
+               wbio->bi_rw = WRITE;
+
+               if (submit_bio_wait(wbio) < 0)
                        /* Failure! */
                        ok = rdev_set_badblocks(rdev, sector,
                                                sectors, 0)
index e889e2deb7b3525ff226a7d7053df1fe8c54f115..0b014535f5dd4dfa1fcac8dae0273db05c8db8c2 100644 (file)
@@ -254,7 +254,7 @@ static void r5l_submit_current_io(struct r5l_log *log)
        __r5l_set_io_unit_state(io, IO_UNIT_IO_START);
        spin_unlock_irqrestore(&log->io_list_lock, flags);
 
-       submit_bio(WRITE, io->current_bio);
+       submit_bio(io->current_bio);
 }
 
 static struct bio *r5l_bio_alloc(struct r5l_log *log)
@@ -373,7 +373,7 @@ static void r5l_append_payload_page(struct r5l_log *log, struct page *page)
                io->current_bio = r5l_bio_alloc(log);
                bio_chain(io->current_bio, prev);
 
-               submit_bio(WRITE, prev);
+               submit_bio(prev);
        }
 
        if (!bio_add_page(io->current_bio, page, PAGE_SIZE, 0))
@@ -686,7 +686,8 @@ 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;
-       submit_bio(WRITE_FLUSH, &log->flush_bio);
+       log->flush_bio.bi_rw = WRITE_FLUSH;
+       submit_bio(&log->flush_bio);
 }
 
 static void r5l_write_super(struct r5l_log *log, sector_t cp);
index 7c4efb4417b0fc5e9c2cd9700eb83dd024e3db92..c25109cc0329929ef577fcba6cf9b99597b17083 100644 (file)
@@ -312,7 +312,7 @@ static void iblock_bio_done(struct bio *bio)
 }
 
 static struct bio *
-iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
+iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num, int rw)
 {
        struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
        struct bio *bio;
@@ -334,18 +334,19 @@ iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
        bio->bi_private = cmd;
        bio->bi_end_io = &iblock_bio_done;
        bio->bi_iter.bi_sector = lba;
+       bio->bi_rw = rw;
 
        return bio;
 }
 
-static void iblock_submit_bios(struct bio_list *list, int rw)
+static void iblock_submit_bios(struct bio_list *list)
 {
        struct blk_plug plug;
        struct bio *bio;
 
        blk_start_plug(&plug);
        while ((bio = bio_list_pop(list)))
-               submit_bio(rw, bio);
+               submit_bio(bio);
        blk_finish_plug(&plug);
 }
 
@@ -387,9 +388,10 @@ iblock_execute_sync_cache(struct se_cmd *cmd)
        bio = bio_alloc(GFP_KERNEL, 0);
        bio->bi_end_io = iblock_end_io_flush;
        bio->bi_bdev = ib_dev->ibd_bd;
+       bio->bi_rw = WRITE_FLUSH;
        if (!immed)
                bio->bi_private = cmd;
-       submit_bio(WRITE_FLUSH, bio);
+       submit_bio(bio);
        return 0;
 }
 
@@ -478,7 +480,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
                goto fail;
        cmd->priv = ibr;
 
-       bio = iblock_get_bio(cmd, block_lba, 1);
+       bio = iblock_get_bio(cmd, block_lba, 1, WRITE);
        if (!bio)
                goto fail_free_ibr;
 
@@ -491,7 +493,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
                while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
                                != sg->length) {
 
-                       bio = iblock_get_bio(cmd, block_lba, 1);
+                       bio = iblock_get_bio(cmd, block_lba, 1, WRITE);
                        if (!bio)
                                goto fail_put_bios;
 
@@ -504,7 +506,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
                sectors -= 1;
        }
 
-       iblock_submit_bios(&list, WRITE);
+       iblock_submit_bios(&list);
        return 0;
 
 fail_put_bios:
@@ -712,7 +714,7 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                return 0;
        }
 
-       bio = iblock_get_bio(cmd, block_lba, sgl_nents);
+       bio = iblock_get_bio(cmd, block_lba, sgl_nents, rw);
        if (!bio)
                goto fail_free_ibr;
 
@@ -732,11 +734,11 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
                                != sg->length) {
                        if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {
-                               iblock_submit_bios(&list, rw);
+                               iblock_submit_bios(&list);
                                bio_cnt = 0;
                        }
 
-                       bio = iblock_get_bio(cmd, block_lba, sg_num);
+                       bio = iblock_get_bio(cmd, block_lba, sg_num, rw);
                        if (!bio)
                                goto fail_put_bios;
 
@@ -756,7 +758,7 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                        goto fail_put_bios;
        }
 
-       iblock_submit_bios(&list, rw);
+       iblock_submit_bios(&list);
        iblock_complete_cmd(cmd);
        return 0;
 
index b677a6ea6001a872fc27dd6f90db72459b69f712..50f81916663b33212439973336ffacc5004ecd65 100644 (file)
@@ -1673,6 +1673,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                }
                bio->bi_bdev = block_ctx->dev->bdev;
                bio->bi_iter.bi_sector = dev_bytenr >> 9;
+               bio->bi_rw = READ;
 
                for (j = i; j < num_pages; j++) {
                        ret = bio_add_page(bio, block_ctx->pagev[j],
@@ -1685,7 +1686,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                               "btrfsic: error, failed to add a single page!\n");
                        return -1;
                }
-               if (submit_bio_wait(READ, bio)) {
+               if (submit_bio_wait(bio)) {
                        printk(KERN_INFO
                               "btrfsic: read error at logical %llu dev %s!\n",
                               block_ctx->start, block_ctx->dev->name);
@@ -2918,9 +2919,10 @@ int btrfsic_submit_bh(int rw, struct buffer_head *bh)
        return submit_bh(rw, bh);
 }
 
-static void __btrfsic_submit_bio(int rw, struct bio *bio)
+static void __btrfsic_submit_bio(struct bio *bio)
 {
        struct btrfsic_dev_state *dev_state;
+       int rw = bio->bi_rw;
 
        if (!btrfsic_is_initialized)
                return;
@@ -3016,16 +3018,16 @@ leave:
        mutex_unlock(&btrfsic_mutex);
 }
 
-void btrfsic_submit_bio(int rw, struct bio *bio)
+void btrfsic_submit_bio(struct bio *bio)
 {
-       __btrfsic_submit_bio(rw, bio);
-       submit_bio(rw, bio);
+       __btrfsic_submit_bio(bio);
+       submit_bio(bio);
 }
 
-int btrfsic_submit_bio_wait(int rw, struct bio *bio)
+int btrfsic_submit_bio_wait(struct bio *bio)
 {
-       __btrfsic_submit_bio(rw, bio);
-       return submit_bio_wait(rw, bio);
+       __btrfsic_submit_bio(bio);
+       return submit_bio_wait(bio);
 }
 
 int btrfsic_mount(struct btrfs_root *root,
index 13b8566c97ab433f7455eeb6762942d5e623d16a..c04e249058c3a299c9da092209b8ce4cbf612c0d 100644 (file)
@@ -21,8 +21,8 @@
 
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
 int btrfsic_submit_bh(int rw, struct buffer_head *bh);
-void btrfsic_submit_bio(int rw, struct bio *bio);
-int btrfsic_submit_bio_wait(int rw, struct bio *bio);
+void btrfsic_submit_bio(struct bio *bio);
+int btrfsic_submit_bio_wait(struct bio *bio);
 #else
 #define btrfsic_submit_bh submit_bh
 #define btrfsic_submit_bio submit_bio
index 6628fca9f4ed87c047e54007f1f94f99ebbaba65..3666558a237554c020e14967cbbaf5ac1049c3da 100644 (file)
@@ -3486,12 +3486,13 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
 
        bio->bi_end_io = btrfs_end_empty_barrier;
        bio->bi_bdev = device->bdev;
+       bio->bi_rw = WRITE_FLUSH;
        init_completion(&device->flush_wait);
        bio->bi_private = &device->flush_wait;
        device->flush_bio = bio;
 
        bio_get(bio);
-       btrfsic_submit_bio(WRITE_FLUSH, bio);
+       btrfsic_submit_bio(bio);
 
        return 0;
 }
index 6e953de83f08e35d363eaf08466e3ef89449ff64..40e8dcc319d4daf5eb680925bc43482909f5c826 100644 (file)
@@ -2049,9 +2049,10 @@ int repair_io_failure(struct inode *inode, u64 start, u64 length, u64 logical,
                return -EIO;
        }
        bio->bi_bdev = dev->bdev;
+       bio->bi_rw = WRITE_SYNC;
        bio_add_page(bio, page, length, pg_offset);
 
-       if (btrfsic_submit_bio_wait(WRITE_SYNC, bio)) {
+       if (btrfsic_submit_bio_wait(bio)) {
                /* try to remap that extent elsewhere? */
                btrfs_bio_counter_dec(fs_info);
                bio_put(bio);
@@ -2735,14 +2736,14 @@ static int __must_check submit_one_bio(int rw, struct bio *bio,
        start = page_offset(page) + bvec->bv_offset;
 
        bio->bi_private = NULL;
-
+       bio->bi_rw = rw;
        bio_get(bio);
 
        if (tree->ops && tree->ops->submit_bio_hook)
                ret = tree->ops->submit_bio_hook(page->mapping->host, rw, bio,
                                           mirror_num, bio_flags, start);
        else
-               btrfsic_submit_bio(rw, bio);
+               btrfsic_submit_bio(bio);
 
        bio_put(bio);
        return ret;
index f8b6d411a034b46a565f7df4066e0f6ecee8f189..36d5bf7bbb5926f6ebd9b17a8942b631291f4a40 100644 (file)
@@ -1320,7 +1320,9 @@ write_data:
 
                bio->bi_private = rbio;
                bio->bi_end_io = raid_write_end_io;
-               submit_bio(WRITE, bio);
+               bio->bi_rw = WRITE;
+
+               submit_bio(bio);
        }
        return;
 
@@ -1573,11 +1575,12 @@ static int raid56_rmw_stripe(struct btrfs_raid_bio *rbio)
 
                bio->bi_private = rbio;
                bio->bi_end_io = raid_rmw_end_io;
+               bio->bi_rw = READ;
 
                btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                    BTRFS_WQ_ENDIO_RAID56);
 
-               submit_bio(READ, bio);
+               submit_bio(bio);
        }
        /* the actual write will happen once the reads are done */
        return 0;
@@ -2097,11 +2100,12 @@ static int __raid56_parity_recover(struct btrfs_raid_bio *rbio)
 
                bio->bi_private = rbio;
                bio->bi_end_io = raid_recover_end_io;
+               bio->bi_rw = READ;
 
                btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                    BTRFS_WQ_ENDIO_RAID56);
 
-               submit_bio(READ, bio);
+               submit_bio(bio);
        }
 out:
        return 0;
@@ -2433,7 +2437,9 @@ submit_write:
 
                bio->bi_private = rbio;
                bio->bi_end_io = raid_write_end_io;
-               submit_bio(WRITE, bio);
+               bio->bi_rw = WRITE;
+
+               submit_bio(bio);
        }
        return;
 
@@ -2610,11 +2616,12 @@ static void raid56_parity_scrub_stripe(struct btrfs_raid_bio *rbio)
 
                bio->bi_private = rbio;
                bio->bi_end_io = raid56_parity_scrub_end_io;
+               bio->bi_rw = READ;
 
                btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                    BTRFS_WQ_ENDIO_RAID56);
 
-               submit_bio(READ, bio);
+               submit_bio(bio);
        }
        /* the actual write will happen once the reads are done */
        return;
index 70427ef66b044db3baadd071e9b58b3fa9ce4bfd..9899f3e44a56d2dadef4a0ca88ed56408a219104 100644 (file)
@@ -1504,8 +1504,9 @@ static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
                                sblock->no_io_error_seen = 0;
                } else {
                        bio->bi_iter.bi_sector = page->physical >> 9;
+                       bio->bi_rw = READ;
 
-                       if (btrfsic_submit_bio_wait(READ, bio))
+                       if (btrfsic_submit_bio_wait(bio))
                                sblock->no_io_error_seen = 0;
                }
 
@@ -1583,6 +1584,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                        return -EIO;
                bio->bi_bdev = page_bad->dev->bdev;
                bio->bi_iter.bi_sector = page_bad->physical >> 9;
+               bio->bi_rw = WRITE;
 
                ret = bio_add_page(bio, page_good->page, PAGE_SIZE, 0);
                if (PAGE_SIZE != ret) {
@@ -1590,7 +1592,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                        return -EIO;
                }
 
-               if (btrfsic_submit_bio_wait(WRITE, bio)) {
+               if (btrfsic_submit_bio_wait(bio)) {
                        btrfs_dev_stat_inc_and_print(page_bad->dev,
                                BTRFS_DEV_STAT_WRITE_ERRS);
                        btrfs_dev_replace_stats_inc(
@@ -1684,6 +1686,7 @@ again:
                bio->bi_end_io = scrub_wr_bio_end_io;
                bio->bi_bdev = sbio->dev->bdev;
                bio->bi_iter.bi_sector = sbio->physical >> 9;
+               bio->bi_rw = WRITE;
                sbio->err = 0;
        } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                   spage->physical_for_dev_replace ||
@@ -1731,7 +1734,7 @@ static void scrub_wr_submit(struct scrub_ctx *sctx)
         * orders the requests before sending them to the driver which
         * doubled the write performance on spinning disks when measured
         * with Linux 3.5 */
-       btrfsic_submit_bio(WRITE, sbio->bio);
+       btrfsic_submit_bio(sbio->bio);
 }
 
 static void scrub_wr_bio_end_io(struct bio *bio)
@@ -2041,7 +2044,7 @@ static void scrub_submit(struct scrub_ctx *sctx)
        sbio = sctx->bios[sctx->curr];
        sctx->curr = -1;
        scrub_pending_bio_inc(sctx);
-       btrfsic_submit_bio(READ, sbio->bio);
+       btrfsic_submit_bio(sbio->bio);
 }
 
 static int scrub_add_page_to_rd_bio(struct scrub_ctx *sctx,
@@ -2088,6 +2091,7 @@ again:
                bio->bi_end_io = scrub_bio_end_io;
                bio->bi_bdev = sbio->dev->bdev;
                bio->bi_iter.bi_sector = sbio->physical >> 9;
+               bio->bi_rw = READ;
                sbio->err = 0;
        } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                   spage->physical ||
@@ -4436,6 +4440,7 @@ static int write_page_nocow(struct scrub_ctx *sctx,
        bio->bi_iter.bi_size = 0;
        bio->bi_iter.bi_sector = physical_for_dev_replace >> 9;
        bio->bi_bdev = dev->bdev;
+       bio->bi_rw = WRITE_SYNC;
        ret = bio_add_page(bio, page, PAGE_SIZE, 0);
        if (ret != PAGE_SIZE) {
 leave_with_eio:
@@ -4444,7 +4449,7 @@ leave_with_eio:
                return -EIO;
        }
 
-       if (btrfsic_submit_bio_wait(WRITE_SYNC, bio))
+       if (btrfsic_submit_bio_wait(bio))
                goto leave_with_eio;
 
        bio_put(bio);
index da9e0036a864d3d8cf45b164b0fb083675223584..037f3ab841d8e2852e392f6319a82550313deb9a 100644 (file)
@@ -462,7 +462,7 @@ loop_lock:
                        sync_pending = 0;
                }
 
-               btrfsic_submit_bio(cur->bi_rw, cur);
+               btrfsic_submit_bio(cur);
                num_run++;
                batch_run++;
 
@@ -5996,7 +5996,7 @@ static void btrfs_end_bio(struct bio *bio)
  */
 static noinline void btrfs_schedule_bio(struct btrfs_root *root,
                                        struct btrfs_device *device,
-                                       int rw, struct bio *bio)
+                                       struct bio *bio)
 {
        int should_queue = 1;
        struct btrfs_pending_bios *pending_bios;
@@ -6007,9 +6007,9 @@ static noinline void btrfs_schedule_bio(struct btrfs_root *root,
        }
 
        /* don't bother with additional async steps for reads, right now */
-       if (!(rw & REQ_WRITE)) {
+       if (!(bio->bi_rw & REQ_WRITE)) {
                bio_get(bio);
-               btrfsic_submit_bio(rw, bio);
+               btrfsic_submit_bio(bio);
                bio_put(bio);
                return;
        }
@@ -6023,7 +6023,6 @@ static noinline void btrfs_schedule_bio(struct btrfs_root *root,
        atomic_inc(&root->fs_info->nr_async_bios);
        WARN_ON(bio->bi_next);
        bio->bi_next = NULL;
-       bio->bi_rw |= rw;
 
        spin_lock(&device->io_lock);
        if (bio->bi_rw & REQ_SYNC)
@@ -6057,6 +6056,7 @@ static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
        btrfs_io_bio(bio)->stripe_index = dev_nr;
        bio->bi_end_io = btrfs_end_bio;
        bio->bi_iter.bi_sector = physical >> 9;
+       bio->bi_rw |= rw;
 #ifdef DEBUG
        {
                struct rcu_string *name;
@@ -6075,9 +6075,9 @@ static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
        btrfs_bio_counter_inc_noblocked(root->fs_info);
 
        if (async)
-               btrfs_schedule_bio(root, dev, rw, bio);
+               btrfs_schedule_bio(root, dev, bio);
        else
-               btrfsic_submit_bio(rw, bio);
+               btrfsic_submit_bio(bio);
 }
 
 static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
index 754813a6962bc324c476b5d5035f10e761c1e28c..9a55e7f8b25c52171bc1a471b69c2f0faa28658a 100644 (file)
@@ -3030,8 +3030,9 @@ static int submit_bh_wbc(int rw, struct buffer_head *bh,
                rw |= REQ_META;
        if (buffer_prio(bh))
                rw |= REQ_PRIO;
+       bio->bi_rw = rw;
 
-       submit_bio(rw, bio);
+       submit_bio(bio);
        return 0;
 }
 
index 2fc8c43ce531de02379c93e85c03f95c0d3ca793..5b758566199e4594c6073a1bdcbdecdc601c2970 100644 (file)
@@ -318,6 +318,7 @@ int fscrypt_zeroout_range(struct inode *inode, pgoff_t lblk,
                bio->bi_bdev = inode->i_sb->s_bdev;
                bio->bi_iter.bi_sector =
                        pblk << (inode->i_sb->s_blocksize_bits - 9);
+               bio->bi_rw = WRITE;
                ret = bio_add_page(bio, ciphertext_page,
                                        inode->i_sb->s_blocksize, 0);
                if (ret != inode->i_sb->s_blocksize) {
@@ -327,7 +328,7 @@ int fscrypt_zeroout_range(struct inode *inode, pgoff_t lblk,
                        err = -EIO;
                        goto errout;
                }
-               err = submit_bio_wait(WRITE, bio);
+               err = submit_bio_wait(bio);
                if ((err == 0) && bio->bi_error)
                        err = -EIO;
                bio_put(bio);
index f3b4408be5904a996920397960b2df322fde07f3..1bcdd5dde00d1a2b432e1a907a656a71b0760f8d 100644 (file)
@@ -375,6 +375,7 @@ dio_bio_alloc(struct dio *dio, struct dio_submit *sdio,
 
        bio->bi_bdev = bdev;
        bio->bi_iter.bi_sector = first_sector;
+       bio->bi_rw = dio->rw;
        if (dio->is_async)
                bio->bi_end_io = dio_bio_end_aio;
        else
@@ -412,7 +413,7 @@ static inline void dio_bio_submit(struct dio *dio, struct dio_submit *sdio)
                               sdio->logical_offset_in_bio);
                dio->bio_cookie = BLK_QC_T_NONE;
        } else
-               dio->bio_cookie = submit_bio(dio->rw, bio);
+               dio->bio_cookie = submit_bio(bio);
 
        sdio->bio = NULL;
        sdio->boundary = 0;
index 6a6c27373b5467d11dcfc056b3c17dec5cccde3b..811bd5de809904b275c8cc26b53dd91438033d05 100644 (file)
@@ -428,6 +428,7 @@ int ext4_encrypted_zeroout(struct inode *inode, ext4_lblk_t lblk,
                bio->bi_bdev = inode->i_sb->s_bdev;
                bio->bi_iter.bi_sector =
                        pblk << (inode->i_sb->s_blocksize_bits - 9);
+               bio->bi_rw = WRITE;
                ret = bio_add_page(bio, ciphertext_page,
                                   inode->i_sb->s_blocksize, 0);
                if (ret != inode->i_sb->s_blocksize) {
@@ -439,7 +440,7 @@ int ext4_encrypted_zeroout(struct inode *inode, ext4_lblk_t lblk,
                        err = -EIO;
                        goto errout;
                }
-               err = submit_bio_wait(WRITE, bio);
+               err = submit_bio_wait(bio);
                if ((err == 0) && bio->bi_error)
                        err = -EIO;
                bio_put(bio);
index 2a01df9cc1c3214ee0e106eee262e7a3d1cee284..a72dbcc7a43e6494b408890fd27dc743d9d17b36 100644 (file)
@@ -342,7 +342,8 @@ void ext4_io_submit(struct ext4_io_submit *io)
        if (bio) {
                int io_op = io->io_wbc->sync_mode == WB_SYNC_ALL ?
                            WRITE_SYNC : WRITE;
-               submit_bio(io_op, io->io_bio);
+               io->io_bio->bi_rw = io_op;
+               submit_bio(io->io_bio);
        }
        io->io_bio = NULL;
 }
index dc54a4b60eba0faf0b4f8afb290925b5b57e355a..130bd45f4a990da7e02f59ac441b68f62bbbde53 100644 (file)
@@ -271,7 +271,7 @@ int ext4_mpage_readpages(struct address_space *mapping,
                 */
                if (bio && (last_block_in_bio != blocks[0] - 1)) {
                submit_and_realloc:
-                       submit_bio(READ, bio);
+                       submit_bio(bio);
                        bio = NULL;
                }
                if (bio == NULL) {
@@ -294,6 +294,7 @@ int ext4_mpage_readpages(struct address_space *mapping,
                        bio->bi_iter.bi_sector = blocks[0] << (blkbits - 9);
                        bio->bi_end_io = mpage_end_io;
                        bio->bi_private = ctx;
+                       bio->bi_rw = READ;
                }
 
                length = first_hole << blkbits;
@@ -303,14 +304,14 @@ int ext4_mpage_readpages(struct address_space *mapping,
                if (((map.m_flags & EXT4_MAP_BOUNDARY) &&
                     (relative_block == map.m_len)) ||
                    (first_hole != blocks_per_page)) {
-                       submit_bio(READ, bio);
+                       submit_bio(bio);
                        bio = NULL;
                } else
                        last_block_in_bio = blocks[blocks_per_page - 1];
                goto next_page;
        confused:
                if (bio) {
-                       submit_bio(READ, bio);
+                       submit_bio(bio);
                        bio = NULL;
                }
                if (!PageUptodate(page))
@@ -323,6 +324,6 @@ int ext4_mpage_readpages(struct address_space *mapping,
        }
        BUG_ON(pages && !list_empty(pages));
        if (bio)
-               submit_bio(READ, bio);
+               submit_bio(bio);
        return 0;
 }
index 9a8bbc1fb1faa6865665285b37217f7993692431..c595c8f84c48d12a169f4a62fc01465413e13c93 100644 (file)
@@ -102,7 +102,8 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw,
 {
        if (!is_read_io(rw))
                atomic_inc(&sbi->nr_wb_bios);
-       submit_bio(rw, bio);
+       bio->bi_rw = rw;
+       submit_bio(bio);
 }
 
 static void __submit_merged_bio(struct f2fs_bio_info *io)
@@ -1080,6 +1081,7 @@ submit_and_realloc:
                        bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(block_nr);
                        bio->bi_end_io = f2fs_read_end_io;
                        bio->bi_private = ctx;
+                       bio->bi_rw = READ;
                }
 
                if (bio_add_page(bio, page, blocksize, 0) < blocksize)
index 2e6f537a0e7df7df4b449df05f222ff4bc5a90b4..3fe2faba842a260a9bbc626eef9d76795badccfb 100644 (file)
@@ -406,7 +406,8 @@ repeat:
                fcc->dispatch_list = llist_reverse_order(fcc->dispatch_list);
 
                bio->bi_bdev = sbi->sb->s_bdev;
-               ret = submit_bio_wait(WRITE_FLUSH, bio);
+               bio->bi_rw = WRITE_FLUSH;
+               ret = submit_bio_wait(bio);
 
                llist_for_each_entry_safe(cmd, next,
                                          fcc->dispatch_list, llnode) {
@@ -438,7 +439,8 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi)
                int ret;
 
                bio->bi_bdev = sbi->sb->s_bdev;
-               ret = submit_bio_wait(WRITE_FLUSH, bio);
+               bio->bi_rw = WRITE_FLUSH;
+               ret = submit_bio_wait(bio);
                bio_put(bio);
                return ret;
        }
index d5369a109781d990317cf634f3f8537c38a5dd7c..ce282423a85388ebf84a2518b73dd35c9b8899ef 100644 (file)
@@ -240,7 +240,8 @@ void gfs2_log_flush_bio(struct gfs2_sbd *sdp, int rw)
 {
        if (sdp->sd_log_bio) {
                atomic_inc(&sdp->sd_log_in_flight);
-               submit_bio(rw, sdp->sd_log_bio);
+               sdp->sd_log_bio->bi_rw = rw;
+               submit_bio(sdp->sd_log_bio);
                sdp->sd_log_bio = NULL;
        }
 }
index 8eaadabbc77100bea1906de90b70e201cb4c57cd..66670e14f6545c8a3d78e466b93c29e890d48880 100644 (file)
@@ -230,7 +230,8 @@ static void gfs2_submit_bhs(int rw, struct buffer_head *bhs[], int num)
                bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh));
        }
        bio->bi_end_io = gfs2_meta_read_endio;
-       submit_bio(rw, bio);
+       bio->bi_rw = rw;
+       submit_bio(bio);
 }
 
 /**
index 45463600fb81d34e48d328e63bf9ef389e0dd363..d9e19f61077b947a80e35f9f268f1bad6741dc41 100644 (file)
@@ -246,7 +246,8 @@ static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
 
        bio->bi_end_io = end_bio_io_page;
        bio->bi_private = page;
-       submit_bio(READ_SYNC | REQ_META, bio);
+       bio->bi_rw = READ_SYNC | REQ_META;
+       submit_bio(bio);
        wait_on_page_locked(page);
        bio_put(bio);
        if (!PageUptodate(page)) {
index cc623567143769b95d60a45a46b2f17e889773d0..d026bb3fb36f3efc20b83ab7fdbf3748c7ffbdd6 100644 (file)
@@ -65,6 +65,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
        bio = bio_alloc(GFP_NOIO, 1);
        bio->bi_iter.bi_sector = sector;
        bio->bi_bdev = sb->s_bdev;
+       bio->bi_rw = rw;
 
        if (!(rw & WRITE) && data)
                *data = (u8 *)buf + offset;
@@ -83,7 +84,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
                buf = (u8 *)buf + len;
        }
 
-       ret = submit_bio_wait(rw, bio);
+       ret = submit_bio_wait(bio);
 out:
        bio_put(bio);
        return ret < 0 ? ret : 0;
index 63759d723920c3c76020a684c6cbe52f1c630a52..3ee3f32562f9cda8a3eee65ef4e046e5e4d586bc 100644 (file)
@@ -2002,12 +2002,13 @@ static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp)
 
        bio->bi_end_io = lbmIODone;
        bio->bi_private = bp;
+       bio->bi_rw = READ_SYNC;
        /*check if journaling to disk has been disabled*/
        if (log->no_integrity) {
                bio->bi_iter.bi_size = 0;
                lbmIODone(bio);
        } else {
-               submit_bio(READ_SYNC, bio);
+               submit_bio(bio);
        }
 
        wait_event(bp->l_ioevent, (bp->l_flag != lbmREAD));
@@ -2145,13 +2146,14 @@ static void lbmStartIO(struct lbuf * bp)
 
        bio->bi_end_io = lbmIODone;
        bio->bi_private = bp;
+       bio->bi_rw = WRITE_SYNC;
 
        /* check if journaling to disk has been disabled */
        if (log->no_integrity) {
                bio->bi_iter.bi_size = 0;
                lbmIODone(bio);
        } else {
-               submit_bio(WRITE_SYNC, bio);
+               submit_bio(bio);
                INCREMENT(lmStat.submitted);
        }
 }
index b60e015cc757505096176114980cdc5461ad9239..97254436a4eddeca2b24e948e62b024bf5bd3582 100644 (file)
@@ -411,7 +411,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
                        inc_io(page);
                        if (!bio->bi_iter.bi_size)
                                goto dump_bio;
-                       submit_bio(WRITE, bio);
+                       submit_bio(bio);
                        nr_underway++;
                        bio = NULL;
                } else
@@ -434,6 +434,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
                bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9);
                bio->bi_end_io = metapage_write_end_io;
                bio->bi_private = page;
+               bio->bi_rw = WRITE;
 
                /* Don't call bio_add_page yet, we may add to this vec */
                bio_offset = offset;
@@ -448,7 +449,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
                if (!bio->bi_iter.bi_size)
                        goto dump_bio;
 
-               submit_bio(WRITE, bio);
+               submit_bio(bio);
                nr_underway++;
        }
        if (redirty)
@@ -506,7 +507,7 @@ static int metapage_readpage(struct file *fp, struct page *page)
                                insert_metapage(page, NULL);
                        inc_io(page);
                        if (bio)
-                               submit_bio(READ, bio);
+                               submit_bio(bio);
 
                        bio = bio_alloc(GFP_NOFS, 1);
                        bio->bi_bdev = inode->i_sb->s_bdev;
@@ -514,6 +515,7 @@ static int metapage_readpage(struct file *fp, struct page *page)
                                pblock << (inode->i_blkbits - 9);
                        bio->bi_end_io = metapage_read_end_io;
                        bio->bi_private = page;
+                       bio->bi_rw = READ;
                        len = xlen << inode->i_blkbits;
                        offset = block_offset << inode->i_blkbits;
                        if (bio_add_page(bio, page, len, offset) < len)
@@ -523,7 +525,7 @@ static int metapage_readpage(struct file *fp, struct page *page)
                        block_offset++;
        }
        if (bio)
-               submit_bio(READ, bio);
+               submit_bio(bio);
        else
                unlock_page(page);
 
index cc26f8f215f5058b1face75ef5460694bc47fa48..29704bda639495b47c53afce522423a74d1d0be5 100644 (file)
@@ -29,8 +29,9 @@ static int sync_request(struct page *page, struct block_device *bdev, int rw)
        bio.bi_bdev = bdev;
        bio.bi_iter.bi_sector = page->index * (PAGE_SIZE >> 9);
        bio.bi_iter.bi_size = PAGE_SIZE;
+       bio.bi_rw = rw;
 
-       return submit_bio_wait(rw, &bio);
+       return submit_bio_wait(&bio);
 }
 
 static int bdev_readpage(void *_sb, struct page *page)
@@ -95,8 +96,9 @@ static int __bdev_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
                        bio->bi_iter.bi_sector = ofs >> 9;
                        bio->bi_private = sb;
                        bio->bi_end_io = writeseg_end_io;
+                       bio->bi_rw = WRITE;
                        atomic_inc(&super->s_pending_writes);
-                       submit_bio(WRITE, bio);
+                       submit_bio(bio);
 
                        ofs += i * PAGE_SIZE;
                        index += i;
@@ -122,8 +124,9 @@ static int __bdev_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
        bio->bi_iter.bi_sector = ofs >> 9;
        bio->bi_private = sb;
        bio->bi_end_io = writeseg_end_io;
+       bio->bi_rw = WRITE;
        atomic_inc(&super->s_pending_writes);
-       submit_bio(WRITE, bio);
+       submit_bio(bio);
        return 0;
 }
 
@@ -185,8 +188,9 @@ static int do_erase(struct super_block *sb, u64 ofs, pgoff_t index,
                        bio->bi_iter.bi_sector = ofs >> 9;
                        bio->bi_private = sb;
                        bio->bi_end_io = erase_end_io;
+                       bio->bi_rw = WRITE;
                        atomic_inc(&super->s_pending_writes);
-                       submit_bio(WRITE, bio);
+                       submit_bio(bio);
 
                        ofs += i * PAGE_SIZE;
                        index += i;
@@ -206,8 +210,9 @@ static int do_erase(struct super_block *sb, u64 ofs, pgoff_t index,
        bio->bi_iter.bi_sector = ofs >> 9;
        bio->bi_private = sb;
        bio->bi_end_io = erase_end_io;
+       bio->bi_rw = WRITE;
        atomic_inc(&super->s_pending_writes);
-       submit_bio(WRITE, bio);
+       submit_bio(bio);
        return 0;
 }
 
index eedc644b78d78338ebb960339f3d1d224b837b9b..2c251ecfeeea8fb60752dba92623e8f72aa34d71 100644 (file)
@@ -59,8 +59,9 @@ static void mpage_end_io(struct bio *bio)
 static struct bio *mpage_bio_submit(int rw, struct bio *bio)
 {
        bio->bi_end_io = mpage_end_io;
+       bio->bi_rw = rw;
        guard_bio_eod(rw, bio);
-       submit_bio(rw, bio);
+       submit_bio(bio);
        return NULL;
 }
 
index 17a42e4eb8728371f4aec957a545c47d332e7fcd..4c79f4ddb0524d31375403819066d1ebe9a7b495 100644 (file)
@@ -102,14 +102,15 @@ static inline void put_parallel(struct parallel_io *p)
 }
 
 static struct bio *
-bl_submit_bio(int rw, struct bio *bio)
+bl_submit_bio(struct bio *bio)
 {
        if (bio) {
                get_parallel(bio->bi_private);
                dprintk("%s submitting %s bio %u@%llu\n", __func__,
-                       rw == READ ? "read" : "write", bio->bi_iter.bi_size,
+                       bio->bi_rw == READ ? "read" : "write",
+                       bio->bi_iter.bi_size,
                        (unsigned long long)bio->bi_iter.bi_sector);
-               submit_bio(rw, bio);
+               submit_bio(bio);
        }
        return NULL;
 }
@@ -158,7 +159,7 @@ do_add_page_to_bio(struct bio *bio, int npg, int rw, sector_t isect,
        if (disk_addr < map->start || disk_addr >= map->start + map->len) {
                if (!dev->map(dev, disk_addr, map))
                        return ERR_PTR(-EIO);
-               bio = bl_submit_bio(rw, bio);
+               bio = bl_submit_bio(bio);
        }
        disk_addr += map->disk_offset;
        disk_addr -= map->start;
@@ -174,9 +175,10 @@ retry:
                                disk_addr >> SECTOR_SHIFT, end_io, par);
                if (!bio)
                        return ERR_PTR(-ENOMEM);
+               bio->bi_rw = rw;
        }
        if (bio_add_page(bio, page, *len, offset) < *len) {
-               bio = bl_submit_bio(rw, bio);
+               bio = bl_submit_bio(bio);
                goto retry;
        }
        return bio;
@@ -252,7 +254,7 @@ bl_read_pagelist(struct nfs_pgio_header *header)
        for (i = pg_index; i < header->page_array.npages; i++) {
                if (extent_length <= 0) {
                        /* We've used up the previous extent */
-                       bio = bl_submit_bio(READ, bio);
+                       bio = bl_submit_bio(bio);
 
                        /* Get the next one */
                        if (!ext_tree_lookup(bl, isect, &be, false)) {
@@ -273,7 +275,7 @@ bl_read_pagelist(struct nfs_pgio_header *header)
                }
 
                if (is_hole(&be)) {
-                       bio = bl_submit_bio(READ, bio);
+                       bio = bl_submit_bio(bio);
                        /* Fill hole w/ zeroes w/o accessing device */
                        dprintk("%s Zeroing page for hole\n", __func__);
                        zero_user_segment(pages[i], pg_offset, pg_len);
@@ -306,7 +308,7 @@ bl_read_pagelist(struct nfs_pgio_header *header)
                header->res.count = (isect << SECTOR_SHIFT) - header->args.offset;
        }
 out:
-       bl_submit_bio(READ, bio);
+       bl_submit_bio(bio);
        blk_finish_plug(&plug);
        put_parallel(par);
        return PNFS_ATTEMPTED;
@@ -398,7 +400,7 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
        for (i = pg_index; i < header->page_array.npages; i++) {
                if (extent_length <= 0) {
                        /* We've used up the previous extent */
-                       bio = bl_submit_bio(WRITE, bio);
+                       bio = bl_submit_bio(bio);
                        /* Get the next one */
                        if (!ext_tree_lookup(bl, isect, &be, true)) {
                                header->pnfs_error = -EINVAL;
@@ -427,7 +429,7 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
 
        header->res.count = header->args.count;
 out:
-       bl_submit_bio(WRITE, bio);
+       bl_submit_bio(bio);
        blk_finish_plug(&plug);
        put_parallel(par);
        return PNFS_ATTEMPTED;
index bf36df10540b692dc2eee698a07296edcbd0267b..0f62909557e77166ef55162cc0b3c266526c8347 100644 (file)
@@ -364,7 +364,8 @@ static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer *segbuf,
 
        bio->bi_end_io = nilfs_end_bio_write;
        bio->bi_private = segbuf;
-       submit_bio(mode, bio);
+       bio->bi_rw = mode;
+       submit_bio(bio);
        segbuf->sb_nbio++;
 
        wi->bio = NULL;
index 6aaf3e35139109cff852999e38d4c909b0d7f520..8b1d86ebd8d1f955d8517ad495f1785492a767c2 100644 (file)
@@ -530,7 +530,7 @@ static void o2hb_bio_end_io(struct bio *bio)
 static struct bio *o2hb_setup_one_bio(struct o2hb_region *reg,
                                      struct o2hb_bio_wait_ctxt *wc,
                                      unsigned int *current_slot,
-                                     unsigned int max_slots)
+                                     unsigned int max_slots, int rw)
 {
        int len, current_page;
        unsigned int vec_len, vec_start;
@@ -556,6 +556,7 @@ static struct bio *o2hb_setup_one_bio(struct o2hb_region *reg,
        bio->bi_bdev = reg->hr_bdev;
        bio->bi_private = wc;
        bio->bi_end_io = o2hb_bio_end_io;
+       bio->bi_rw = rw;
 
        vec_start = (cs << bits) % PAGE_SIZE;
        while(cs < max_slots) {
@@ -591,7 +592,8 @@ static int o2hb_read_slots(struct o2hb_region *reg,
        o2hb_bio_wait_init(&wc);
 
        while(current_slot < max_slots) {
-               bio = o2hb_setup_one_bio(reg, &wc, &current_slot, max_slots);
+               bio = o2hb_setup_one_bio(reg, &wc, &current_slot, max_slots,
+                                        READ);
                if (IS_ERR(bio)) {
                        status = PTR_ERR(bio);
                        mlog_errno(status);
@@ -599,7 +601,7 @@ static int o2hb_read_slots(struct o2hb_region *reg,
                }
 
                atomic_inc(&wc.wc_num_reqs);
-               submit_bio(READ, bio);
+               submit_bio(bio);
        }
 
        status = 0;
@@ -623,7 +625,7 @@ static int o2hb_issue_node_write(struct o2hb_region *reg,
 
        slot = o2nm_this_node();
 
-       bio = o2hb_setup_one_bio(reg, write_wc, &slot, slot+1);
+       bio = o2hb_setup_one_bio(reg, write_wc, &slot, slot+1, WRITE_SYNC);
        if (IS_ERR(bio)) {
                status = PTR_ERR(bio);
                mlog_errno(status);
@@ -631,7 +633,7 @@ static int o2hb_issue_node_write(struct o2hb_region *reg,
        }
 
        atomic_inc(&write_wc->wc_num_reqs);
-       submit_bio(WRITE_SYNC, bio);
+       submit_bio(bio);
 
        status = 0;
 bail:
index 4c463b99fe574341043cb1f6ab612a59df881d31..0cd1603856b4d54a20d546b8498db952e42181a1 100644 (file)
@@ -438,7 +438,10 @@ xfs_submit_ioend(
 
        ioend->io_bio->bi_private = ioend;
        ioend->io_bio->bi_end_io = xfs_end_bio;
-
+       if (wbc->sync_mode == WB_SYNC_ALL)
+               ioend->io_bio->bi_rw = WRITE_SYNC;
+       else
+               ioend->io_bio->bi_rw = WRITE;
        /*
         * If we are failing the IO now, just mark the ioend with an
         * error and finish it. This will run IO completion immediately
@@ -451,8 +454,7 @@ xfs_submit_ioend(
                return status;
        }
 
-       submit_bio(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE,
-                  ioend->io_bio);
+       submit_bio(ioend->io_bio);
        return 0;
 }
 
@@ -510,8 +512,11 @@ xfs_chain_bio(
 
        bio_chain(ioend->io_bio, new);
        bio_get(ioend->io_bio);         /* for xfs_destroy_ioend */
-       submit_bio(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE,
-                  ioend->io_bio);
+       if (wbc->sync_mode == WB_SYNC_ALL)
+               ioend->io_bio->bi_rw = WRITE_SYNC;
+       else
+               ioend->io_bio->bi_rw = WRITE;
+       submit_bio(ioend->io_bio);
        ioend->io_bio = new;
 }
 
index e71cfbd5acb3c74df23be024c91420a07291a493..0777c67f169bc66e05ee6ce886af57116d97fcee 100644 (file)
@@ -1166,7 +1166,7 @@ next_chunk:
        bio->bi_iter.bi_sector = sector;
        bio->bi_end_io = xfs_buf_bio_end_io;
        bio->bi_private = bp;
-
+       bio->bi_rw = rw;
 
        for (; size && nr_pages; nr_pages--, page_index++) {
                int     rbytes, nbytes = PAGE_SIZE - offset;
@@ -1190,7 +1190,7 @@ next_chunk:
                        flush_kernel_vmap_range(bp->b_addr,
                                                xfs_buf_vmap_len(bp));
                }
-               submit_bio(rw, bio);
+               submit_bio(bio);
                if (size)
                        goto next_chunk;
        } else {
index 9faebf7f9a33c04a73506e7e379432ce1cce93bf..3bde94234eea686a1e009f05021c3091e5479a29 100644 (file)
@@ -473,7 +473,7 @@ static inline void bio_io_error(struct bio *bio)
 struct request_queue;
 extern int bio_phys_segments(struct request_queue *, struct bio *);
 
-extern int submit_bio_wait(int rw, struct bio *bio);
+extern int submit_bio_wait(struct bio *bio);
 extern void bio_advance(struct bio *, unsigned);
 
 extern void bio_init(struct bio *);
index dd288148a6b15f2ea958441e628f5ed2a729faff..65e4c51ecb3d739f0757dc50acb84ed5093463e9 100644 (file)
@@ -2747,7 +2747,7 @@ static inline void remove_inode_hash(struct inode *inode)
 extern void inode_sb_list_add(struct inode *inode);
 
 #ifdef CONFIG_BLOCK
-extern blk_qc_t submit_bio(int, struct bio *);
+extern blk_qc_t submit_bio(struct bio *);
 extern int bdev_read_only(struct block_device *);
 #endif
 extern int set_blocksize(struct block_device *, int);
index 160e1006640d585f417ae37ecab304e407971e67..be227f5aa9dcf12cbd7af3af866d02285390bc92 100644 (file)
@@ -271,6 +271,7 @@ static int hib_submit_io(int rw, pgoff_t page_off, void *addr,
        bio = bio_alloc(__GFP_RECLAIM | __GFP_HIGH, 1);
        bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9);
        bio->bi_bdev = hib_resume_bdev;
+       bio->bi_rw = rw;
 
        if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
                printk(KERN_ERR "PM: Adding page to bio failed at %llu\n",
@@ -283,9 +284,9 @@ static int hib_submit_io(int rw, pgoff_t page_off, void *addr,
                bio->bi_end_io = hib_end_io;
                bio->bi_private = hb;
                atomic_inc(&hb->count);
-               submit_bio(rw, bio);
+               submit_bio(bio);
        } else {
-               error = submit_bio_wait(rw, bio);
+               error = submit_bio_wait(bio);
                bio_put(bio);
        }
 
index 242dba07545bc61104a7713f2246f8e0fccebfc4..5a5fd66d7bd50e29994dbbc96eeb56ea9a5ac8e0 100644 (file)
@@ -259,7 +259,7 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
                bio_end_io_t end_write_func)
 {
        struct bio *bio;
-       int ret, rw = WRITE;
+       int ret;
        struct swap_info_struct *sis = page_swap_info(page);
 
        if (sis->flags & SWP_FILE) {
@@ -317,12 +317,13 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
                ret = -ENOMEM;
                goto out;
        }
+       bio->bi_rw = WRITE;
        if (wbc->sync_mode == WB_SYNC_ALL)
-               rw |= REQ_SYNC;
+               bio->bi_rw |= REQ_SYNC;
        count_vm_event(PSWPOUT);
        set_page_writeback(page);
        unlock_page(page);
-       submit_bio(rw, bio);
+       submit_bio(bio);
 out:
        return ret;
 }
@@ -369,8 +370,9 @@ int swap_readpage(struct page *page)
                ret = -ENOMEM;
                goto out;
        }
+       bio->bi_rw = READ;
        count_vm_event(PSWPIN);
-       submit_bio(READ, bio);
+       submit_bio(bio);
 out:
        return ret;
 }