]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - block/blk-timeout.c
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);
61 blk_queue_flag_set(QUEUE_FLAG_FAIL_IO
, q
);
63 blk_queue_flag_clear(QUEUE_FLAG_FAIL_IO
, q
);
69 #endif /* CONFIG_FAIL_IO_TIMEOUT */
72 * blk_delete_timer - Delete/cancel timer for a given function.
73 * @req: request that we are canceling timer for
76 void blk_delete_timer(struct request
*req
)
78 list_del_init(&req
->timeout_list
);
81 static void blk_rq_timed_out(struct request
*req
)
83 struct request_queue
*q
= req
->q
;
84 enum blk_eh_timer_return ret
= BLK_EH_RESET_TIMER
;
86 if (q
->rq_timed_out_fn
)
87 ret
= q
->rq_timed_out_fn(req
);
89 case BLK_EH_RESET_TIMER
:
91 blk_clear_rq_complete(req
);
95 * LLD handles this for now but in the future
96 * we can send a request msg to abort the command
97 * and we can move more of the generic scsi eh code to
102 printk(KERN_ERR
"block: bad eh return: %d\n", ret
);
107 static void blk_rq_check_expired(struct request
*rq
, unsigned long *next_timeout
,
108 unsigned int *next_set
)
110 const unsigned long deadline
= blk_rq_deadline(rq
);
112 if (time_after_eq(jiffies
, deadline
)) {
113 list_del_init(&rq
->timeout_list
);
116 * Check if we raced with end io completion
118 if (!blk_mark_rq_complete(rq
))
119 blk_rq_timed_out(rq
);
120 } else if (!*next_set
|| time_after(*next_timeout
, deadline
)) {
121 *next_timeout
= deadline
;
126 void blk_timeout_work(struct work_struct
*work
)
128 struct request_queue
*q
=
129 container_of(work
, struct request_queue
, timeout_work
);
130 unsigned long flags
, next
= 0;
131 struct request
*rq
, *tmp
;
134 spin_lock_irqsave(q
->queue_lock
, flags
);
136 list_for_each_entry_safe(rq
, tmp
, &q
->timeout_list
, timeout_list
)
137 blk_rq_check_expired(rq
, &next
, &next_set
);
140 mod_timer(&q
->timeout
, round_jiffies_up(next
));
142 spin_unlock_irqrestore(q
->queue_lock
, flags
);
146 * blk_abort_request -- Request request recovery for the specified command
147 * @req: pointer to the request of interest
149 * This function requests that the block layer start recovery for the
150 * request by deleting the timer and calling the q's timeout function.
151 * LLDDs who implement their own error recovery MAY ignore the timeout
152 * event if they generated blk_abort_req. Must hold queue lock.
154 void blk_abort_request(struct request
*req
)
156 if (req
->q
->mq_ops
) {
158 * All we need to ensure is that timeout scan takes place
159 * immediately and that scan sees the new timeout value.
160 * No need for fancy synchronizations.
162 blk_rq_set_deadline(req
, jiffies
);
163 kblockd_schedule_work(&req
->q
->timeout_work
);
165 if (blk_mark_rq_complete(req
))
167 blk_delete_timer(req
);
168 blk_rq_timed_out(req
);
171 EXPORT_SYMBOL_GPL(blk_abort_request
);
173 unsigned long blk_rq_timeout(unsigned long timeout
)
177 maxt
= round_jiffies_up(jiffies
+ BLK_MAX_TIMEOUT
);
178 if (time_after(timeout
, maxt
))
185 * blk_add_timer - Start timeout timer for a single request
186 * @req: request that is about to start running.
189 * Each request has its own timer, and as it is added to the queue, we
190 * set up the timer. When the request completes, we cancel the timer.
192 void blk_add_timer(struct request
*req
)
194 struct request_queue
*q
= req
->q
;
195 unsigned long expiry
;
198 lockdep_assert_held(q
->queue_lock
);
200 /* blk-mq has its own handler, so we don't need ->rq_timed_out_fn */
201 if (!q
->mq_ops
&& !q
->rq_timed_out_fn
)
204 BUG_ON(!list_empty(&req
->timeout_list
));
207 * Some LLDs, like scsi, peek at the timeout to prevent a
208 * command from being retried forever.
211 req
->timeout
= q
->rq_timeout
;
213 blk_rq_set_deadline(req
, jiffies
+ req
->timeout
);
216 * Only the non-mq case needs to add the request to a protected list.
217 * For the mq case we simply scan the tag map.
220 list_add_tail(&req
->timeout_list
, &req
->q
->timeout_list
);
223 * If the timer isn't already pending or this timeout is earlier
224 * than an existing one, modify the timer. Round up to next nearest
227 expiry
= blk_rq_timeout(round_jiffies_up(blk_rq_deadline(req
)));
229 if (!timer_pending(&q
->timeout
) ||
230 time_before(expiry
, q
->timeout
.expires
)) {
231 unsigned long diff
= q
->timeout
.expires
- expiry
;
234 * Due to added timer slack to group timers, the timer
235 * will often be a little in front of what we asked for.
236 * So apply some tolerance here too, otherwise we keep
237 * modifying the timer because expires for value X
238 * will be X + something.
240 if (!timer_pending(&q
->timeout
) || (diff
>= HZ
/ 2))
241 mod_timer(&q
->timeout
, expiry
);