Merge branch 'for-3.10/core' of git://git.kernel.dk/linux-block

Pull block core updates from Jens Axboe:

 - Major bit is Kents prep work for immutable bio vecs.

 - Stable candidate fix for a scheduling-while-atomic in the queue
   bypass operation.

 - Fix for the hang on exceeded rq->datalen 32-bit unsigned when merging
   discard bios.

 - Tejuns changes to convert the writeback thread pool to the generic
   workqueue mechanism.

 - Runtime PM framework, SCSI patches exists on top of these in James'
   tree.

 - A few random fixes.

* 'for-3.10/core' of git://git.kernel.dk/linux-block: (40 commits)
  relay: move remove_buf_file inside relay_close_buf
  partitions/efi.c: replace useless kzalloc's by kmalloc's
  fs/block_dev.c: fix iov_shorten() criteria in blkdev_aio_read()
  block: fix max discard sectors limit
  blkcg: fix "scheduling while atomic" in blk_queue_bypass_start
  Documentation: cfq-iosched: update documentation help for cfq tunables
  writeback: expose the bdi_wq workqueue
  writeback: replace custom worker pool implementation with unbound workqueue
  writeback: remove unused bdi_pending_list
  aoe: Fix unitialized var usage
  bio-integrity: Add explicit field for owner of bip_buf
  block: Add an explicit bio flag for bios that own their bvec
  block: Add bio_alloc_pages()
  block: Convert some code to bio_for_each_segment_all()
  block: Add bio_for_each_segment_all()
  bounce: Refactor __blk_queue_bounce to not use bi_io_vec
  raid1: use bio_copy_data()
  pktcdvd: Use bio_reset() in disabled code to kill bi_idx usage
  pktcdvd: use bio_copy_data()
  block: Add bio_copy_data()
  ...

