block: Abstract out bvec iterator

Immutable biovecs are going to require an explicit iterator. To
implement immutable bvecs, a later patch is going to add a bi_bvec_done
member to this struct; for now, this patch effectively just renames
things.

Signed-off-by: Kent Overstreet <kmo@daterainc.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: "Ed L. Cashin" <ecashin@coraid.com>
Cc: Nick Piggin <npiggin@kernel.dk>
Cc: Lars Ellenberg <drbd-dev@lists.linbit.com>
Cc: Jiri Kosina <jkosina@suse.cz>
Cc: Matthew Wilcox <willy@linux.intel.com>
Cc: Geoff Levand <geoff@infradead.org>
Cc: Yehuda Sadeh <yehuda@inktank.com>
Cc: Sage Weil <sage@inktank.com>
Cc: Alex Elder <elder@inktank.com>
Cc: ceph-devel@vger.kernel.org
Cc: Joshua Morris <josh.h.morris@us.ibm.com>
Cc: Philip Kelleher <pjk1939@linux.vnet.ibm.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: Jeremy Fitzhardinge <jeremy@goop.org>
Cc: Neil Brown <neilb@suse.de>
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@redhat.com>
Cc: dm-devel@redhat.com
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: linux390@de.ibm.com
Cc: Boaz Harrosh <bharrosh@panasas.com>
Cc: Benny Halevy <bhalevy@tonian.com>
Cc: "James E.J. Bottomley" <JBottomley@parallels.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Nicholas A. Bellinger" <nab@linux-iscsi.org>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Chris Mason <chris.mason@fusionio.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@kernel.org>
Cc: Joern Engel <joern@logfs.org>
Cc: Prasad Joshi <prasadjoshi.linux@gmail.com>
Cc: Trond Myklebust <Trond.Myklebust@netapp.com>
Cc: KONISHI Ryusuke <konishi.ryusuke@lab.ntt.co.jp>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Ben Myers <bpm@sgi.com>
Cc: xfs@oss.sgi.com
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Len Brown <len.brown@intel.com>
Cc: Pavel Machek <pavel@ucw.cz>
Cc: "Rafael J. Wysocki" <rjw@sisk.pl>
Cc: Herton Ronaldo Krzesinski <herton.krzesinski@canonical.com>
Cc: Ben Hutchings <ben@decadent.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Guo Chao <yan@linux.vnet.ibm.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Asai Thambi S P <asamymuthupa@micron.com>
Cc: Selvan Mani <smani@micron.com>
Cc: Sam Bradshaw <sbradshaw@micron.com>
Cc: Wei Yongjun <yongjun_wei@trendmicro.com.cn>
Cc: "Roger Pau Monné" <roger.pau@citrix.com>
Cc: Jan Beulich <jbeulich@suse.com>
Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
Cc: Ian Campbell <Ian.Campbell@citrix.com>
Cc: Sebastian Ott <sebott@linux.vnet.ibm.com>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Jiang Liu <jiang.liu@huawei.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Cc: Jerome Marchand <jmarchand@redhat.com>
Cc: Joe Perches <joe@perches.com>
Cc: Peng Tao <tao.peng@emc.com>
Cc: Andy Adamson <andros@netapp.com>
Cc: fanchaoting <fanchaoting@cn.fujitsu.com>
Cc: Jie Liu <jeff.liu@oracle.com>
Cc: Sunil Mushran <sunil.mushran@gmail.com>
Cc: "Martin K. Petersen" <martin.petersen@oracle.com>
Cc: Namjae Jeon <namjae.jeon@samsung.com>
Cc: Pankaj Kumar <pankaj.km@samsung.com>
Cc: Dan Magenheimer <dan.magenheimer@oracle.com>
Cc: Mel Gorman <mgorman@suse.de>6

1 files changed, 29 insertions, 25 deletions

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index ff8668c5efb1..ce986bacf7b7 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -651,7 +651,7 @@ static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s
 
         for (;;) {
                 tmp = rb_entry(n, struct pkt_rb_node, rb_node);
-                if (s <= tmp->bio->bi_sector)
+                if (s <= tmp->bio->bi_iter.bi_sector)
                         next = n->rb_left;
                 else
                         next = n->rb_right;
@@ -660,12 +660,12 @@ static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s
                 n = next;
         }
 
