Branch data     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                 :        404 : static void blk_end_sync_rq(struct request *rq, blk_status_t error)
      21                 :            : {
      22                 :        404 :         struct completion *waiting = rq->end_io_data;
      23                 :            : 
      24                 :        404 :         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                 :        404 :         complete(waiting);
      31                 :        404 : }
      32                 :            : 
      33                 :            : /**
      34                 :            :  * blk_execute_rq_nowait - insert a request into queue for execution
      35                 :            :  * @q:          queue to insert the request in
      36                 :            :  * @bd_disk:    matching gendisk
      37                 :            :  * @rq:         request to insert
      38                 :            :  * @at_head:    insert request at head or tail of queue
      39                 :            :  * @done:       I/O completion handler
      40                 :            :  *
      41                 :            :  * Description:
      42                 :            :  *    Insert a fully prepared request at the back of the I/O scheduler queue
      43                 :            :  *    for execution.  Don't wait for completion.
      44                 :            :  *
      45                 :            :  * Note:
      46                 :            :  *    This function will invoke @done directly if the queue is dead.
      47                 :            :  */
      48                 :        404 : void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
      49                 :            :                            struct request *rq, int at_head,
      50                 :            :                            rq_end_io_fn *done)
      51                 :            : {
      52         [ -  + ]:        404 :         WARN_ON(irqs_disabled());
      53   [ -  +  -  + ]:        404 :         WARN_ON(!blk_rq_is_passthrough(rq));
      54                 :            : 
      55                 :        404 :         rq->rq_disk = bd_disk;
      56                 :        404 :         rq->end_io = done;
      57                 :            : 
      58                 :        404 :         blk_account_io_start(rq, true);
      59                 :            : 
      60                 :            :         /*
      61                 :            :          * don't check dying flag for MQ because the request won't
      62                 :            :          * be reused after dying flag is set
      63                 :            :          */
      64                 :        404 :         blk_mq_sched_insert_request(rq, at_head, true, false);
      65                 :        404 : }
      66                 :            : EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
      67                 :            : 
      68                 :            : /**
      69                 :            :  * blk_execute_rq - insert a request into queue for execution
      70                 :            :  * @q:          queue to insert the request in
      71                 :            :  * @bd_disk:    matching gendisk
      72                 :            :  * @rq:         request to insert
      73                 :            :  * @at_head:    insert request at head or tail of queue
      74                 :            :  *
      75                 :            :  * Description:
      76                 :            :  *    Insert a fully prepared request at the back of the I/O scheduler queue
      77                 :            :  *    for execution and wait for completion.
      78                 :            :  */
      79                 :        404 : void blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
      80                 :            :                    struct request *rq, int at_head)
      81                 :            : {
      82                 :        404 :         DECLARE_COMPLETION_ONSTACK(wait);
      83                 :        404 :         unsigned long hang_check;
      84                 :            : 
      85                 :        404 :         rq->end_io_data = &wait;
      86                 :        404 :         blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq);
      87                 :            : 
      88                 :            :         /* Prevent hang_check timer from firing at us during very long I/O */
      89                 :        404 :         hang_check = sysctl_hung_task_timeout_secs;
      90                 :        404 :         if (hang_check)
      91                 :            :                 while (!wait_for_completion_io_timeout(&wait, hang_check * (HZ/2)));
      92                 :            :         else
      93                 :        404 :                 wait_for_completion_io(&wait);
      94                 :        404 : }
      95                 :            : EXPORT_SYMBOL(blk_execute_rq);