16 files changed, 124 insertions, 149 deletions

diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 748dea4f34dc..758da2287d9a 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1406,7 +1406,7 @@ next_segment:
 
                 track = block / (floppy->dtype->sects * floppy->type->sect_mult);
                 sector = block % (floppy->dtype->sects * floppy->type->sect_mult);
-                data = rq->buffer + 512 * cnt;
+                data = bio_data(rq->bio) + 512 * cnt;
 #ifdef DEBUG
                 printk("access to track %d, sector %d, with buffer at "
                        "0x%08lx\n", track, sector, data);
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index cfa64bdf01c9..2104b1b4ccda 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1484,7 +1484,7 @@ repeat:
         ReqCnt = 0;
         ReqCmd = rq_data_dir(fd_request);
         ReqBlock = blk_rq_pos(fd_request);
-        ReqBuffer = fd_request->buffer;
+        ReqBuffer = bio_data(fd_request->bio);
         setup_req_params( drive );
         do_fd_action( drive );
 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index fa9bb742df6e..dc3a41c82b38 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2351,7 +2351,7 @@ static void rw_interrupt(void)
         }
 
         if (CT(COMMAND) != FD_READ ||
-            raw_cmd->kernel_data == current_req->buffer) {
+            raw_cmd->kernel_data == bio_data(current_req->bio)) {
                 /* transfer directly from buffer */
                 cont->done(1);
         } else if (CT(COMMAND) == FD_READ) {
@@ -2640,7 +2640,7 @@ static int make_raw_rw_request(void)
                 raw_cmd->flags &= ~FD_RAW_WRITE;
                 raw_cmd->flags |= FD_RAW_READ;
                 COMMAND = FM_MODE(_floppy, FD_READ);
-        } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
+        } else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) {
                 unsigned long dma_limit;
                 int direct, indirect;
 
@@ -2654,13 +2654,13 @@ static int make_raw_rw_request(void)
                  */
                 max_size = buffer_chain_size();
                 dma_limit = (MAX_DMA_ADDRESS -
-                             ((unsigned long)current_req->buffer)) >> 9;
+                             ((unsigned long)bio_data(current_req->bio))) >> 9;
                 if ((unsigned long)max_size > dma_limit)
                         max_size = dma_limit;
                 /* 64 kb boundaries */