-        if (s > tmp->bio->bi_sector) {
+        if (s > tmp->bio->bi_iter.bi_sector) {
                 tmp = pkt_rbtree_next(tmp);
                 if (!tmp)
                         return NULL;
         }
-        BUG_ON(s > tmp->bio->bi_sector);
+        BUG_ON(s > tmp->bio->bi_iter.bi_sector);
         return tmp;
 }
 
@@ -676,13 +676,13 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod
 {
         struct rb_node **p = &pd->bio_queue.rb_node;
         struct rb_node *parent = NULL;
-        sector_t s = node->bio->bi_sector;
+        sector_t s = node->bio->bi_iter.bi_sector;
         struct pkt_rb_node *tmp;
 
         while (*p) {
                 parent = *p;
                 tmp = rb_entry(parent, struct pkt_rb_node, rb_node);
-                if (s < tmp->bio->bi_sector)
+                if (s < tmp->bio->bi_iter.bi_sector)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -857,7 +857,8 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                         spin_lock(&pd->iosched.lock);
                         bio = bio_list_peek(&pd->iosched.write_queue);
                         spin_unlock(&pd->iosched.lock);
-                        if (bio && (bio->bi_sector == pd->iosched.last_write))
+                        if (bio && (bio->bi_iter.bi_sector ==
+                                    pd->iosched.last_write))
                                 need_write_seek = 0;
                         if (need_write_seek && reads_queued) {
                                 if (atomic_read(&pd->cdrw.pending_bios) > 0) {
@@ -888,7 +889,8 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                         continue;
 
                 if (bio_data_dir(bio) == READ)
-                        pd->iosched.successive_reads += bio->bi_size >> 10;
+                        pd->iosched.successive_reads +=
+                                bio->bi_iter.bi_size >> 10;
                 else {
                         pd->iosched.successive_reads = 0;
                         pd->iosched.last_write = bio_end_sector(bio);
@@ -978,7 +980,7 @@ static void pkt_end_io_read(struct bio *bio, int err)
 
         pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
                 bio, (unsigned long long)pkt->sector,
-                (unsigned long long)bio->bi_sector, err);
+                (unsigned long long)bio->bi_iter.bi_sector, err);
 
         if (err)
                 atomic_inc(&pkt->io_errors);
@@ -1026,8 +1028,9 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
         memset(written, 0, sizeof(written));
         spin_lock(&pkt->lock);
         bio_list_for_each(bio, &pkt->orig_bios) {
-                int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
-                int num_frames = bio->bi_size / CD_FRAMESIZE;
+                int first_frame = (bio->bi_iter.bi_sector - pkt->sector) /
+                        (CD_FRAMESIZE >> 9);
+                int num_frames = bio->bi_iter.bi_size / CD_FRAMESIZE;
                 pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9);
                 BUG_ON(first_frame < 0);
                 BUG_ON(first_frame + num_frames > pkt->frames);
@@ -1053,7 +1056,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
 
                 bio = pkt->r_bios[f];
                 bio_reset(bio);
-                bio->bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
+                bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
                 bio->bi_bdev = pd->bdev;
                 bio->bi_end_io = pkt_end_io_read;
                 bio->bi_private = pkt;
@@ -1150,8 +1153,8 @@ static int pkt_start_recovery(struct packet_data *pkt)
         bio_reset(pkt->bio);
         pkt->bio->bi_bdev = pd->bdev;
         pkt->bio->bi_rw = REQ_WRITE;
-        pkt->bio->bi_sector = new_sector;
-        pkt->bio->bi_size = pkt->frames * CD_FRAMESIZE;
+        pkt->bio->bi_iter.bi_sector = new_sector;
+        pkt->bio->bi_iter.bi_size = pkt->frames * CD_FRAMESIZE;
         pkt->bio->bi_vcnt = pkt->frames;
 
         pkt->bio->bi_end_io = pkt_end_io_packet_write;
@@ -1213,7 +1216,7 @@ static int pkt_handle_queue(struct pktcdvd_device *pd)
         node = first_node;
         while (node) {
                 bio = node->bio;
-                zone = get_zone(bio->bi_sector, pd);
+                zone = get_zone(bio->bi_iter.bi_sector, pd);
                 list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) {
                         if (p->sector == zone) {
                                 bio = NULL;
@@ -1252,14 +1255,14 @@ try_next_bio:
         pkt_dbg(2, pd, "looking for zone %llx\n", (unsigned long long)zone);
         while ((node = pkt_rbtree_find(pd, zone)) != NULL) {
                 bio = node->bio;
-                pkt_dbg(2, pd, "found zone=%llx\n",
-                        (unsigned long long)get_zone(bio->bi_sector, pd));
-                if (get_zone(bio->bi_sector, pd) != zone)
+                pkt_dbg(2, pd, "found zone=%llx\n", (unsigned long long)
+                        get_zone(bio->bi_iter.bi_sector, pd));
+                if (get_zone(bio->bi_iter.bi_sector, pd) != zone)
                         break;
                 pkt_rbtree_erase(pd, node);
                 spin_lock(&pkt->lock);
                 bio_list_add(&pkt->orig_bios, bio);
-                pkt->write_size += bio->bi_size / CD_FRAMESIZE;
+                pkt->write_size += bio->bi_iter.bi_size / CD_FRAMESIZE;
                 spin_unlock(&pkt->lock);
         }
         /* check write congestion marks, and if bio_queue_size is
@@ -1293,7 +1296,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
         struct bio_vec *bvec = pkt->w_bio->bi_io_vec;
 
         bio_reset(pkt->w_bio);
-        pkt->w_bio->bi_sector = pkt->sector;
+        pkt->w_bio->bi_iter.bi_sector = pkt->sector;
         pkt->w_bio->bi_bdev = pd->bdev;
         pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
         pkt->w_bio->bi_private = pkt;
@@ -2370,20 +2373,20 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
 
         if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
                 pkt_notice(pd, "WRITE for ro device (%llu)\n",
-                           (unsigned long long)bio->bi_sector);
+                           (unsigned long long)bio->bi_iter.bi_sector);
                 goto end_io;
         }
 
-        if (!bio->bi_size || (bio->bi_size % CD_FRAMESIZE)) {
+        if (!bio->bi_iter.bi_size || (bio->bi_iter.bi_size % CD_FRAMESIZE)) {
                 pkt_err(pd, "wrong bio size\n");
                 goto end_io;
         }
 
         blk_queue_bounce(q, &bio);
 
-        zone = get_zone(bio->bi_sector, pd);
+        zone = get_zone(bio->bi_iter.bi_sector, pd);
         pkt_dbg(2, pd, "start = %6llx stop = %6llx\n",
-                (unsigned long long)bio->bi_sector,
+                (unsigned long long)bio->bi_iter.bi_sector,
                 (unsigned long long)bio_end_sector(bio));
 
         /* Check if we have to split the bio */
@@ -2395,7 +2398,7 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                 last_zone = get_zone(bio_end_sector(bio) - 1, pd);
                 if (last_zone != zone) {
                         BUG_ON(last_zone != zone + pd->settings.size);
-                        first_sectors = last_zone - bio->bi_sector;
+                        first_sectors = last_zone - bio->bi_iter.bi_sector;
                         bp = bio_split(bio, first_sectors);
                         BUG_ON(!bp);
                         pkt_make_request(q, &bp->bio1);
@@ -2417,7 +2420,8 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                         if ((pkt->state == PACKET_WAITING_STATE) ||
                             (pkt->state == PACKET_READ_WAIT_STATE)) {
                                 bio_list_add(&pkt->orig_bios, bio);
-                                pkt->write_size += bio->bi_size / CD_FRAMESIZE;
+                                pkt->write_size +=
+                                        bio->bi_iter.bi_size / CD_FRAMESIZE;
                                 if ((pkt->write_size >= pkt->frames) &&
                                     (pkt->state == PACKET_WAITING_STATE)) {
                                         atomic_inc(&pkt->run_sm);