* e.g. due to a concurrent blk_mq_finish_request() call. Returns true to
  * keep iterating requests.
  */
-static bool hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
+static bool hctx_show_busy_rq(struct request *rq, void *data)
 {
        const struct show_busy_params *params = data;
 
 
                return true;
 
        if (rq->q == q && (!hctx || rq->mq_hctx == hctx))
-               ret = iter_data->fn(rq, iter_data->data, reserved);
+               ret = iter_data->fn(rq, iter_data->data);
        blk_mq_put_rq_ref(rq);
        return ret;
 }
 
        if (!(iter_data->flags & BT_TAG_ITER_STARTED) ||
            blk_mq_request_started(rq))
-               ret = iter_data->fn(rq, iter_data->data, reserved);
+               ret = iter_data->fn(rq, iter_data->data);
        if (!iter_static_rqs)
                blk_mq_put_rq_ref(rq);
        return ret;
 }
 EXPORT_SYMBOL(blk_mq_tagset_busy_iter);
 
-static bool blk_mq_tagset_count_completed_rqs(struct request *rq,
-               void *data, bool reserved)
+static bool blk_mq_tagset_count_completed_rqs(struct request *rq, void *data)
 {
        unsigned *count = data;
 
 
        unsigned int inflight[2];
 };
 
-static bool blk_mq_check_inflight(struct request *rq, void *priv,
-                                 bool reserved)
+static bool blk_mq_check_inflight(struct request *rq, void *priv)
 {
        struct mq_inflight *mi = priv;
 
 }
 EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);
 
-static bool blk_mq_rq_inflight(struct request *rq, void *priv,
-                              bool reserved)
+static bool blk_mq_rq_inflight(struct request *rq, void *priv)
 {
        /*
         * If we find a request that isn't idle we know the queue is busy
                __blk_mq_free_request(rq);
 }
 
-static bool blk_mq_check_expired(struct request *rq, void *priv, bool reserved)
+static bool blk_mq_check_expired(struct request *rq, void *priv)
 {
        unsigned long *next = priv;
 
        bool has_rq;
 };
 
-static bool blk_mq_has_request(struct request *rq, void *data, bool reserved)
+static bool blk_mq_has_request(struct request *rq, void *data)
 {
        struct rq_iter_data *iter_data = data;
 
 
        blk_mq_end_request(rq, cmd->status);
 }
 
-static bool mtip_abort_cmd(struct request *req, void *data, bool reserved)
+static bool mtip_abort_cmd(struct request *req, void *data)
 {
        struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);
        struct driver_data *dd = data;
        return true;
 }
 
-static bool mtip_queue_cmd(struct request *req, void *data, bool reserved)
+static bool mtip_queue_cmd(struct request *req, void *data)
 {
        struct driver_data *dd = data;
 
 
        kfree(args);
 }
 
-static bool nbd_clear_req(struct request *req, void *data, bool reserved)
+static bool nbd_clear_req(struct request *req, void *data)
 {
        struct nbd_cmd *cmd = blk_mq_rq_to_pdu(req);
 
 
        int scsi_result;
 };
 
-static bool srp_terminate_cmd(struct scsi_cmnd *scmnd, void *context_ptr,
-                             bool reserved)
+static bool srp_terminate_cmd(struct scsi_cmnd *scmnd, void *context_ptr)
 {
        struct srp_terminate_context *context = context_ptr;
        struct srp_target_port *target = context->srp_target;
 
 }
 EXPORT_SYMBOL_GPL(nvme_host_path_error);
 
-bool nvme_cancel_request(struct request *req, void *data, bool reserved)
+bool nvme_cancel_request(struct request *req, void *data)
 {
        dev_dbg_ratelimited(((struct nvme_ctrl *) data)->device,
                                "Cancelling I/O %d", req->tag);
 
  * status. The done path will return the io request back to the block
  * layer with an error status.
  */
-static bool
-nvme_fc_terminate_exchange(struct request *req, void *data, bool reserved)
+static bool nvme_fc_terminate_exchange(struct request *req, void *data)
 {
        struct nvme_ctrl *nctrl = data;
        struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);
 
 }
 
 blk_status_t nvme_host_path_error(struct request *req);
-bool nvme_cancel_request(struct request *req, void *data, bool reserved);
+bool nvme_cancel_request(struct request *req, void *data);
 void nvme_cancel_tagset(struct nvme_ctrl *ctrl);
 void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl);
 bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,
 
        q->entries = qsize;
 }
 
-static bool wait_for_io_iter(struct scsi_cmnd *cmd, void *data, bool rsvd)
+static bool wait_for_io_iter(struct scsi_cmnd *cmd, void *data)
 {
        int *active = data;
 
 
        int krlcnt;
 };
 
-static bool fib_count_iter(struct scsi_cmnd *scmnd, void *data, bool reserved)
+static bool fib_count_iter(struct scsi_cmnd *scmnd, void *data)
 {
        struct fib_count_data *fib_count = data;
 
 
        return wq_work_done;
 }
 
-static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
-                                bool reserved)
+static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data)
 {
        const int tag = scsi_cmd_to_rq(sc)->tag;
        struct fnic *fnic = data;
        int term_cnt;
 };
 