-                if (CROSS_64KB(current_req->buffer, max_size << 9))
+                if (CROSS_64KB(bio_data(current_req->bio), max_size << 9))
                         max_size = (K_64 -
-                                    ((unsigned long)current_req->buffer) %
+                                    ((unsigned long)bio_data(current_req->bio)) %
                                     K_64) >> 9;
                 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
                 /*
@@ -2677,7 +2677,7 @@ static int make_raw_rw_request(void)
                        (DP->read_track & (1 << DRS->probed_format)))))) {
                         max_size = blk_rq_sectors(current_req);
                 } else {
-                        raw_cmd->kernel_data = current_req->buffer;
+                        raw_cmd->kernel_data = bio_data(current_req->bio);
                         raw_cmd->length = current_count_sectors << 9;
                         if (raw_cmd->length == 0) {
                                 DPRINT("%s: zero dma transfer attempted\n", __func__);
@@ -2731,7 +2731,7 @@ static int make_raw_rw_request(void)
         raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
         raw_cmd->length <<= 9;
         if ((raw_cmd->length < current_count_sectors << 9) ||
-            (raw_cmd->kernel_data != current_req->buffer &&
+            (raw_cmd->kernel_data != bio_data(current_req->bio) &&
              CT(COMMAND) == FD_WRITE &&
              (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
               aligned_sector_t < buffer_min)) ||
@@ -2739,7 +2739,7 @@ static int make_raw_rw_request(void)
             raw_cmd->length <= 0 || current_count_sectors <= 0) {
                 DPRINT("fractionary current count b=%lx s=%lx\n",
                        raw_cmd->length, current_count_sectors);
-                if (raw_cmd->kernel_data != current_req->buffer)
+                if (raw_cmd->kernel_data != bio_data(current_req->bio))
                         pr_info("addr=%d, length=%ld\n",
                                 (int)((raw_cmd->kernel_data -
                                        floppy_track_buffer) >> 9),
@@ -2756,7 +2756,7 @@ static int make_raw_rw_request(void)
                 return 0;
         }
 
-        if (raw_cmd->kernel_data != current_req->buffer) {
+        if (raw_cmd->kernel_data != bio_data(current_req->bio)) {
                 if (raw_cmd->kernel_data < floppy_track_buffer ||
                     current_count_sectors < 0 ||
                     raw_cmd->length < 0 ||
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index bf397bf108b7..8a290c08262f 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -464,11 +464,11 @@ static void read_intr(void)
 
 ok_to_read:
         req = hd_req;
-        insw(HD_DATA, req->buffer, 256);
+        insw(HD_DATA, bio_data(req->bio), 256);
 #ifdef DEBUG
         printk("%s: read: sector %ld, remaining = %u, buffer=%p\n",
                req->rq_disk->disk_name, blk_rq_pos(req) + 1,
-               blk_rq_sectors(req) - 1, req->buffer+512);
+               blk_rq_sectors(req) - 1, bio_data(req->bio)+512);
 #endif
         if (hd_end_request(0, 512)) {
                 SET_HANDLER(&read_intr);
@@ -505,7 +505,7 @@ static void write_intr(void)
 ok_to_write:
         if (hd_end_request(0, 512)) {
                 SET_HANDLER(&write_intr);
-                outsw(HD_DATA, req->buffer, 256);
+                outsw(HD_DATA, bio_data(req->bio), 256);
                 return;
         }
 
@@ -624,7 +624,7 @@ repeat:
         printk("%s: %sing: CHS=%d/%d/%d, sectors=%d, buffer=%p\n",
                 req->rq_disk->disk_name,
                 req_data_dir(req) == READ ? "read" : "writ",
-                cyl, head, sec, nsect, req->buffer);
+                cyl, head, sec, nsect, bio_data(req->bio));
 #endif
         if (req->cmd_type == REQ_TYPE_FS) {
                 switch (rq_data_dir(req)) {
@@ -643,7 +643,7 @@ repeat:
                                 bad_rw_intr();
                                 goto repeat;
                         }
-                        outsw(HD_DATA, req->buffer, 256);
+                        outsw(HD_DATA, bio_data(req->bio), 256);
                         break;
                 default:
                         printk("unknown hd-command\n");
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index eb59b1241366..e352cac707e8 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -479,7 +479,7 @@ static unsigned int mg_out(struct mg_host *host,
 
 static void mg_read_one(struct mg_host *host, struct request *req)
 {
-        u16 *buff = (u16 *)req->buffer;
+        u16 *buff = (u16 *)bio_data(req->bio);
         u32 i;
 
         for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
@@ -496,7 +496,7 @@ static void mg_read(struct request *req)
                 mg_bad_rw_intr(host);
 
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), bio_data(req->bio));
 
         do {
                 if (mg_wait(host, ATA_DRQ,
@@ -514,7 +514,7 @@ static void mg_read(struct request *req)
 
 static void mg_write_one(struct mg_host *host, struct request *req)
 {
-        u16 *buff = (u16 *)req->buffer;
+        u16 *buff = (u16 *)bio_data(req->bio);
         u32 i;
 
         for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
@@ -534,7 +534,7 @@ static void mg_write(struct request *req)
         }
 
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-               rem, blk_rq_pos(req), req->buffer);
+               rem, blk_rq_pos(req), bio_data(req->bio));
 
         if (mg_wait(host, ATA_DRQ,
                     MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
@@ -585,7 +585,7 @@ ok_to_read:
         mg_read_one(host, req);
 
         MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-               blk_rq_pos(req), blk_rq_sectors(req) - 1, req->buffer);
+               blk_rq_pos(req), blk_rq_sectors(req) - 1, bio_data(req->bio));
 
         /* send read confirm */
         outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
@@ -624,7 +624,7 @@ ok_to_write:
                 /* write 1 sector and set handler if remains */
                 mg_write_one(host, req);
                 MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                       blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
+                       blk_rq_pos(req), blk_rq_sectors(req), bio_data(req->bio));
                 host->mg_do_intr = mg_write_intr;
                 mod_timer(&host->timer, jiffies + 3 * HZ);
         }
