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

Pull core block IO update from Jens Axboe:
 "Nothing really major in here, mostly a collection of smaller
  optimizations and cleanups, mixed with various fixes.  In more detail,
  this contains:

   - Addition of policy specific data to blkcg for block cgroups.  From
     Arianna Avanzini.

   - Various cleanups around command types from Christoph.

   - Cleanup of the suspend block I/O path from Christoph.

   - Plugging updates from Shaohua and Jeff Moyer, for blk-mq.

   - Eliminating atomic inc/dec of both remaining IO count and reference
     count in a bio.  From me.

   - Fixes for SG gap and chunk size support for data-less (discards)
     IO, so we can merge these better.  From me.

   - Small restructuring of blk-mq shared tag support, freeing drivers
     from iterating hardware queues.  From Keith Busch.

   - A few cfq-iosched tweaks, from Tahsin Erdogan and me.  Makes the
     IOPS mode the default for non-rotational storage"

* 'for-4.2/core' of git://git.kernel.dk/linux-block: (35 commits)
  cfq-iosched: fix other locations where blkcg_to_cfqgd() can return NULL
  cfq-iosched: fix sysfs oops when attempting to read unconfigured weights
  cfq-iosched: move group scheduling functions under ifdef
  cfq-iosched: fix the setting of IOPS mode on SSDs
  blktrace: Add blktrace.c to BLOCK LAYER in MAINTAINERS file
  block, cgroup: implement policy-specific per-blkcg data
  block: Make CFQ default to IOPS mode on SSDs
  block: add blk_set_queue_dying() to blkdev.h
  blk-mq: Shared tag enhancements
  block: don't honor chunk sizes for data-less IO
  block: only honor SG gap prevention for merges that contain data
  block: fix returnvar.cocci warnings
  block, dm: don't copy bios for request clones
  block: remove management of bi_remaining when restoring original bi_end_io
  block: replace trylock with mutex_lock in blkdev_reread_part()
  block: export blkdev_reread_part() and __blkdev_reread_part()
  suspend: simplify block I/O handling
  block: collapse bio bit space
  block: remove unused BIO_RW_BLOCK and BIO_EOF flags
  block: remove BIO_EOPNOTSUPP
  ...

26 files changed, 170 insertions, 237 deletions

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 39e5f7fae3ef..83a7ba4a3eec 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -230,29 +230,40 @@ static int nbd_send_req(struct nbd_device *nbd, struct request *req)
         int result, flags;
         struct nbd_request request;
         unsigned long size = blk_rq_bytes(req);
+        u32 type;
+
+        if (req->cmd_type == REQ_TYPE_DRV_PRIV)
+                type = NBD_CMD_DISC;
+        else if (req->cmd_flags & REQ_DISCARD)
+                type = NBD_CMD_TRIM;
+        else if (req->cmd_flags & REQ_FLUSH)
+                type = NBD_CMD_FLUSH;
+        else if (rq_data_dir(req) == WRITE)
+                type = NBD_CMD_WRITE;
+        else
+                type = NBD_CMD_READ;
 
         memset(&request, 0, sizeof(request));
         request.magic = htonl(NBD_REQUEST_MAGIC);