-static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
-                                    bool reserved)
+static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data)
 {
        struct fnic_rport_abort_io_iter_data *iter_data = data;
        struct fnic *fnic = iter_data->fnic;
        int ret;
 };
 
-static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
-                                    void *data, bool reserved)
+static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc, void *data)
 {
        struct fnic_pending_aborts_iter_data *iter_data = data;
        struct fnic *fnic = iter_data->fnic;
 
 }
 
-static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
-                                  bool reserved)
+static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data)
 {
        struct fnic_pending_aborts_iter_data *iter_data = data;
        struct fnic *fnic = iter_data->fnic;
 
 }
 EXPORT_SYMBOL(scsi_host_get);
 
-static bool scsi_host_check_in_flight(struct request *rq, void *data,
-                                     bool reserved)
+static bool scsi_host_check_in_flight(struct request *rq, void *data)
 {
        int *count = data;
        struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
 }
 EXPORT_SYMBOL_GPL(scsi_flush_work);
 
-static bool complete_all_cmds_iter(struct request *rq, void *data, bool rsvd)
+static bool complete_all_cmds_iter(struct request *rq, void *data)
 {
        struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
        enum scsi_host_status status = *(enum scsi_host_status *)data;
 EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands);
 
 struct scsi_host_busy_iter_data {
-       bool (*fn)(struct scsi_cmnd *, void *, bool);
+       bool (*fn)(struct scsi_cmnd *, void *);
        void *priv;
 };
 
-static bool __scsi_host_busy_iter_fn(struct request *req, void *priv,
-                                  bool reserved)
+static bool __scsi_host_busy_iter_fn(struct request *req, void *priv)
 {
        struct scsi_host_busy_iter_data *iter_data = priv;
        struct scsi_cmnd *sc = blk_mq_rq_to_pdu(req);
 
-       return iter_data->fn(sc, iter_data->priv, reserved);
+       return iter_data->fn(sc, iter_data->priv);
 }
 
 /**
  * ithas to be provided by the caller
  **/
 void scsi_host_busy_iter(struct Scsi_Host *shost,
-                        bool (*fn)(struct scsi_cmnd *, void *, bool),
+                        bool (*fn)(struct scsi_cmnd *, void *),
                         void *priv)
 {
        struct scsi_host_busy_iter_data iter_data = {
 
  * mpi3mr_print_scmd - print individual SCSI command
  * @rq: Block request
  * @data: Adapter instance reference
- * @reserved: N/A. Currently not used
  *
  * Print the SCSI command details if it is in LLD scope.
  *
  * Return: true always.
  */
-static bool mpi3mr_print_scmd(struct request *rq,
-       void *data, bool reserved)
+static bool mpi3mr_print_scmd(struct request *rq, void *data)
 {
        struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
        struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  * mpi3mr_flush_scmd - Flush individual SCSI command
  * @rq: Block request
  * @data: Adapter instance reference
- * @reserved: N/A. Currently not used
  *
  * Return the SCSI command to the upper layers if it is in LLD
  * scope.
  * Return: true always.
  */
 
-static bool mpi3mr_flush_scmd(struct request *rq,
-       void *data, bool reserved)
+static bool mpi3mr_flush_scmd(struct request *rq, void *data)
 {
        struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
        struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  * mpi3mr_count_dev_pending - Count commands pending for a lun
  * @rq: Block request
  * @data: SCSI device reference
- * @reserved: Unused
  *
  * This is an iterator function called for each SCSI command in
  * a host and if the command is pending in the LLD for the
  * Return: true always.
  */
 
-static bool mpi3mr_count_dev_pending(struct request *rq,
-       void *data, bool reserved)
+static bool mpi3mr_count_dev_pending(struct request *rq, void *data)
 {
        struct scsi_device *sdev = (struct scsi_device *)data;
        struct mpi3mr_sdev_priv_data *sdev_priv_data = sdev->hostdata;
  * mpi3mr_count_tgt_pending - Count commands pending for target
  * @rq: Block request
  * @data: SCSI target reference
- * @reserved: Unused
  *
  * This is an iterator function called for each SCSI command in
  * a host and if the command is pending in the LLD for the
  * Return: true always.
  */
 
-static bool mpi3mr_count_tgt_pending(struct request *rq,
-       void *data, bool reserved)
+static bool mpi3mr_count_tgt_pending(struct request *rq, void *data)
 {
        struct scsi_target *starget = (struct scsi_target *)data;
        struct mpi3mr_stgt_priv_data *stgt_priv_data = starget->hostdata;
 
        bool last;
 };
 
-typedef bool (busy_tag_iter_fn)(struct request *, void *, bool);
+typedef bool (busy_tag_iter_fn)(struct request *, void *);
 
 /**
  * struct blk_mq_ops - Callback functions that implements block driver
 
 extern int scsi_host_unblock(struct Scsi_Host *shost, int new_state);
 
 void scsi_host_busy_iter(struct Scsi_Host *,
-                        bool (*fn)(struct scsi_cmnd *, void *, bool), void *priv);
+                        bool (*fn)(struct scsi_cmnd *, void *), void *priv);
 
 struct class_container;