diff --git a/drivers/block/null_blk.c b/drivers/block/null_blk.c
index 091b9ea14feb..b40af63a5476 100644
--- a/drivers/block/null_blk.c
+++ b/drivers/block/null_blk.c
@@ -32,6 +32,7 @@ struct nullb {
         unsigned int index;
         struct request_queue *q;
         struct gendisk *disk;
+        struct blk_mq_tag_set tag_set;
         struct hrtimer timer;
         unsigned int queue_depth;
         spinlock_t lock;
@@ -226,7 +227,7 @@ static void null_cmd_end_timer(struct nullb_cmd *cmd)
 
 static void null_softirq_done_fn(struct request *rq)
 {
-        end_cmd(rq->special);
+        end_cmd(blk_mq_rq_to_pdu(rq));
 }
 
 static inline void null_handle_cmd(struct nullb_cmd *cmd)
@@ -311,7 +312,7 @@ static void null_request_fn(struct request_queue *q)
 
 static int null_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *rq)
 {
-        struct nullb_cmd *cmd = rq->special;
+        struct nullb_cmd *cmd = blk_mq_rq_to_pdu(rq);
 
         cmd->rq = rq;
         cmd->nq = hctx->driver_data;
@@ -320,46 +321,6 @@ static int null_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *rq)
         return BLK_MQ_RQ_QUEUE_OK;
 }
 
