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);