2 * Functions related to generic timeout handling of requests.
4 #include <linux/kernel.h>
5 #include <linux/module.h>
6 #include <linux/blkdev.h>
7 #include <linux/fault-inject.h>
12 #ifdef CONFIG_FAIL_IO_TIMEOUT
14 static DECLARE_FAULT_ATTR(fail_io_timeout
);
16 static int __init
setup_fail_io_timeout(char *str
)
18 return setup_fault_attr(&fail_io_timeout
, str
);
20 __setup("fail_io_timeout=", setup_fail_io_timeout
);
22 int blk_should_fake_timeout(struct request_queue
*q
)
24 if (!test_bit(QUEUE_FLAG_FAIL_IO
, &q
->queue_flags
))
27 return should_fail(&fail_io_timeout
, 1);
30 static int __init
fail_io_timeout_debugfs(void)
32 struct dentry
*dir
= fault_create_debugfs_attr("fail_io_timeout",
33 NULL
, &fail_io_timeout
);
35 return PTR_ERR_OR_ZERO(dir
);
38 late_initcall(fail_io_timeout_debugfs
);
40 ssize_t
part_timeout_show(struct device
*dev
, struct device_attribute
*attr
,
43 struct gendisk
*disk
= dev_to_disk(dev
);
44 int set
= test_bit(QUEUE_FLAG_FAIL_IO
, &disk
->queue
->queue_flags
);
46 return sprintf(buf
, "%d\n", set
!= 0);
49 ssize_t
part_timeout_store(struct device
*dev
, struct device_attribute
*attr
,
50 const char *buf
, size_t count
)
52 struct gendisk
*disk
= dev_to_disk(dev
);
56 struct request_queue
*q
= disk
->queue
;
57 char *p
= (char *) buf
;
59 val
= simple_strtoul(p
, &p
, 10);
60 spin_lock_irq(q
->queue_lock
);
62 queue_flag_set(QUEUE_FLAG_FAIL_IO
, q
);
64 queue_flag_clear(QUEUE_FLAG_FAIL_IO
, q
);
65 spin_unlock_irq(q
->queue_lock
);
71 #endif /* CONFIG_FAIL_IO_TIMEOUT */
74 * blk_delete_timer - Delete/cancel timer for a given function.
75 * @req: request that we are canceling timer for
78 void blk_delete_timer(struct request
*req
)
80 list_del_init(&req
->timeout_list
);
83 static void blk_rq_timed_out(struct request
*req
)
85 struct request_queue
*q
= req
->q
;
86 enum blk_eh_timer_return ret
= BLK_EH_RESET_TIMER
;
88 if (q
->rq_timed_out_fn
)
89 ret
= q
->rq_timed_out_fn(req
);
92 /* Can we use req->errors here? */
93 __blk_complete_request(req
);
95 case BLK_EH_RESET_TIMER
:
97 blk_clear_rq_complete(req
);
99 case BLK_EH_NOT_HANDLED
:
101 * LLD handles this for now but in the future
102 * we can send a request msg to abort the command
103 * and we can move more of the generic scsi eh code to
108 printk(KERN_ERR
"block: bad eh return: %d\n", ret
);
113 static void blk_rq_check_expired(struct request
*rq
, unsigned long *next_timeout
,
114 unsigned int *next_set
)
116 if (time_after_eq(jiffies
, rq
->deadline
)) {
117 list_del_init(&rq
->timeout_list
);
120 * Check if we raced with end io completion
122 if (!blk_mark_rq_complete(rq
))
123 blk_rq_timed_out(rq
);
124 } else if (!*next_set
|| time_after(*next_timeout
, rq
->deadline
)) {
125 *next_timeout
= rq
->deadline
;
130 void blk_rq_timed_out_timer(unsigned long data
)
132 struct request_queue
*q
= (struct request_queue
*) data
;
133 unsigned long flags
, next
= 0;
134 struct request
*rq
, *tmp
;
137 spin_lock_irqsave(q
->queue_lock
, flags
);
139 list_for_each_entry_safe(rq
, tmp
, &q
->timeout_list
, timeout_list
)
140 blk_rq_check_expired(rq
, &next
, &next_set
);
143 mod_timer(&q
->timeout
, round_jiffies_up(next
));
145 spin_unlock_irqrestore(q
->queue_lock
, flags
);
149 * blk_abort_request -- Request request recovery for the specified command
150 * @req: pointer to the request of interest
152 * This function requests that the block layer start recovery for the
153 * request by deleting the timer and calling the q's timeout function.
154 * LLDDs who implement their own error recovery MAY ignore the timeout
155 * event if they generated blk_abort_req. Must hold queue lock.
157 void blk_abort_request(struct request
*req
)
159 if (blk_mark_rq_complete(req
))
161 blk_delete_timer(req
);
163 blk_mq_rq_timed_out(req
, false);
165 blk_rq_timed_out(req
);
167 EXPORT_SYMBOL_GPL(blk_abort_request
);
169 unsigned long blk_rq_timeout(unsigned long timeout
)
173 maxt
= round_jiffies_up(jiffies
+ BLK_MAX_TIMEOUT
);
174 if (time_after(timeout
, maxt
))
181 * blk_add_timer - Start timeout timer for a single request
182 * @req: request that is about to start running.
185 * Each request has its own timer, and as it is added to the queue, we
186 * set up the timer. When the request completes, we cancel the timer.
188 void blk_add_timer(struct request
*req
)
190 struct request_queue
*q
= req
->q
;
191 unsigned long expiry
;
193 if (req
->cmd_flags
& REQ_NO_TIMEOUT
)
196 /* blk-mq has its own handler, so we don't need ->rq_timed_out_fn */
197 if (!q
->mq_ops
&& !q
->rq_timed_out_fn
)
200 BUG_ON(!list_empty(&req
->timeout_list
));
203 * Some LLDs, like scsi, peek at the timeout to prevent a
204 * command from being retried forever.
207 req
->timeout
= q
->rq_timeout
;
209 req
->deadline
= jiffies
+ req
->timeout
;
211 list_add_tail(&req
->timeout_list
, &req
->q
->timeout_list
);
214 * If the timer isn't already pending or this timeout is earlier
215 * than an existing one, modify the timer. Round up to next nearest
218 expiry
= blk_rq_timeout(round_jiffies_up(req
->deadline
));
220 if (!timer_pending(&q
->timeout
) ||
221 time_before(expiry
, q
->timeout
.expires
)) {
222 unsigned long diff
= q
->timeout
.expires
- expiry
;
225 * Due to added timer slack to group timers, the timer
226 * will often be a little in front of what we asked for.
227 * So apply some tolerance here too, otherwise we keep
228 * modifying the timer because expires for value X
229 * will be X + something.
231 if (!timer_pending(&q
->timeout
) || (diff
>= HZ
/ 2))
232 mod_timer(&q
->timeout
, expiry
);
This page took 0.034564 seconds and 5 git commands to generate.