-static struct blk_mq_hw_ctx *null_alloc_hctx(struct blk_mq_reg *reg, unsigned int hctx_index)
-{
-        int b_size = DIV_ROUND_UP(reg->nr_hw_queues, nr_online_nodes);
-        int tip = (reg->nr_hw_queues % nr_online_nodes);
-        int node = 0, i, n;
-
-        /*
-         * Split submit queues evenly wrt to the number of nodes. If uneven,
-         * fill the first buckets with one extra, until the rest is filled with
-         * no extra.
-         */
-        for (i = 0, n = 1; i < hctx_index; i++, n++) {
-                if (n % b_size == 0) {
-                        n = 0;
-                        node++;
-
-                        tip--;
-                        if (!tip)
-                                b_size = reg->nr_hw_queues / nr_online_nodes;
-                }
-        }
-
-        /*
-         * A node might not be online, therefore map the relative node id to the
-         * real node id.
-         */
-        for_each_online_node(n) {
-                if (!node)
-                        break;
-                node--;
-        }
-
-        return kzalloc_node(sizeof(struct blk_mq_hw_ctx), GFP_KERNEL, n);
-}
-
-static void null_free_hctx(struct blk_mq_hw_ctx *hctx, unsigned int hctx_index)
-{
-        kfree(hctx);
-}
-
 static void null_init_queue(struct nullb *nullb, struct nullb_queue *nq)
 {
         BUG_ON(!nullb);
@@ -389,19 +350,14 @@ static struct blk_mq_ops null_mq_ops = {
         .complete       = null_softirq_done_fn,
 };
 
-static struct blk_mq_reg null_mq_reg = {
-        .ops            = &null_mq_ops,
-        .queue_depth    = 64,
-        .cmd_size       = sizeof(struct nullb_cmd),
-        .flags          = BLK_MQ_F_SHOULD_MERGE,
-};
-
 static void null_del_dev(struct nullb *nullb)
 {
         list_del_init(&nullb->list);
 
         del_gendisk(nullb->disk);
         blk_cleanup_queue(nullb->q);
+        if (queue_mode == NULL_Q_MQ)
+                blk_mq_free_tag_set(&nullb->tag_set);
         put_disk(nullb->disk);
         kfree(nullb);
 }
@@ -506,7 +462,7 @@ static int null_add_dev(void)
 
         nullb = kzalloc_node(sizeof(*nullb), GFP_KERNEL, home_node);
         if (!nullb)
-                return -ENOMEM;
+                goto out;
 
         spin_lock_init(&nullb->lock);
 
@@ -514,49 +470,44 @@ static int null_add_dev(void)
                 submit_queues = nr_online_nodes;
 
         if (setup_queues(nullb))
-                goto err;
+                goto out_free_nullb;
 
         if (queue_mode == NULL_Q_MQ) {
-                null_mq_reg.numa_node = home_node;
-                null_mq_reg.queue_depth = hw_queue_depth;
-                null_mq_reg.nr_hw_queues = submit_queues;
-
-                if (use_per_node_hctx) {
-                        null_mq_reg.ops->alloc_hctx = null_alloc_hctx;
-                        null_mq_reg.ops->free_hctx = null_free_hctx;
-                } else {
-                        null_mq_reg.ops->alloc_hctx = blk_mq_alloc_single_hw_queue;
-                        null_mq_reg.ops->free_hctx = blk_mq_free_single_hw_queue;
-                }
-
-                nullb->q = blk_mq_init_queue(&null_mq_reg, nullb);
+                nullb->tag_set.ops = &null_mq_ops;
+                nullb->tag_set.nr_hw_queues = submit_queues;
+                nullb->tag_set.queue_depth = hw_queue_depth;
+                nullb->tag_set.numa_node = home_node;
+                nullb->tag_set.cmd_size = sizeof(struct nullb_cmd);
+                nullb->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
+                nullb->tag_set.driver_data = nullb;
+
+                if (blk_mq_alloc_tag_set(&nullb->tag_set))
+                        goto out_cleanup_queues;
+
+                nullb->q = blk_mq_init_queue(&nullb->tag_set);
+                if (!nullb->q)
+                        goto out_cleanup_tags;
         } else if (queue_mode == NULL_Q_BIO) {
                 nullb->q = blk_alloc_queue_node(GFP_KERNEL, home_node);
+                if (!nullb->q)
+                        goto out_cleanup_queues;
                 blk_queue_make_request(nullb->q, null_queue_bio);
                 init_driver_queues(nullb);
         } else {
                 nullb->q = blk_init_queue_node(null_request_fn, &nullb->lock, home_node);
+                if (!nullb->q)
+                        goto out_cleanup_queues;
                 blk_queue_prep_rq(nullb->q, null_rq_prep_fn);
-                if (nullb->q)
-                        blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
+                blk_queue_softirq_done(nullb->q, null_softirq_done_fn);
                 init_driver_queues(nullb);
         }
 
-        if (!nullb->q)
-                goto queue_fail;
-
         nullb->q->queuedata = nullb;
         queue_flag_set_unlocked(QUEUE_FLAG_NONROT, nullb->q);
 
         disk = nullb->disk = alloc_disk_node(1, home_node);
-        if (!disk) {
-queue_fail:
-                blk_cleanup_queue(nullb->q);
-                cleanup_queues(nullb);
-err:
-                kfree(nullb);
-                return -ENOMEM;
-        }
+        if (!disk)
+                goto out_cleanup_blk_queue;
 
         mutex_lock(&lock);
         list_add_tail(&nullb->list, &nullb_list);
@@ -579,6 +530,18 @@ err:
         sprintf(disk->disk_name, "nullb%d", nullb->index);
         add_disk(disk);
         return 0;
+
+out_cleanup_blk_queue:
+        blk_cleanup_queue(nullb->q);
+out_cleanup_tags:
+        if (queue_mode == NULL_Q_MQ)
+                blk_mq_free_tag_set(&nullb->tag_set);
+out_cleanup_queues:
+        cleanup_queues(nullb);
+out_free_nullb:
+        kfree(nullb);
+out:
+        return -ENOMEM;
 }
 
 static int __init null_init(void)
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index e76bdc074dbe..719cb1bc1640 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -747,7 +747,7 @@ static void do_pcd_request(struct request_queue * q)
                         pcd_current = cd;
                         pcd_sector = blk_rq_pos(pcd_req);
                         pcd_count = blk_rq_cur_sectors(pcd_req);
-                        pcd_buf = pcd_req->buffer;
+                        pcd_buf = bio_data(pcd_req->bio);
                         pcd_busy = 1;
                         ps_set_intr(do_pcd_read, NULL, 0, nice);
                         return;
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 19ad8f0c83ef..fea7e76a00de 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -454,7 +454,7 @@ static enum action do_pd_io_start(void)
                 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
                         return Fail;
                 pd_run = blk_rq_sectors(pd_req);
-                pd_buf = pd_req->buffer;
+                pd_buf = bio_data(pd_req->bio);
                 pd_retries = 0;
                 if (pd_cmd == READ)
                         return do_pd_read_start();
@@ -485,7 +485,7 @@ static int pd_next_buf(void)
         spin_lock_irqsave(&pd_lock, saved_flags);
         __blk_end_request_cur(pd_req, 0);
         pd_count = blk_rq_cur_sectors(pd_req);
