--- initial
+++ final
@@ -1,91 +1,91 @@
 static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio) {
   const int is_sync = op_is_sync(bio->bi_opf);
   const int is_flush_fua = op_is_flush(bio->bi_opf);
   struct blk_mq_alloc_data data = {.flags = 0};
   struct request *rq;
   unsigned int request_count = 0;
   struct blk_plug *plug;
   struct request *same_queue_rq = NULL;
   blk_qc_t cookie;
   unsigned int wb_acct;
   blk_queue_bounce(q, &bio);
-  blk_queue_split(q, &bio, q->bio_split);
+  blk_queue_split(q, &bio);
   if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
     bio_io_error(bio);
     return BLK_QC_T_NONE;
   }
   if (!is_flush_fua && !blk_queue_nomerges(q) && blk_attempt_plug_merge(q, bio, &request_count, &same_queue_rq)) return BLK_QC_T_NONE;
   if (blk_mq_sched_bio_merge(q, bio)) return BLK_QC_T_NONE;
   wb_acct = wbt_wait(q->rq_wb, bio, NULL);
   trace_block_getrq(q, bio, bio->bi_opf);
   rq = blk_mq_get_request(q, bio, bio->bi_opf, &data);
   if (unlikely(!rq)) {
     __wbt_done(q->rq_wb, wb_acct);
     return BLK_QC_T_NONE;
   }
   wbt_track(&rq->issue_stat, wb_acct);
   cookie = request_to_qc_t(data.hctx, rq);
   plug = current->plug;
   if (unlikely(is_flush_fua)) {
     blk_mq_put_ctx(data.ctx);
     blk_mq_bio_to_request(rq, bio);
     if (q->elevator) {
       blk_mq_sched_insert_request(rq, false, true, true, true);
     } else {
       blk_insert_flush(rq);
       blk_mq_run_hw_queue(data.hctx, true);
     }
   } else if (plug && q->nr_hw_queues == 1) {
     struct request *last = NULL;
     blk_mq_put_ctx(data.ctx);
     blk_mq_bio_to_request(rq, bio);
     /*
      * @request_count may become stale because of schedule
      * out, so check the list again.
      */
     if (list_empty(&plug->mq_list))
       request_count = 0;
     else if (blk_queue_nomerges(q))
       request_count = blk_plug_queued_count(q);
     if (!request_count)
       trace_block_plug(q);
     else
       last = list_entry_rq(plug->mq_list.prev);
     if (request_count >= BLK_MAX_REQUEST_COUNT || (last && blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE)) {
       blk_flush_plug_list(plug, false);
       trace_block_plug(q);
     }
     list_add_tail(&rq->queuelist, &plug->mq_list);
   } else if (plug && !blk_queue_nomerges(q)) {
     blk_mq_bio_to_request(rq, bio);
     /*
      * We do limited plugging. If the bio can be merged, do that.
      * Otherwise the existing request in the plug list will be
      * issued. So the plug list will have one request at most
      * The plug list might get flushed before this. If that happens,
      * the plug list is empty, and same_queue_rq is invalid.
      */
     if (list_empty(&plug->mq_list)) same_queue_rq = NULL;
     if (same_queue_rq) list_del_init(&same_queue_rq->queuelist);
     list_add_tail(&rq->queuelist, &plug->mq_list);
     blk_mq_put_ctx(data.ctx);
     if (same_queue_rq) {
       data.hctx = blk_mq_map_queue(q, same_queue_rq->mq_ctx->cpu);
       blk_mq_try_issue_directly(data.hctx, same_queue_rq, &cookie);
     }
   } else if (q->nr_hw_queues > 1 && is_sync) {
     blk_mq_put_ctx(data.ctx);
     blk_mq_bio_to_request(rq, bio);
     blk_mq_try_issue_directly(data.hctx, rq, &cookie);
   } else if (q->elevator) {
     blk_mq_put_ctx(data.ctx);
     blk_mq_bio_to_request(rq, bio);
     blk_mq_sched_insert_request(rq, false, true, true, true);
   } else {
     blk_mq_put_ctx(data.ctx);
     blk_mq_bio_to_request(rq, bio);
     blk_mq_queue_io(data.hctx, data.ctx, rq);
     blk_mq_run_hw_queue(data.hctx, true);
   }
   return cookie;
 }<sep>@@
expression e1,e2,e3;
@@
       blk_queue_split(e1, e2
-              , e3
                      )