1 files changed, 23 insertions, 79 deletions

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 9f2d348f7115..3c08983e600a 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -901,7 +901,7 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                         pd->iosched.successive_reads += bio->bi_size >> 10;
                 else {
                         pd->iosched.successive_reads = 0;
-                        pd->iosched.last_write = bio->bi_sector + bio_sectors(bio);
+                        pd->iosched.last_write = bio_end_sector(bio);
                 }
                 if (pd->iosched.successive_reads >= HI_SPEED_SWITCH) {
                         if (pd->read_speed == pd->write_speed) {
@@ -948,31 +948,6 @@ static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_que
 }
 
 /*
- * Copy CD_FRAMESIZE bytes from src_bio into a destination page
- */
-static void pkt_copy_bio_data(struct bio *src_bio, int seg, int offs, struct page *dst_page, int dst_offs)
-{
-        unsigned int copy_size = CD_FRAMESIZE;
-
-        while (copy_size > 0) {
-                struct bio_vec *src_bvl = bio_iovec_idx(src_bio, seg);
-                void *vfrom = kmap_atomic(src_bvl->bv_page) +
-                        src_bvl->bv_offset + offs;
-                void *vto = page_address(dst_page) + dst_offs;
-                int len = min_t(int, copy_size, src_bvl->bv_len - offs);
-
-                BUG_ON(len < 0);
-                memcpy(vto, vfrom, len);
-                kunmap_atomic(vfrom);
-
-                seg++;
-                offs = 0;
-                dst_offs += len;
-                copy_size -= len;
-        }
-}
-
-/*
  * Copy all data for this packet to pkt->pages[], so that
  * a) The number of required segments for the write bio is minimized, which
  *    is necessary for some scsi controllers.
@@ -1181,16 +1156,15 @@ static int pkt_start_recovery(struct packet_data *pkt)
         new_sector = new_block * (CD_FRAMESIZE >> 9);
         pkt->sector = new_sector;
 
+        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_next = NULL;
-        pkt->bio->bi_flags = 1 << BIO_UPTODATE;
-        pkt->bio->bi_idx = 0;
+        pkt->bio->bi_size = pkt->frames * CD_FRAMESIZE;
+        pkt->bio->bi_vcnt = pkt->frames;
 
-        BUG_ON(pkt->bio->bi_rw != REQ_WRITE);
-        BUG_ON(pkt->bio->bi_vcnt != pkt->frames);
-        BUG_ON(pkt->bio->bi_size != pkt->frames * CD_FRAMESIZE);
-        BUG_ON(pkt->bio->bi_end_io != pkt_end_io_packet_write);
-        BUG_ON(pkt->bio->bi_private != pkt);
+        pkt->bio->bi_end_io = pkt_end_io_packet_write;
+        pkt->bio->bi_private = pkt;
 
         drop_super(sb);
         return 1;
@@ -1325,55 +1299,35 @@ try_next_bio:
  */
 static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
 {
-        struct bio *bio;
         int f;
-        int frames_write;
         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_bdev = pd->bdev;
+        pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
+        pkt->w_bio->bi_private = pkt;
+
+        /* XXX: locking? */
         for (f = 0; f < pkt->frames; f++) {
                 bvec[f].bv_page = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE];
                 bvec[f].bv_offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
+                if (!bio_add_page(pkt->w_bio, bvec[f].bv_page, CD_FRAMESIZE, bvec[f].bv_offset))
+                        BUG();
         }
+        VPRINTK(DRIVER_NAME": vcnt=%d\n", pkt->w_bio->bi_vcnt);
 
         /*
          * Fill-in bvec with data from orig_bios.
          */
-        frames_write = 0;
         spin_lock(&pkt->lock);
-        bio_list_for_each(bio, &pkt->orig_bios) {
-                int segment = bio->bi_idx;
-                int src_offs = 0;
-                int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
-                int num_frames = bio->bi_size / CD_FRAMESIZE;
-                BUG_ON(first_frame < 0);
-                BUG_ON(first_frame + num_frames > pkt->frames);
-                for (f = first_frame; f < first_frame + num_frames; f++) {
-                        struct bio_vec *src_bvl = bio_iovec_idx(bio, segment);
-
-                        while (src_offs >= src_bvl->bv_len) {
-                                src_offs -= src_bvl->bv_len;
-                                segment++;
-                                BUG_ON(segment >= bio->bi_vcnt);
-                                src_bvl = bio_iovec_idx(bio, segment);
-                        }
+        bio_copy_data(pkt->w_bio, pkt->orig_bios.head);
 
-                        if (src_bvl->bv_len - src_offs >= CD_FRAMESIZE) {
-                                bvec[f].bv_page = src_bvl->bv_page;
-                                bvec[f].bv_offset = src_bvl->bv_offset + src_offs;
-                        } else {
-                                pkt_copy_bio_data(bio, segment, src_offs,
-                                                  bvec[f].bv_page, bvec[f].bv_offset);
-                        }
-                        src_offs += CD_FRAMESIZE;
-                        frames_write++;
-                }
-        }
         pkt_set_state(pkt, PACKET_WRITE_WAIT_STATE);
         spin_unlock(&pkt->lock);
 
         VPRINTK("pkt_start_write: Writing %d frames for zone %llx\n",
-                frames_write, (unsigned long long)pkt->sector);
-        BUG_ON(frames_write != pkt->write_size);
+                pkt->write_size, (unsigned long long)pkt->sector);
 
         if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames)) {
                 pkt_make_local_copy(pkt, bvec);
@@ -1383,16 +1337,6 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
         }
 
         /* Start the write request */
-        bio_reset(pkt->w_bio);
-        pkt->w_bio->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;
-        for (f = 0; f < pkt->frames; f++)
-                if (!bio_add_page(pkt->w_bio, bvec[f].bv_page, CD_FRAMESIZE, bvec[f].bv_offset))
-                        BUG();
-        VPRINTK(DRIVER_NAME": vcnt=%d\n", pkt->w_bio->bi_vcnt);
-
         atomic_set(&pkt->io_wait, 1);
         pkt->w_bio->bi_rw = WRITE;
         pkt_queue_bio(pd, pkt->w_bio);
@@ -2431,7 +2375,7 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                 cloned_bio->bi_bdev = pd->bdev;
                 cloned_bio->bi_private = psd;
                 cloned_bio->bi_end_io = pkt_end_io_read_cloned;
-                pd->stats.secs_r += bio->bi_size >> 9;
+                pd->stats.secs_r += bio_sectors(bio);
                 pkt_queue_bio(pd, cloned_bio);
                 return;
         }
@@ -2452,7 +2396,7 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
         zone = ZONE(bio->bi_sector, pd);
         VPRINTK("pkt_make_request: start = %6llx stop = %6llx\n",
                 (unsigned long long)bio->bi_sector,
-                (unsigned long long)(bio->bi_sector + bio_sectors(bio)));
+                (unsigned long long)bio_end_sector(bio));
 
         /* Check if we have to split the bio */
         {
@@ -2460,7 +2404,7 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
                 sector_t last_zone;
                 int first_sectors;
 
-                last_zone = ZONE(bio->bi_sector + bio_sectors(bio) - 1, pd);
+                last_zone = 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;