-        request.type = htonl(nbd_cmd(req));
-
-        if (nbd_cmd(req) != NBD_CMD_FLUSH && nbd_cmd(req) != NBD_CMD_DISC) {
+        request.type = htonl(type);
+        if (type != NBD_CMD_FLUSH && type != NBD_CMD_DISC) {
                 request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
                 request.len = htonl(size);
         }
         memcpy(request.handle, &req, sizeof(req));
 
         dev_dbg(nbd_to_dev(nbd), "request %p: sending control (%s@%llu,%uB)\n",
-                req, nbdcmd_to_ascii(nbd_cmd(req)),
+                req, nbdcmd_to_ascii(type),
                 (unsigned long long)blk_rq_pos(req) << 9, blk_rq_bytes(req));
         result = sock_xmit(nbd, 1, &request, sizeof(request),
-                        (nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
+                        (type == NBD_CMD_WRITE) ? MSG_MORE : 0);
         if (result <= 0) {
                 dev_err(disk_to_dev(nbd->disk),
                         "Send control failed (result %d)\n", result);
                 return -EIO;
         }
 
-        if (nbd_cmd(req) == NBD_CMD_WRITE) {
+        if (type == NBD_CMD_WRITE) {
                 struct req_iterator iter;
                 struct bio_vec bvec;
                 /*
@@ -352,7 +363,7 @@ static struct request *nbd_read_stat(struct nbd_device *nbd)
         }
 
         dev_dbg(nbd_to_dev(nbd), "request %p: got reply\n", req);
-        if (nbd_cmd(req) == NBD_CMD_READ) {
+        if (rq_data_dir(req) != WRITE) {
                 struct req_iterator iter;
                 struct bio_vec bvec;
 
@@ -452,23 +463,11 @@ static void nbd_handle_req(struct nbd_device *nbd, struct request *req)
         if (req->cmd_type != REQ_TYPE_FS)
                 goto error_out;
 
-        nbd_cmd(req) = NBD_CMD_READ;
-        if (rq_data_dir(req) == WRITE) {
-                if ((req->cmd_flags & REQ_DISCARD)) {
-                        WARN_ON(!(nbd->flags & NBD_FLAG_SEND_TRIM));
-                        nbd_cmd(req) = NBD_CMD_TRIM;
-                } else
-                        nbd_cmd(req) = NBD_CMD_WRITE;
-                if (nbd->flags & NBD_FLAG_READ_ONLY) {
-                        dev_err(disk_to_dev(nbd->disk),
-                                "Write on read-only\n");
-                        goto error_out;
-                }
-        }
-
-        if (req->cmd_flags & REQ_FLUSH) {
-                BUG_ON(unlikely(blk_rq_sectors(req)));
-                nbd_cmd(req) = NBD_CMD_FLUSH;
+        if (rq_data_dir(req) == WRITE &&
+            (nbd->flags & NBD_FLAG_READ_ONLY)) {
+                dev_err(disk_to_dev(nbd->disk),
+                        "Write on read-only\n");
+                goto error_out;
         }
 
         req->errors = 0;
@@ -592,8 +591,7 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 fsync_bdev(bdev);
                 mutex_lock(&nbd->tx_lock);
                 blk_rq_init(NULL, &sreq);
-                sreq.cmd_type = REQ_TYPE_SPECIAL;
-                nbd_cmd(&sreq) = NBD_CMD_DISC;
+                sreq.cmd_type = REQ_TYPE_DRV_PRIV;
 
                 /* Check again after getting mutex back.  */
                 if (!nbd->sock)
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index d48715b287e6..dbb4da1cdca8 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -442,7 +442,7 @@ static char *pd_buf;		/* buffer for request in progress */
 
 static enum action do_pd_io_start(void)
 {
-        if (pd_req->cmd_type == REQ_TYPE_SPECIAL) {
+        if (pd_req->cmd_type == REQ_TYPE_DRV_PRIV) {
                 phase = pd_special;
                 return pd_special();
         }
@@ -725,7 +725,7 @@ static int pd_special_command(struct pd_unit *disk,
         if (IS_ERR(rq))
                 return PTR_ERR(rq);
 
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->special = func;
 
         err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 5d552857de41..59c91d49b14b 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -620,7 +620,7 @@ static int carm_array_info (struct carm_host *host, unsigned int array_idx)
         spin_unlock_irq(&host->lock);
 
         DPRINTK("blk_execute_rq_nowait, tag == %u\n", idx);
-        crq->rq->cmd_type = REQ_TYPE_SPECIAL;
+        crq->rq->cmd_type = REQ_TYPE_DRV_PRIV;
         crq->rq->special = crq;
         blk_execute_rq_nowait(host->oob_q, NULL, crq->rq, true, NULL);
 
@@ -661,7 +661,7 @@ static int carm_send_special (struct carm_host *host, carm_sspc_t func)
         crq->msg_bucket = (u32) rc;
 
         DPRINTK("blk_execute_rq_nowait, tag == %u\n", idx);
-        crq->rq->cmd_type = REQ_TYPE_SPECIAL;
+        crq->rq->cmd_type = REQ_TYPE_DRV_PRIV;
         crq->rq->special = crq;
         blk_execute_rq_nowait(host->oob_q, NULL, crq->rq, true, NULL);
 
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 5ea2f0bbbc7c..d4d05f064d39 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -124,7 +124,7 @@ static inline void virtblk_request_done(struct request *req)
                 req->resid_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.residual);
                 req->sense_len = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.sense_len);
                 req->errors = virtio32_to_cpu(vblk->vdev, vbr->in_hdr.errors);
-        } else if (req->cmd_type == REQ_TYPE_SPECIAL) {
+        } else if (req->cmd_type == REQ_TYPE_DRV_PRIV) {
                 req->errors = (error != 0);
         }
 
@@ -188,7 +188,7 @@ static int virtio_queue_rq(struct blk_mq_hw_ctx *hctx,
                         vbr->out_hdr.sector = 0;
                         vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
                         break;
-                case REQ_TYPE_SPECIAL:
+                case REQ_TYPE_DRV_PRIV:
                         vbr->out_hdr.type = cpu_to_virtio32(vblk->vdev, VIRTIO_BLK_T_GET_ID);
                         vbr->out_hdr.sector = 0;
                         vbr->out_hdr.ioprio = cpu_to_virtio32(vblk->vdev, req_get_ioprio(vbr->req));
@@ -251,7 +251,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
                 return PTR_ERR(req);
         }
 
-        req->cmd_type = REQ_TYPE_SPECIAL;
+        req->cmd_type = REQ_TYPE_DRV_PRIV;
         err = blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
         blk_put_request(req);
 
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index fac3d9da2e07..1362ad80a76c 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -93,7 +93,7 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
         int error;
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->special = (char *)pc;
 
         if (buf && bufflen) {
@@ -191,7 +191,7 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
 
         BUG_ON(sense_len > sizeof(*sense));
 
-        if (rq->cmd_type == REQ_TYPE_SENSE || drive->sense_rq_armed)
+        if (rq->cmd_type == REQ_TYPE_ATA_SENSE || drive->sense_rq_armed)
                 return;
 
         memset(sense, 0, sizeof(*sense));
@@ -210,7 +210,7 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
         sense_rq->rq_disk = rq->rq_disk;
         sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
         sense_rq->cmd[4] = cmd_len;
-        sense_rq->cmd_type = REQ_TYPE_SENSE;
+        sense_rq->cmd_type = REQ_TYPE_ATA_SENSE;
         sense_rq->cmd_flags |= REQ_PREEMPT;
 
         if (drive->media == ide_tape)
@@ -310,7 +310,7 @@ int ide_cd_get_xferlen(struct request *rq)
         switch (rq->cmd_type) {
         case REQ_TYPE_FS:
                 return 32768;
-        case REQ_TYPE_SENSE:
+        case REQ_TYPE_ATA_SENSE:
         case REQ_TYPE_BLOCK_PC:
         case REQ_TYPE_ATA_PC:
                 return blk_rq_bytes(rq);
@@ -477,7 +477,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                 if (uptodate == 0)
                         drive->failed_pc = NULL;
 
-                if (rq->cmd_type == REQ_TYPE_SPECIAL) {
+                if (rq->cmd_type == REQ_TYPE_DRV_PRIV) {
                         rq->errors = 0;
                         error = 0;
                 } else {
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 0b510bafd90e..64a6b827b3dd 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -210,7 +210,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
 static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq)
 {
         /*
-         * For REQ_TYPE_SENSE, "rq->special" points to the original
+         * For REQ_TYPE_ATA_SENSE, "rq->special" points to the original
          * failed request.  Also, the sense data should be read
          * directly from rq which might be different from the original
          * sense buffer if it got copied during mapping.
@@ -285,7 +285,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
                                   "stat 0x%x",
                                   rq->cmd[0], rq->cmd_type, err, stat);
 
-        if (rq->cmd_type == REQ_TYPE_SENSE) {
+        if (rq->cmd_type == REQ_TYPE_ATA_SENSE) {
                 /*
                  * We got an error trying to get sense info from the drive
                  * (probably while trying to recover from a former error).
@@ -526,7 +526,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         ide_expiry_t *expiry = NULL;
         int dma_error = 0, dma, thislen, uptodate = 0;
         int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc = 0;
-        int sense = (rq->cmd_type == REQ_TYPE_SENSE);
+        int sense = (rq->cmd_type == REQ_TYPE_ATA_SENSE);
         unsigned int timeout;
         u16 len;
         u8 ireason, stat;
@@ -791,7 +791,7 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                 if (cdrom_start_rw(drive, rq) == ide_stopped)
                         goto out_end;
                 break;
-        case REQ_TYPE_SENSE:
+        case REQ_TYPE_ATA_SENSE:
         case REQ_TYPE_BLOCK_PC:
         case REQ_TYPE_ATA_PC:
                 if (!rq->timeout)
@@ -799,7 +799,7 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
 
                 cdrom_do_block_pc(drive, rq);
                 break;
-        case REQ_TYPE_SPECIAL:
+        case REQ_TYPE_DRV_PRIV:
                 /* right now this can only be a reset... */
                 uptodate = 1;
                 goto out_end;
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index 02caa7dd51c8..066e39036518 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -304,7 +304,7 @@ int ide_cdrom_reset(struct cdrom_device_info *cdi)
         int ret;
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->cmd_flags = REQ_QUIET;
         ret = blk_execute_rq(drive->queue, cd->disk, rq, 0);
         blk_put_request(rq);
diff --git a/drivers/ide/ide-devsets.c b/drivers/ide/ide-devsets.c
index 9e98122f646e..b05a74d78ef5 100644
--- a/drivers/ide/ide-devsets.c
+++ b/drivers/ide/ide-devsets.c
@@ -166,7 +166,7 @@ int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
                 return setting->set(drive, arg);
 
         rq = blk_get_request(q, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->cmd_len = 5;
         rq->cmd[0] = REQ_DEVSET_EXEC;
         *(int *)&rq->cmd[1] = arg;
diff --git a/drivers/ide/ide-eh.c b/drivers/ide/ide-eh.c
index 32970664c275..d6da011299f5 100644
--- a/drivers/ide/ide-eh.c
+++ b/drivers/ide/ide-eh.c
@@ -129,7 +129,7 @@ ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, u8 stat)
 
                         if (cmd)
                                 ide_complete_cmd(drive, cmd, stat, err);
-                } else if (blk_pm_request(rq)) {
+                } else if (ata_pm_request(rq)) {
                         rq->errors = 1;
                         ide_complete_pm_rq(drive, rq);
                         return ide_stopped;
@@ -147,7 +147,7 @@ static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
 {
         struct request *rq = drive->hwif->rq;
 
-        if (rq && rq->cmd_type == REQ_TYPE_SPECIAL &&
+        if (rq && rq->cmd_type == REQ_TYPE_DRV_PRIV &&
             rq->cmd[0] == REQ_DRIVE_RESET) {
                 if (err <= 0 && rq->errors == 0)
                         rq->errors = -EIO;
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 8c6363cdd208..2fb5350c5410 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -97,7 +97,7 @@ static int ide_floppy_callback(ide_drive_t *drive, int dsc)
                                "Aborting request!\n");
         }
 
-        if (rq->cmd_type == REQ_TYPE_SPECIAL)
+        if (rq->cmd_type == REQ_TYPE_DRV_PRIV)
                 rq->errors = uptodate ? 0 : IDE_DRV_ERROR_GENERAL;
 
         return uptodate;
@@ -246,7 +246,7 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                 } else
                         printk(KERN_ERR PFX "%s: I/O error\n", drive->name);
 
-                if (rq->cmd_type == REQ_TYPE_SPECIAL) {
+                if (rq->cmd_type == REQ_TYPE_DRV_PRIV) {
                         rq->errors = 0;
                         ide_complete_rq(drive, 0, blk_rq_bytes(rq));
                         return ide_stopped;
@@ -265,8 +265,8 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                 pc = &floppy->queued_pc;
                 idefloppy_create_rw_cmd(drive, pc, rq, (unsigned long)block);
                 break;
-        case REQ_TYPE_SPECIAL:
-        case REQ_TYPE_SENSE:
+        case REQ_TYPE_DRV_PRIV:
+        case REQ_TYPE_ATA_SENSE:
                 pc = (struct ide_atapi_pc *)rq->special;
                 break;
         case REQ_TYPE_BLOCK_PC:
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 177db6d5b2f5..669ea1e45795 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -135,7 +135,7 @@ EXPORT_SYMBOL(ide_complete_rq);
 
 void ide_kill_rq(ide_drive_t *drive, struct request *rq)
 {
-        u8 drv_req = (rq->cmd_type == REQ_TYPE_SPECIAL) && rq->rq_disk;
+        u8 drv_req = (rq->cmd_type == REQ_TYPE_DRV_PRIV) && rq->rq_disk;
         u8 media = drive->media;
 
         drive->failed_pc = NULL;
@@ -320,7 +320,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                 goto kill_rq;
         }
 
-        if (blk_pm_request(rq))
+        if (ata_pm_request(rq))
                 ide_check_pm_state(drive, rq);
 
         drive->hwif->tp_ops->dev_select(drive);
@@ -342,8 +342,8 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
 
                 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
                         return execute_drive_cmd(drive, rq);
-                else if (blk_pm_request(rq)) {
-                        struct request_pm_state *pm = rq->special;
+                else if (ata_pm_request(rq)) {
+                        struct ide_pm_state *pm = rq->special;
 #ifdef DEBUG_PM
                         printk("%s: start_power_step(step: %d)\n",
                                 drive->name, pm->pm_step);
@@ -353,7 +353,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                             pm->pm_step == IDE_PM_COMPLETED)
                                 ide_complete_pm_rq(drive, rq);
                         return startstop;
-                } else if (!rq->rq_disk && rq->cmd_type == REQ_TYPE_SPECIAL)
+                } else if (!rq->rq_disk && rq->cmd_type == REQ_TYPE_DRV_PRIV)
                         /*
                          * TODO: Once all ULDs have been modified to
                          * check for specific op codes rather than
@@ -538,7 +538,7 @@ repeat:
                  * state machine.
                  */
                 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
-                    blk_pm_request(rq) == 0 &&
+                    ata_pm_request(rq) == 0 &&
                     (rq->cmd_flags & REQ_PREEMPT) == 0) {
                         /* there should be no pending command at this point */
                         ide_unlock_port(hwif);
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index 6233fa2cb8a9..aa2e9b77b20d 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -222,7 +222,7 @@ static int generic_drive_reset(ide_drive_t *drive)
         int ret = 0;
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->cmd_len = 1;
         rq->cmd[0] = REQ_DRIVE_RESET;
         if (blk_execute_rq(drive->queue, NULL, rq, 1))
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index ca958604cda2..c80868520488 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -34,7 +34,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
         rq = blk_get_request(q, READ, __GFP_WAIT);
         rq->cmd[0] = REQ_PARK_HEADS;
         rq->cmd_len = 1;
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->special = &timeout;
         rc = blk_execute_rq(q, NULL, rq, 1);
         blk_put_request(rq);
@@ -51,7 +51,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
 
         rq->cmd[0] = REQ_UNPARK_HEADS;
         rq->cmd_len = 1;
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         elv_add_request(q, rq, ELEVATOR_INSERT_FRONT);
 
 out:
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index 8d1e32d7cd97..081e43458d50 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -8,7 +8,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         ide_drive_t *pair = ide_get_pair_dev(drive);
         ide_hwif_t *hwif = drive->hwif;
         struct request *rq;
-        struct request_pm_state rqpm;
+        struct ide_pm_state rqpm;
         int ret;
 
         if (ide_port_acpi(hwif)) {
@@ -19,7 +19,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
 
         memset(&rqpm, 0, sizeof(rqpm));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_PM_SUSPEND;
+        rq->cmd_type = REQ_TYPE_ATA_PM_SUSPEND;
         rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_SUSPEND;
         if (mesg.event == PM_EVENT_PRETHAW)
@@ -38,13 +38,43 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         return ret;
 }
 
+static void ide_end_sync_rq(struct request *rq, int error)
+{
+        complete(rq->end_io_data);
+}
+
+static int ide_pm_execute_rq(struct request *rq)
+{
+        struct request_queue *q = rq->q;
+        DECLARE_COMPLETION_ONSTACK(wait);
+
+        rq->end_io_data = &wait;
+        rq->end_io = ide_end_sync_rq;
+
+        spin_lock_irq(q->queue_lock);
+        if (unlikely(blk_queue_dying(q))) {
+                rq->cmd_flags |= REQ_QUIET;
+                rq->errors = -ENXIO;
+                __blk_end_request_all(rq, rq->errors);
+                spin_unlock_irq(q->queue_lock);
+                return -ENXIO;
+        }
+        __elv_add_request(q, rq, ELEVATOR_INSERT_FRONT);
+        __blk_run_queue_uncond(q);
+        spin_unlock_irq(q->queue_lock);
+
+        wait_for_completion_io(&wait);
+
+        return rq->errors ? -EIO : 0;
+}
+
 int generic_ide_resume(struct device *dev)
 {
         ide_drive_t *drive = to_ide_device(dev);
         ide_drive_t *pair = ide_get_pair_dev(drive);
         ide_hwif_t *hwif = drive->hwif;
         struct request *rq;
-        struct request_pm_state rqpm;
+        struct ide_pm_state rqpm;
         int err;
 
         if (ide_port_acpi(hwif)) {
@@ -59,13 +89,13 @@ int generic_ide_resume(struct device *dev)
 
         memset(&rqpm, 0, sizeof(rqpm));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_PM_RESUME;
+        rq->cmd_type = REQ_TYPE_ATA_PM_RESUME;
         rq->cmd_flags |= REQ_PREEMPT;
         rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_RESUME;
         rqpm.pm_state = PM_EVENT_ON;
 
-        err = blk_execute_rq(drive->queue, NULL, rq, 1);
+        err = ide_pm_execute_rq(rq);
         blk_put_request(rq);
 
         if (err == 0 && dev->driver) {
@@ -80,7 +110,7 @@ int generic_ide_resume(struct device *dev)
 
 void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->special;
+        struct ide_pm_state *pm = rq->special;
 
 #ifdef DEBUG_PM
         printk(KERN_INFO "%s: complete_power_step(step: %d)\n",
@@ -110,7 +140,7 @@ void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 
 ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->special;
+        struct ide_pm_state *pm = rq->special;
         struct ide_cmd cmd = { };
 
         switch (pm->pm_step) {
@@ -182,7 +212,7 @@ out_do_tf:
 void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 {
         struct request_queue *q = drive->queue;
-        struct request_pm_state *pm = rq->special;
+        struct ide_pm_state *pm = rq->special;
         unsigned long flags;
 
         ide_complete_power_step(drive, rq);
@@ -191,10 +221,10 @@ void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 
 #ifdef DEBUG_PM
         printk("%s: completing PM request, %s\n", drive->name,
-               (rq->cmd_type == REQ_TYPE_PM_SUSPEND) ? "suspend" : "resume");
+               (rq->cmd_type == REQ_TYPE_ATA_PM_SUSPEND) ? "suspend" : "resume");
 #endif
         spin_lock_irqsave(q->queue_lock, flags);
-        if (rq->cmd_type == REQ_TYPE_PM_SUSPEND)
+        if (rq->cmd_type == REQ_TYPE_ATA_PM_SUSPEND)
                 blk_stop_queue(q);
         else
                 drive->dev_flags &= ~IDE_DFLAG_BLOCKED;
@@ -208,13 +238,13 @@ void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 
 void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->special;
+        struct ide_pm_state *pm = rq->special;
 
-        if (rq->cmd_type == REQ_TYPE_PM_SUSPEND &&
+        if (rq->cmd_type == REQ_TYPE_ATA_PM_SUSPEND &&
             pm->pm_step == IDE_PM_START_SUSPEND)
                 /* Mark drive blocked when starting the suspend sequence. */
                 drive->dev_flags |= IDE_DFLAG_BLOCKED;
-        else if (rq->cmd_type == REQ_TYPE_PM_RESUME &&
+        else if (rq->cmd_type == REQ_TYPE_ATA_PM_RESUME &&
                  pm->pm_step == IDE_PM_START_RESUME) {
                 /*
                  * The first thing we do on wakeup is to wait for BSY bit to
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 6eb738ca6d2f..f5d51d1d09ee 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -576,8 +576,8 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                       rq->cmd[0], (unsigned long long)blk_rq_pos(rq),
                       blk_rq_sectors(rq));
 
-        BUG_ON(!(rq->cmd_type == REQ_TYPE_SPECIAL ||
-                 rq->cmd_type == REQ_TYPE_SENSE));
+        BUG_ON(!(rq->cmd_type == REQ_TYPE_DRV_PRIV ||
+                 rq->cmd_type == REQ_TYPE_ATA_SENSE));
 
         /* Retry a failed packet command */
         if (drive->failed_pc && drive->pc->c[0] == REQUEST_SENSE) {
@@ -853,7 +853,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
         BUG_ON(size < 0 || size % tape->blk_size);
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
+        rq->cmd_type = REQ_TYPE_DRV_PRIV;
         rq->cmd[13] = cmd;
         rq->rq_disk = tape->disk;
         rq->__sector = tape->first_frame;
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index dabb88b1cbec..0979e126fff1 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -186,7 +186,7 @@ static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
             tf->command == ATA_CMD_CHK_POWER) {
                 struct request *rq = hwif->rq;
 
-                if (blk_pm_request(rq))
+                if (ata_pm_request(rq))
                         ide_complete_pm_rq(drive, rq);
                 else
                         ide_finish_cmd(drive, cmd, stat);
diff --git a/drivers/md/bcache/io.c b/drivers/md/bcache/io.c
index fa028fa82df4..cb64e64a4789 100644
--- a/drivers/md/bcache/io.c
+++ b/drivers/md/bcache/io.c
@@ -55,7 +55,7 @@ static void bch_bio_submit_split_done(struct closure *cl)
 
         s->bio->bi_end_io = s->bi_end_io;
         s->bio->bi_private = s->bi_private;
-        bio_endio_nodec(s->bio, 0);
+        bio_endio(s->bio, 0);
 
         closure_debug_destroy(&s->cl);
         mempool_free(s, s->p->bio_split_hook);
diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c
index ab43faddb447..1616f668a4cb 100644
--- a/drivers/md/bcache/request.c
+++ b/drivers/md/bcache/request.c
@@ -619,7 +619,7 @@ static void do_bio_hook(struct search *s, struct bio *orig_bio)
         bio->bi_end_io          = request_endio;
         bio->bi_private         = &s->cl;
 
-        atomic_set(&bio->bi_cnt, 3);
+        bio_cnt_set(bio, 3);
 }
 
 static void search_free(struct closure *cl)
diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 7755af351867..41b2594a80c6 100644
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -86,12 +86,6 @@ static void dm_unhook_bio(struct dm_hook_info *h, struct bio *bio)
 {
         bio->bi_end_io = h->bi_end_io;
         bio->bi_private = h->bi_private;
-
-        /*
-         * Must bump bi_remaining to allow bio to complete with
-         * restored bi_end_io.
-         */
-        atomic_inc(&bio->bi_remaining);
 }
 
 /*----------------------------------------------------------------*/
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 089d62751f7f..743fa9bbae9e 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -1254,8 +1254,6 @@ static int mirror_end_io(struct dm_target *ti, struct bio *bio, int error)
                         dm_bio_restore(bd, bio);
                         bio_record->details.bi_bdev = NULL;
 
-                        atomic_inc(&bio->bi_remaining);
-
                         queue_bio(ms, bio, rw);
                         return DM_ENDIO_INCOMPLETE;
                 }
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index f83a0f3fc365..7c82d3ccce87 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -1478,7 +1478,6 @@ out:
         if (full_bio) {
                 full_bio->bi_end_io = pe->full_bio_end_io;
                 full_bio->bi_private = pe->full_bio_private;
-                atomic_inc(&full_bio->bi_remaining);
         }
         increment_pending_exceptions_done_count();
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 16ba55ad7089..a5f94125ad01 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -942,21 +942,28 @@ static int dm_table_alloc_md_mempools(struct dm_table *t, struct mapped_device *
 {
         unsigned type = dm_table_get_type(t);
         unsigned per_bio_data_size = 0;
-        struct dm_target *tgt;
         unsigned i;
 
-        if (unlikely(type == DM_TYPE_NONE)) {
+        switch (type) {
+        case DM_TYPE_BIO_BASED:
+                for (i = 0; i < t->num_targets; i++) {
+                        struct dm_target *tgt = t->targets + i;
+
+                        per_bio_data_size = max(per_bio_data_size,
+                                                tgt->per_bio_data_size);
+                }
+                t->mempools = dm_alloc_bio_mempools(t->integrity_supported,
+                                                    per_bio_data_size);
+                break;
+        case DM_TYPE_REQUEST_BASED:
+        case DM_TYPE_MQ_REQUEST_BASED:
+                t->mempools = dm_alloc_rq_mempools(md, type);
+                break;
+        default:
                 DMWARN("no table type is set, can't allocate mempools");
                 return -EINVAL;
         }
 
-        if (type == DM_TYPE_BIO_BASED)
-                for (i = 0; i < t->num_targets; i++) {
-                        tgt = t->targets + i;
-                        per_bio_data_size = max(per_bio_data_size, tgt->per_bio_data_size);
-                }
-
-        t->mempools = dm_alloc_md_mempools(md, type, t->integrity_supported, per_bio_data_size);
         if (!t->mempools)
                 return -ENOMEM;
 
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 921aafd12aee..e852602c0091 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -793,10 +793,9 @@ static void inc_remap_and_issue_cell(struct thin_c *tc,
 
 static void process_prepared_mapping_fail(struct dm_thin_new_mapping *m)
 {
-        if (m->bio) {
+        if (m->bio)
                 m->bio->bi_end_io = m->saved_bi_end_io;
-                atomic_inc(&m->bio->bi_remaining);
-        }
+
         cell_error(m->tc->pool, m->cell);
         list_del(&m->list);
         mempool_free(m, m->tc->pool->mapping_pool);
@@ -810,10 +809,8 @@ static void process_prepared_mapping(struct dm_thin_new_mapping *m)
         int r;
 
         bio = m->bio;
-        if (bio) {
+        if (bio)
                 bio->bi_end_io = m->saved_bi_end_io;
-                atomic_inc(&bio->bi_remaining);
-        }
 
         if (m->err) {
                 cell_error(pool, m->cell);
diff --git a/drivers/md/dm-verity.c b/drivers/md/dm-verity.c
index 66616db33e6f..bb9c6a00e4b0 100644
--- a/drivers/md/dm-verity.c
+++ b/drivers/md/dm-verity.c
@@ -459,7 +459,7 @@ static void verity_finish_io(struct dm_verity_io *io, int error)
         bio->bi_end_io = io->orig_bi_end_io;
         bio->bi_private = io->orig_bi_private;
 
-        bio_endio_nodec(bio, error);
+        bio_endio(bio, error);
 }
 
 static void verity_work(struct work_struct *w)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 2caf492890d6..4d6f089a0e9e 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -990,57 +990,6 @@ static void clone_endio(struct bio *bio, int error)
         dec_pending(io, error);
 }
 
-/*
- * Partial completion handling for request-based dm
- */
-static void end_clone_bio(struct bio *clone, int error)
-{
-        struct dm_rq_clone_bio_info *info =
-                container_of(clone, struct dm_rq_clone_bio_info, clone);
-        struct dm_rq_target_io *tio = info->tio;
-        struct bio *bio = info->orig;
-        unsigned int nr_bytes = info->orig->bi_iter.bi_size;
-
-        bio_put(clone);
-
-        if (tio->error)
-                /*
-                 * An error has already been detected on the request.
-                 * Once error occurred, just let clone->end_io() handle
-                 * the remainder.
-                 */
-                return;
-        else if (error) {
-                /*
-                 * Don't notice the error to the upper layer yet.
-                 * The error handling decision is made by the target driver,
-                 * when the request is completed.
-                 */
-                tio->error = error;
-                return;
-        }
-
-        /*
-         * I/O for the bio successfully completed.
-         * Notice the data completion to the upper layer.
-         */
-
-        /*
-         * bios are processed from the head of the list.
-         * So the completing bio should always be rq->bio.
-         * If it's not, something wrong is happening.
-         */
-        if (tio->orig->bio != bio)
-                DMERR("bio completion is going in the middle of the request");
-
-        /*
-         * Update the original request.
-         * Do not use blk_end_request() here, because it may complete
-         * the original request before the clone, and break the ordering.
-         */
-        blk_update_request(tio->orig, 0, nr_bytes);
-}
-
 static struct dm_rq_target_io *tio_from_request(struct request *rq)
 {
         return (rq->q->mq_ops ? blk_mq_rq_to_pdu(rq) : rq->special);
@@ -1087,8 +1036,6 @@ static void free_rq_clone(struct request *clone)
         struct dm_rq_target_io *tio = clone->end_io_data;
         struct mapped_device *md = tio->md;
 
-        blk_rq_unprep_clone(clone);
-
         if (md->type == DM_TYPE_MQ_REQUEST_BASED)
                 /* stacked on blk-mq queue(s) */
                 tio->ti->type->release_clone_rq(clone);
@@ -1827,39 +1774,13 @@ static void dm_dispatch_clone_request(struct request *clone, struct request *rq)
                 dm_complete_request(rq, r);
 }
 
-static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
-                                 void *data)
+static void setup_clone(struct request *clone, struct request *rq,
+                        struct dm_rq_target_io *tio)
 {
-        struct dm_rq_target_io *tio = data;
-        struct dm_rq_clone_bio_info *info =
-                container_of(bio, struct dm_rq_clone_bio_info, clone);
-
-        info->orig = bio_orig;
-        info->tio = tio;
-        bio->bi_end_io = end_clone_bio;
-
-        return 0;
-}
-
-static int setup_clone(struct request *clone, struct request *rq,
-                       struct dm_rq_target_io *tio, gfp_t gfp_mask)
-{
-        int r;
-
-        r = blk_rq_prep_clone(clone, rq, tio->md->bs, gfp_mask,
-                              dm_rq_bio_constructor, tio);
-        if (r)
-                return r;
-
-        clone->cmd = rq->cmd;
-        clone->cmd_len = rq->cmd_len;
-        clone->sense = rq->sense;
+        blk_rq_prep_clone(clone, rq);
         clone->end_io = end_clone_request;
         clone->end_io_data = tio;
-
         tio->clone = clone;
-
-        return 0;
 }
 
 static struct request *clone_rq(struct request *rq, struct mapped_device *md,
@@ -1880,12 +1801,7 @@ static struct request *clone_rq(struct request *rq, struct mapped_device *md,
                 clone = tio->clone;
 
         blk_rq_init(NULL, clone);
-        if (setup_clone(clone, rq, tio, gfp_mask)) {
-                /* -ENOMEM */
-                if (alloc_clone)
-                        free_clone_request(md, clone);
-                return NULL;
-        }
+        setup_clone(clone, rq, tio);
 
         return clone;
 }
@@ -1979,11 +1895,7 @@ static int map_request(struct dm_rq_target_io *tio, struct request *rq,
                 }
                 if (r != DM_MAPIO_REMAPPED)
                         return r;
-                if (setup_clone(clone, rq, tio, GFP_ATOMIC)) {
-                        /* -ENOMEM */
-                        ti->type->release_clone_rq(clone);
-                        return DM_MAPIO_REQUEUE;
-                }
+                setup_clone(clone, rq, tio);
         }
 
         switch (r) {
@@ -2437,8 +2349,6 @@ static void __bind_mempools(struct mapped_device *md, struct dm_table *t)
                 goto out;
         }
 
-        BUG_ON(!p || md->io_pool || md->rq_pool || md->bs);
-
         md->io_pool = p->io_pool;
         p->io_pool = NULL;
         md->rq_pool = p->rq_pool;
@@ -3544,48 +3454,23 @@ int dm_noflush_suspending(struct dm_target *ti)
 }
 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
 
-struct dm_md_mempools *dm_alloc_md_mempools(struct mapped_device *md, unsigned type,
-                                            unsigned integrity, unsigned per_bio_data_size)
+struct dm_md_mempools *dm_alloc_bio_mempools(unsigned integrity,
+                                             unsigned per_bio_data_size)
 {
-        struct dm_md_mempools *pools = kzalloc(sizeof(*pools), GFP_KERNEL);
-        struct kmem_cache *cachep = NULL;
-        unsigned int pool_size = 0;
+        struct dm_md_mempools *pools;
+        unsigned int pool_size = dm_get_reserved_bio_based_ios();
         unsigned int front_pad;
 
+        pools = kzalloc(sizeof(*pools), GFP_KERNEL);
         if (!pools)
                 return NULL;
 
-        type = filter_md_type(type, md);
+        front_pad = roundup(per_bio_data_size, __alignof__(struct dm_target_io)) +
+                offsetof(struct dm_target_io, clone);
 
-        switch (type) {
-        case DM_TYPE_BIO_BASED:
-                cachep = _io_cache;
-                pool_size = dm_get_reserved_bio_based_ios();
-                front_pad = roundup(per_bio_data_size, __alignof__(struct dm_target_io)) + offsetof(struct dm_target_io, clone);
-                break;
-        case DM_TYPE_REQUEST_BASED:
-                cachep = _rq_tio_cache;
-                pool_size = dm_get_reserved_rq_based_ios();
-                pools->rq_pool = mempool_create_slab_pool(pool_size, _rq_cache);
-                if (!pools->rq_pool)
-                        goto out;
-                /* fall through to setup remaining rq-based pools */
-        case DM_TYPE_MQ_REQUEST_BASED:
-                if (!pool_size)
-                        pool_size = dm_get_reserved_rq_based_ios();
-                front_pad = offsetof(struct dm_rq_clone_bio_info, clone);
-                /* per_bio_data_size is not used. See __bind_mempools(). */
-                WARN_ON(per_bio_data_size != 0);
-                break;
-        default:
-                BUG();
-        }
-
-        if (cachep) {
-                pools->io_pool = mempool_create_slab_pool(pool_size, cachep);
-                if (!pools->io_pool)
-                        goto out;
-        }
+        pools->io_pool = mempool_create_slab_pool(pool_size, _io_cache);
+        if (!pools->io_pool)
+                goto out;
 
         pools->bs = bioset_create_nobvec(pool_size, front_pad);
         if (!pools->bs)
@@ -3595,10 +3480,34 @@ struct dm_md_mempools *dm_alloc_md_mempools(struct mapped_device *md, unsigned t
                 goto out;
 
         return pools;
-
 out:
         dm_free_md_mempools(pools);
+        return NULL;
+}
+
+struct dm_md_mempools *dm_alloc_rq_mempools(struct mapped_device *md,
+                                            unsigned type)
+{
+        unsigned int pool_size = dm_get_reserved_rq_based_ios();
+        struct dm_md_mempools *pools;
+
+        pools = kzalloc(sizeof(*pools), GFP_KERNEL);
+        if (!pools)
+                return NULL;
+
+        if (filter_md_type(type, md) == DM_TYPE_REQUEST_BASED) {
+                pools->rq_pool = mempool_create_slab_pool(pool_size, _rq_cache);
+                if (!pools->rq_pool)
+                        goto out;
+        }
 
+        pools->io_pool = mempool_create_slab_pool(pool_size, _rq_tio_cache);
+        if (!pools->io_pool)
+                goto out;
+
+        return pools;
+out:
+        dm_free_md_mempools(pools);
         return NULL;
 }
 
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 6123c2bf9150..e6e66d087b26 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -222,8 +222,9 @@ void dm_kcopyd_exit(void);
 /*
  * Mempool operations
  */
-struct dm_md_mempools *dm_alloc_md_mempools(struct mapped_device *md, unsigned type,
-                                            unsigned integrity, unsigned per_bio_data_size);
+struct dm_md_mempools *dm_alloc_bio_mempools(unsigned integrity,
+                                             unsigned per_bio_data_size);
+struct dm_md_mempools *dm_alloc_rq_mempools(struct mapped_device *md, unsigned type);
 void dm_free_md_mempools(struct dm_md_mempools *pools);
 
 /*