-        pd_buf = pd_req->buffer;
+        pd_buf = bio_data(pd_req->bio);
         spin_unlock_irqrestore(&pd_lock, saved_flags);
         return 0;
 }
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index f5c86d523ba0..9a15fd3c9349 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -795,7 +795,7 @@ repeat:
         }
 
         pf_cmd = rq_data_dir(pf_req);
-        pf_buf = pf_req->buffer;
+        pf_buf = bio_data(pf_req->bio);
         pf_retries = 0;
 
         pf_busy = 1;
@@ -827,7 +827,7 @@ static int pf_next_buf(void)
                 if (!pf_req)
                         return 1;
                 pf_count = blk_rq_cur_sectors(pf_req);
-                pf_buf = pf_req->buffer;
+                pf_buf = bio_data(pf_req->bio);
         }
         return 0;
 }
diff --git a/drivers/block/skd_main.c b/drivers/block/skd_main.c
index a69dd93d1bd5..c48d9084c965 100644
--- a/drivers/block/skd_main.c
+++ b/drivers/block/skd_main.c
@@ -563,7 +563,6 @@ skd_prep_discard_cdb(struct skd_scsi_request *scsi_req,
 
         req = skreq->req;
         blk_add_request_payload(req, page, len);
-        req->buffer = buf;
 }
 
 static void skd_request_fn_not_online(struct request_queue *q);
@@ -744,6 +743,7 @@ static void skd_request_fn(struct request_queue *q)
                                 break;
                         }
                         skreq->discard_page = 1;
+                        req->completion_data = page;
                         skd_prep_discard_cdb(scsi_req, skreq, page, lba, count);
 
                 } else if (flush == SKD_FLUSH_ZERO_SIZE_FIRST) {
@@ -858,8 +858,7 @@ static void skd_end_request(struct skd_device *skdev,
                 (skreq->discard_page == 1)) {
                 pr_debug("%s:%s:%d, free the page!",
                          skdev->name, __func__, __LINE__);
-                free_page((unsigned long)req->buffer);
-                req->buffer = NULL;
+                __free_page(req->completion_data);
         }
 
         if (unlikely(error)) {
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index b02d53a399f3..6b44bbe528b7 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -549,7 +549,7 @@ static void redo_fd_request(struct request_queue *q)
                 case READ:
                         err = floppy_read_sectors(fs, blk_rq_pos(req),
                                                   blk_rq_cur_sectors(req),
-                                                  req->buffer);
+                                                  bio_data(req->bio));
                         break;
                 }
         done:
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index c74f7b56e7c4..523ee8fd4c15 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -342,7 +342,7 @@ static void start_request(struct floppy_state *fs)
                 swim3_dbg("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%u buf=%p\n",
                           req->rq_disk->disk_name, req->cmd,
                           (long)blk_rq_pos(req), blk_rq_sectors(req),
-                          req->buffer);
+                          bio_data(req->bio));
                 swim3_dbg("           errors=%d current_nr_sectors=%u\n",
                           req->errors, blk_rq_cur_sectors(req));
 #endif
@@ -479,11 +479,11 @@ static inline void setup_transfer(struct floppy_state *fs)
                 /* Set up 3 dma commands: write preamble, data, postamble */
                 init_dma(cp, OUTPUT_MORE, write_preamble, sizeof(write_preamble));
                 ++cp;
-                init_dma(cp, OUTPUT_MORE, req->buffer, 512);
+                init_dma(cp, OUTPUT_MORE, bio_data(req->bio), 512);
                 ++cp;
                 init_dma(cp, OUTPUT_LAST, write_postamble, sizeof(write_postamble));
         } else {
-                init_dma(cp, INPUT_LAST, req->buffer, n * 512);
+                init_dma(cp, INPUT_LAST, bio_data(req->bio), n * 512);
         }
         ++cp;
         out_le16(&cp->command, DBDMA_STOP);
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index cb9b1f8326c3..c8f286e8d80f 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -30,6 +30,9 @@ struct virtio_blk
         /* The disk structure for the kernel. */
         struct gendisk *disk;
 
+        /* Block layer tags. */
+        struct blk_mq_tag_set tag_set;
+
         /* Process context for config space updates */
         struct work_struct config_work;
 
