--- initial
+++ final
@@ -1,107 +1,107 @@
 static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio) {
   struct blk_plug *plug;
   int where = ELEVATOR_INSERT_SORT;
   struct request *req, *free;
   unsigned int request_count = 0;
   unsigned int wb_acct;
   /*
    * low level driver can indicate that it wants pages above a
    * certain limit bounced to low memory (ie for highmem, or even
    * ISA dma in theory)
    */
   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->bi_status = BLK_STS_IOERR;
     bio_endio(bio);
     return BLK_QC_T_NONE;
   }
   if (op_is_flush(bio->bi_opf)) {
     spin_lock_irq(q->queue_lock);
     where = ELEVATOR_INSERT_FLUSH;
     goto get_rq;
   }
   /*
    * Check if we can merge with the plugged list before grabbing
    * any locks.
    */
   if (!blk_queue_nomerges(q)) {
     if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) return BLK_QC_T_NONE;
   } else
     request_count = blk_plug_queued_count(q);
   spin_lock_irq(q->queue_lock);
   switch (elv_merge(q, &req, bio)) {
   case ELEVATOR_BACK_MERGE:
     if (!bio_attempt_back_merge(q, req, bio)) break;
     elv_bio_merged(q, req, bio);
     free = attempt_back_merge(q, req);
     if (free)
       __blk_put_request(q, free);
     else
       elv_merged_request(q, req, ELEVATOR_BACK_MERGE);
     goto out_unlock;
   case ELEVATOR_FRONT_MERGE:
     if (!bio_attempt_front_merge(q, req, bio)) break;
     elv_bio_merged(q, req, bio);
     free = attempt_front_merge(q, req);
     if (free)
       __blk_put_request(q, free);
     else
       elv_merged_request(q, req, ELEVATOR_FRONT_MERGE);
     goto out_unlock;
   default: break;
   }
 get_rq:
   wb_acct = wbt_wait(q->rq_wb, bio, q->queue_lock);
   /*
    * Grab a free request. This is might sleep but can not fail.
    * Returns with the queue unlocked.
    */
   req = get_request(q, bio->bi_opf, bio, GFP_NOIO);
   if (IS_ERR(req)) {
     __wbt_done(q->rq_wb, wb_acct);
     if (PTR_ERR(req) == -ENOMEM)
       bio->bi_status = BLK_STS_RESOURCE;
     else
       bio->bi_status = BLK_STS_IOERR;
     bio_endio(bio);
     goto out_unlock;
   }
   wbt_track(&req->issue_stat, wb_acct);
   /*
    * After dropping the lock and possibly sleeping here, our request
    * may now be mergeable after it had proven unmergeable (above).
    * We don't worry about that case for efficiency. It won't happen
    * often, and the elevators are able to handle it.
    */
   blk_init_request_from_bio(req, bio);
   if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) req->cpu = raw_smp_processor_id();
   plug = current->plug;
   if (plug) {
     /*
      * If this is the first request added after a plug, fire
      * of a plug trace.
      *
      * @request_count may become stale because of schedule
      * out, so check plug list again.
      */
     if (!request_count || list_empty(&plug->list))
       trace_block_plug(q);
     else {
       struct request *last = list_entry_rq(plug->list.prev);
       if (request_count >= BLK_MAX_REQUEST_COUNT || blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE) {
         blk_flush_plug_list(plug, false);
         trace_block_plug(q);
       }
     }
     list_add_tail(&req->queuelist, &plug->list);
     blk_account_io_start(req, true);
   } else {
     spin_lock_irq(q->queue_lock);
     add_acct_request(q, req, where);
     __blk_run_queue(q);
   out_unlock:
     spin_unlock_irq(q->queue_lock);
   }
   return BLK_QC_T_NONE;
 }<sep>@@
expression e1,e2,e3;
@@
       blk_queue_split(e1, e2
-              , e3
                      )