list_del_init(&rq->flush.list);
                blk_flush_restore_request(rq);
                if (q->mq_ops)
-                       blk_mq_end_io(rq, error);
+                       blk_mq_end_request(rq, error);
                else
                        __blk_end_request_all(rq, error);
                break;
         */
        if (!policy) {
                if (q->mq_ops)
-                       blk_mq_end_io(rq, 0);
+                       blk_mq_end_request(rq, 0);
                else
                        __blk_end_bidi_request(rq, 0, 0, 0);
                return;
 
                hctx->cmd_size);
 }
 
-inline void __blk_mq_end_io(struct request *rq, int error)
+inline void __blk_mq_end_request(struct request *rq, int error)
 {
        blk_account_io_done(rq);
 
                blk_mq_free_request(rq);
        }
 }
-EXPORT_SYMBOL(__blk_mq_end_io);
+EXPORT_SYMBOL(__blk_mq_end_request);
 
-void blk_mq_end_io(struct request *rq, int error)
+void blk_mq_end_request(struct request *rq, int error)
 {
        if (blk_update_request(rq, error, blk_rq_bytes(rq)))
                BUG();
-       __blk_mq_end_io(rq, error);
+       __blk_mq_end_request(rq, error);
 }
-EXPORT_SYMBOL(blk_mq_end_io);
+EXPORT_SYMBOL(blk_mq_end_request);
 
 static void __blk_mq_complete_request_remote(void *data)
 {
        struct request_queue *q = rq->q;
 
        if (!q->softirq_done_fn)
-               blk_mq_end_io(rq, rq->errors);
+               blk_mq_end_request(rq, rq->errors);
        else
                blk_mq_ipi_complete_request(rq);
 }
                        pr_err("blk-mq: bad return on queue: %d\n", ret);
                case BLK_MQ_RQ_QUEUE_ERROR:
                        rq->errors = -EIO;
-                       blk_mq_end_io(rq, rq->errors);
+                       blk_mq_end_request(rq, rq->errors);
                        break;
                }
 
 
                        if (ret == BLK_MQ_RQ_QUEUE_ERROR) {
                                rq->errors = -EIO;
-                               blk_mq_end_io(rq, rq->errors);
+                               blk_mq_end_request(rq, rq->errors);
                                goto done;
                        }
                }
 
        if (unlikely(cmd->unaligned))
                up(&port->cmd_slot_unal);
 
-       blk_mq_end_io(rq, status ? -EIO : 0);
+       blk_mq_end_request(rq, status ? -EIO : 0);
 }
 
 /*
                int err;
 
                err = mtip_send_trim(dd, blk_rq_pos(rq), blk_rq_sectors(rq));
-               blk_mq_end_io(rq, err);
+               blk_mq_end_request(rq, err);
                return 0;
        }
 
 
 {
        switch (queue_mode)  {
        case NULL_Q_MQ:
-               blk_mq_end_io(cmd->rq, 0);
+               blk_mq_end_request(cmd->rq, 0);
                return;
        case NULL_Q_RQ:
                INIT_LIST_HEAD(&cmd->rq->queuelist);
 
                req->errors = (error != 0);
        }
 
-       blk_mq_end_io(req, error);
+       blk_mq_end_request(req, error);
 }
 
 static void virtblk_done(struct virtqueue *vq)
 
 
        if (req->mq_ctx) {
                /*
-                * In the MQ case the command gets freed by __blk_mq_end_io,
+                * In the MQ case the command gets freed by __blk_mq_end_request,
                 * so we have to do all cleanup that depends on it earlier.
                 *
                 * We also can't kick the queues from irq context, so we
                 */
                scsi_mq_uninit_cmd(cmd);
 
-               __blk_mq_end_io(req, error);
+               __blk_mq_end_request(req, error);
 
                if (scsi_target(sdev)->single_lun ||
                    !list_empty(&sdev->host->starved_list))
 
 struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int, int);
 
 void blk_mq_start_request(struct request *rq);
-void blk_mq_end_io(struct request *rq, int error);
-void __blk_mq_end_io(struct request *rq, int error);
+void blk_mq_end_request(struct request *rq, int error);
+void __blk_mq_end_request(struct request *rq, int error);
 
 void blk_mq_requeue_request(struct request *rq);
 void blk_mq_add_to_requeue_list(struct request *rq, bool at_head);