@@ -112,7 +115,7 @@ static int __virtblk_add_req(struct virtqueue *vq,
 
 static inline void virtblk_request_done(struct request *req)
 {
-        struct virtblk_req *vbr = req->special;
+        struct virtblk_req *vbr = blk_mq_rq_to_pdu(req);
         int error = virtblk_result(vbr);
 
         if (req->cmd_type == REQ_TYPE_BLOCK_PC) {
@@ -147,14 +150,14 @@ static void virtblk_done(struct virtqueue *vq)
 
         /* In case queue is stopped waiting for more buffers. */
         if (req_done)
-                blk_mq_start_stopped_hw_queues(vblk->disk->queue);
+                blk_mq_start_stopped_hw_queues(vblk->disk->queue, true);
         spin_unlock_irqrestore(&vblk->vq_lock, flags);
 }
 
 static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req)
 {
         struct virtio_blk *vblk = hctx->queue->queuedata;
-        struct virtblk_req *vbr = req->special;
+        struct virtblk_req *vbr = blk_mq_rq_to_pdu(req);
         unsigned long flags;
         unsigned int num;
         const bool last = (req->cmd_flags & REQ_END) != 0;
@@ -480,33 +483,27 @@ static const struct device_attribute dev_attr_cache_type_rw =
         __ATTR(cache_type, S_IRUGO|S_IWUSR,
                virtblk_cache_type_show, virtblk_cache_type_store);
 
-static struct blk_mq_ops virtio_mq_ops = {
-        .queue_rq       = virtio_queue_rq,
-        .map_queue      = blk_mq_map_queue,
-        .alloc_hctx     = blk_mq_alloc_single_hw_queue,
-        .free_hctx      = blk_mq_free_single_hw_queue,
-        .complete       = virtblk_request_done,
-};
-
-static struct blk_mq_reg virtio_mq_reg = {
-        .ops            = &virtio_mq_ops,
-        .nr_hw_queues   = 1,
-        .queue_depth    = 0, /* Set in virtblk_probe */
-        .numa_node      = NUMA_NO_NODE,
-        .flags          = BLK_MQ_F_SHOULD_MERGE,
-};
-module_param_named(queue_depth, virtio_mq_reg.queue_depth, uint, 0444);
-
-static int virtblk_init_vbr(void *data, struct blk_mq_hw_ctx *hctx,
-                             struct request *rq, unsigned int nr)
+static int virtblk_init_request(void *data, struct request *rq,
+                unsigned int hctx_idx, unsigned int request_idx,
+                unsigned int numa_node)
 {
         struct virtio_blk *vblk = data;
-        struct virtblk_req *vbr = rq->special;
+        struct virtblk_req *vbr = blk_mq_rq_to_pdu(rq);
 
         sg_init_table(vbr->sg, vblk->sg_elems);
         return 0;
 }
 
+static struct blk_mq_ops virtio_mq_ops = {
+        .queue_rq       = virtio_queue_rq,
+        .map_queue      = blk_mq_map_queue,
+        .complete       = virtblk_request_done,
+        .init_request   = virtblk_init_request,
+};
+
+static unsigned int virtblk_queue_depth;
+module_param_named(queue_depth, virtblk_queue_depth, uint, 0444);
+
 static int virtblk_probe(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk;
@@ -561,24 +558,34 @@ static int virtblk_probe(struct virtio_device *vdev)
         }
 
         /* Default queue sizing is to fill the ring. */
-        if (!virtio_mq_reg.queue_depth) {
-                virtio_mq_reg.queue_depth = vblk->vq->num_free;
+        if (!virtblk_queue_depth) {
+                virtblk_queue_depth = vblk->vq->num_free;
                 /* ... but without indirect descs, we use 2 descs per req */
                 if (!virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC))
-                        virtio_mq_reg.queue_depth /= 2;
+                        virtblk_queue_depth /= 2;
         }
-        virtio_mq_reg.cmd_size =
+
+        memset(&vblk->tag_set, 0, sizeof(vblk->tag_set));
+        vblk->tag_set.ops = &virtio_mq_ops;
+        vblk->tag_set.nr_hw_queues = 1;
+        vblk->tag_set.queue_depth = virtblk_queue_depth;
+        vblk->tag_set.numa_node = NUMA_NO_NODE;
+        vblk->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
+        vblk->tag_set.cmd_size =
                 sizeof(struct virtblk_req) +
                 sizeof(struct scatterlist) * sg_elems;
+        vblk->tag_set.driver_data = vblk;
 
-        q = vblk->disk->queue = blk_mq_init_queue(&virtio_mq_reg, vblk);
+        err = blk_mq_alloc_tag_set(&vblk->tag_set);
+        if (err)
+                goto out_put_disk;
+
+        q = vblk->disk->queue = blk_mq_init_queue(&vblk->tag_set);
         if (!q) {
                 err = -ENOMEM;
-                goto out_put_disk;
+                goto out_free_tags;
         }
 
-        blk_mq_init_commands(q, virtblk_init_vbr, vblk);
-
         q->queuedata = vblk;
 
         virtblk_name_format("vd", index, vblk->disk->disk_name, DISK_NAME_LEN);
@@ -679,6 +686,8 @@ static int virtblk_probe(struct virtio_device *vdev)
 out_del_disk:
         del_gendisk(vblk->disk);
         blk_cleanup_queue(vblk->disk->queue);
+out_free_tags:
+        blk_mq_free_tag_set(&vblk->tag_set);
 out_put_disk:
         put_disk(vblk->disk);
 out_free_vq:
@@ -705,6 +714,8 @@ static void virtblk_remove(struct virtio_device *vdev)
         del_gendisk(vblk->disk);
         blk_cleanup_queue(vblk->disk->queue);
 
+        blk_mq_free_tag_set(&vblk->tag_set);
+
         /* Stop all the virtqueues. */
         vdev->config->reset(vdev);
 
@@ -749,7 +760,7 @@ static int virtblk_restore(struct virtio_device *vdev)
         vblk->config_enable = true;
         ret = init_vq(vdev->priv);
         if (!ret)
-                blk_mq_start_stopped_hw_queues(vblk->disk->queue);
+                blk_mq_start_stopped_hw_queues(vblk->disk->queue, true);
 
         return ret;
 }
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index efe1b4761735..283a30e88287 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -612,10 +612,10 @@ static void do_blkif_request(struct request_queue *rq)
                 }
 
                 pr_debug("do_blk_req %p: cmd %p, sec %lx, "
-                         "(%u/%u) buffer:%p [%s]\n",
+                         "(%u/%u) [%s]\n",
                          req, req->cmd, (unsigned long)blk_rq_pos(req),
                          blk_rq_cur_sectors(req), blk_rq_sectors(req),
-                         req->buffer, rq_data_dir(req) ? "write" : "read");
+                         rq_data_dir(req) ? "write" : "read");
 
                 if (blkif_queue_request(req)) {
                         blk_requeue_request(rq, req);
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 1393b8871a28..ab3ea62e5dfc 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -661,7 +661,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         rq_data_dir(req));
 
                 ace->req = req;
