Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : /*
       3             :  * Functions related to setting various queue properties from drivers
       4             :  */
       5             : #include <linux/kernel.h>
       6             : #include <linux/module.h>
       7             : #include <linux/bio.h>
       8             : #include <linux/blkdev.h>
       9             : #include <linux/blk-mq.h>
      10             : #include <linux/sched/sysctl.h>
      11             : 
      12             : #include "blk.h"
      13             : #include "blk-mq-sched.h"
      14             : 
      15             : /**
      16             :  * blk_end_sync_rq - executes a completion event on a request
      17             :  * @rq: request to complete
      18             :  * @error: end I/O status of the request
      19             :  */
      20           2 : static void blk_end_sync_rq(struct request *rq, blk_status_t error)
      21             : {
      22           2 :         struct completion *waiting = rq->end_io_data;
      23             : 
      24           2 :         rq->end_io_data = NULL;
      25             : 
      26             :         /*
      27             :          * complete last, if this is a stack request the process (and thus
      28             :          * the rq pointer) could be invalid right after this complete()
      29             :          */
      30           2 :         complete(waiting);
      31           2 : }
      32             : 
      33             : /**
      34             :  * blk_execute_rq_nowait - insert a request to I/O scheduler for execution
      35             :  * @bd_disk:    matching gendisk
      36             :  * @rq:         request to insert
      37             :  * @at_head:    insert request at head or tail of queue
      38             :  * @done:       I/O completion handler
      39             :  *
      40             :  * Description:
      41             :  *    Insert a fully prepared request at the back of the I/O scheduler queue
      42             :  *    for execution.  Don't wait for completion.
      43             :  *
      44             :  * Note:
      45             :  *    This function will invoke @done directly if the queue is dead.
      46             :  */
      47           2 : void blk_execute_rq_nowait(struct gendisk *bd_disk, struct request *rq,
      48             :                            int at_head, rq_end_io_fn *done)
      49             : {
      50           2 :         WARN_ON(irqs_disabled());
      51           4 :         WARN_ON(!blk_rq_is_passthrough(rq));
      52             : 
      53           2 :         rq->rq_disk = bd_disk;
      54           2 :         rq->end_io = done;
      55             : 
      56           2 :         blk_account_io_start(rq);
      57             : 
      58             :         /*
      59             :          * don't check dying flag for MQ because the request won't
      60             :          * be reused after dying flag is set
      61             :          */
      62           2 :         blk_mq_sched_insert_request(rq, at_head, true, false);
      63           2 : }
      64             : EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
      65             : 
      66             : /**
      67             :  * blk_execute_rq - insert a request into queue for execution
      68             :  * @bd_disk:    matching gendisk
      69             :  * @rq:         request to insert
      70             :  * @at_head:    insert request at head or tail of queue
      71             :  *
      72             :  * Description:
      73             :  *    Insert a fully prepared request at the back of the I/O scheduler queue
      74             :  *    for execution and wait for completion.
      75             :  */
      76           2 : void blk_execute_rq(struct gendisk *bd_disk, struct request *rq, int at_head)
      77             : {
      78           2 :         DECLARE_COMPLETION_ONSTACK(wait);
      79           2 :         unsigned long hang_check;
      80             : 
      81           2 :         rq->end_io_data = &wait;
      82           2 :         blk_execute_rq_nowait(bd_disk, rq, at_head, blk_end_sync_rq);
      83             : 
      84             :         /* Prevent hang_check timer from firing at us during very long I/O */
      85           2 :         hang_check = sysctl_hung_task_timeout_secs;
      86           2 :         if (hang_check)
      87             :                 while (!wait_for_completion_io_timeout(&wait, hang_check * (HZ/2)));
      88             :         else
      89           2 :                 wait_for_completion_io(&wait);
      90           2 : }
      91             : EXPORT_SYMBOL(blk_execute_rq);