-                ace->data_ptr = req->buffer;
+                ace->data_ptr = bio_data(req->bio);
                 ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR;
                 ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF);
 
@@ -733,7 +733,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                          *      blk_rq_sectors(ace->req),
                          *      blk_rq_cur_sectors(ace->req));
                          */
-                        ace->data_ptr = ace->req->buffer;
+                        ace->data_ptr = bio_data(ace->req->bio);
                         ace->data_count = blk_rq_cur_sectors(ace->req) * 16;
                         ace_fsm_yieldirq(ace);
                         break;
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 27de5046708a..968f9e52effa 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -87,13 +87,15 @@ static void do_z2_request(struct request_queue *q)
                 while (len) {
                         unsigned long addr = start & Z2RAM_CHUNKMASK;
                         unsigned long size = Z2RAM_CHUNKSIZE - addr;
+                        void *buffer = bio_data(req->bio);
+
                         if (len < size)
                                 size = len;
                         addr += z2ram_map[ start >> Z2RAM_CHUNKSHIFT ];
                         if (rq_data_dir(req) == READ)
-                                memcpy(req->buffer, (char *)addr, size);
+                                memcpy(buffer, (char *)addr, size);
                         else
-                                memcpy((char *)addr, req->buffer, size);
+                                memcpy((char *)addr, buffer, size);
                         start += size;
                         len -= size;
                 }