Branch data Line data Source code
1 : : /*
2 : : * Functions related to generic timeout handling of requests.
3 : : */
4 : : #include <linux/kernel.h>
5 : : #include <linux/module.h>
6 : : #include <linux/blkdev.h>
7 : : #include <linux/fault-inject.h>
8 : :
9 : : #include "blk.h"
10 : : #include "blk-mq.h"
11 : :
12 : : #ifdef CONFIG_FAIL_IO_TIMEOUT
13 : :
14 : : static DECLARE_FAULT_ATTR(fail_io_timeout);
15 : :
16 : : static int __init setup_fail_io_timeout(char *str)
17 : : {
18 : : return setup_fault_attr(&fail_io_timeout, str);
19 : : }
20 : : __setup("fail_io_timeout=", setup_fail_io_timeout);
21 : :
22 : : int blk_should_fake_timeout(struct request_queue *q)
23 : : {
24 : : if (!test_bit(QUEUE_FLAG_FAIL_IO, &q->queue_flags))
25 : : return 0;
26 : :
27 : : return should_fail(&fail_io_timeout, 1);
28 : : }
29 : :
30 : : static int __init fail_io_timeout_debugfs(void)
31 : : {
32 : : struct dentry *dir = fault_create_debugfs_attr("fail_io_timeout",
33 : : NULL, &fail_io_timeout);
34 : :
35 : : return PTR_ERR_OR_ZERO(dir);
36 : : }
37 : :
38 : : late_initcall(fail_io_timeout_debugfs);
39 : :
40 : : ssize_t part_timeout_show(struct device *dev, struct device_attribute *attr,
41 : : char *buf)
42 : : {
43 : : struct gendisk *disk = dev_to_disk(dev);
44 : : int set = test_bit(QUEUE_FLAG_FAIL_IO, &disk->queue->queue_flags);
45 : :
46 : : return sprintf(buf, "%d\n", set != 0);
47 : : }
48 : :
49 : : ssize_t part_timeout_store(struct device *dev, struct device_attribute *attr,
50 : : const char *buf, size_t count)
51 : : {
52 : : struct gendisk *disk = dev_to_disk(dev);
53 : : int val;
54 : :
55 : : if (count) {
56 : : struct request_queue *q = disk->queue;
57 : : char *p = (char *) buf;
58 : :
59 : : val = simple_strtoul(p, &p, 10);
60 : : spin_lock_irq(q->queue_lock);
61 : : if (val)
62 : : queue_flag_set(QUEUE_FLAG_FAIL_IO, q);
63 : : else
64 : : queue_flag_clear(QUEUE_FLAG_FAIL_IO, q);
65 : : spin_unlock_irq(q->queue_lock);
66 : : }
67 : :
68 : : return count;
69 : : }
70 : :
71 : : #endif /* CONFIG_FAIL_IO_TIMEOUT */
72 : :
73 : : /*
74 : : * blk_delete_timer - Delete/cancel timer for a given function.
75 : : * @req: request that we are canceling timer for
76 : : *
77 : : */
78 : 0 : void blk_delete_timer(struct request *req)
79 : : {
80 : 401979 : list_del_init(&req->timeout_list);
81 : 401979 : }
82 : :
83 : 0 : static void blk_rq_timed_out(struct request *req)
84 : : {
85 : 0 : struct request_queue *q = req->q;
86 : : enum blk_eh_timer_return ret = BLK_EH_RESET_TIMER;
87 : :
88 [ # # ]: 0 : if (q->rq_timed_out_fn)
89 : 0 : ret = q->rq_timed_out_fn(req);
90 [ # # # # ]: 0 : switch (ret) {
91 : : case BLK_EH_HANDLED:
92 : : /* Can we use req->errors here? */
93 [ # # ]: 0 : if (q->mq_ops)
94 : 0 : __blk_mq_complete_request(req);
95 : : else
96 : 0 : __blk_complete_request(req);
97 : : break;
98 : : case BLK_EH_RESET_TIMER:
99 [ # # ]: 0 : if (q->mq_ops)
100 : 0 : blk_mq_add_timer(req);
101 : : else
102 : : blk_add_timer(req);
103 : :
104 : : blk_clear_rq_complete(req);
105 : : break;
106 : : case BLK_EH_NOT_HANDLED:
107 : : /*
108 : : * LLD handles this for now but in the future
109 : : * we can send a request msg to abort the command
110 : : * and we can move more of the generic scsi eh code to
111 : : * the blk layer.
112 : : */
113 : : break;
114 : : default:
115 : 0 : printk(KERN_ERR "block: bad eh return: %d\n", ret);
116 : 0 : break;
117 : : }
118 : 0 : }
119 : :
120 : 0 : void blk_rq_check_expired(struct request *rq, unsigned long *next_timeout,
121 : : unsigned int *next_set)
122 : : {
123 [ - + ]: 126 : if (time_after_eq(jiffies, rq->deadline)) {
124 : 0 : list_del_init(&rq->timeout_list);
125 : :
126 : : /*
127 : : * Check if we raced with end io completion
128 : : */
129 [ # # ]: 0 : if (!blk_mark_rq_complete(rq))
130 : 0 : blk_rq_timed_out(rq);
131 [ - + ][ # # ]: 126 : } else if (!*next_set || time_after(*next_timeout, rq->deadline)) {
132 : 126 : *next_timeout = rq->deadline;
133 : 126 : *next_set = 1;
134 : : }
135 : 0 : }
136 : :
137 : 0 : void blk_rq_timed_out_timer(unsigned long data)
138 : : {
139 : 1054 : struct request_queue *q = (struct request_queue *) data;
140 : 1054 : unsigned long flags, next = 0;
141 : : struct request *rq, *tmp;
142 : 1054 : int next_set = 0;
143 : :
144 : 1054 : spin_lock_irqsave(q->queue_lock, flags);
145 : :
146 [ + + ]: 1180 : list_for_each_entry_safe(rq, tmp, &q->timeout_list, timeout_list)
147 : 126 : blk_rq_check_expired(rq, &next, &next_set);
148 : :
149 [ + + ]: 1054 : if (next_set)
150 : 126 : mod_timer(&q->timeout, round_jiffies_up(next));
151 : :
152 : 1054 : spin_unlock_irqrestore(q->queue_lock, flags);
153 : 1054 : }
154 : :
155 : : /**
156 : : * blk_abort_request -- Request request recovery for the specified command
157 : : * @req: pointer to the request of interest
158 : : *
159 : : * This function requests that the block layer start recovery for the
160 : : * request by deleting the timer and calling the q's timeout function.
161 : : * LLDDs who implement their own error recovery MAY ignore the timeout
162 : : * event if they generated blk_abort_req. Must hold queue lock.
163 : : */
164 : 0 : void blk_abort_request(struct request *req)
165 : : {
166 [ # # ]: 0 : if (blk_mark_rq_complete(req))
167 : 0 : return;
168 : : blk_delete_timer(req);
169 : 0 : blk_rq_timed_out(req);
170 : : }
171 : : EXPORT_SYMBOL_GPL(blk_abort_request);
172 : :
173 : 0 : void __blk_add_timer(struct request *req, struct list_head *timeout_list)
174 : : {
175 : 401979 : struct request_queue *q = req->q;
176 : : unsigned long expiry;
177 : :
178 [ + - ]: 401979 : if (!q->rq_timed_out_fn)
179 : 401979 : return;
180 : :
181 [ - + ]: 401979 : BUG_ON(!list_empty(&req->timeout_list));
182 : :
183 : : /*
184 : : * Some LLDs, like scsi, peek at the timeout to prevent a
185 : : * command from being retried forever.
186 : : */
187 [ + + ]: 401979 : if (!req->timeout)
188 : 387103 : req->timeout = q->rq_timeout;
189 : :
190 : 401979 : req->deadline = jiffies + req->timeout;
191 [ + - ]: 401979 : if (timeout_list)
192 : : list_add_tail(&req->timeout_list, timeout_list);
193 : :
194 : : /*
195 : : * If the timer isn't already pending or this timeout is earlier
196 : : * than an existing one, modify the timer. Round up to next nearest
197 : : * second.
198 : : */
199 : 401979 : expiry = round_jiffies_up(req->deadline);
200 : :
201 [ + + ]: 401979 : if (!timer_pending(&q->timeout) ||
202 [ + + ]: 401051 : time_before(expiry, q->timeout.expires))
203 : 6829 : mod_timer(&q->timeout, expiry);
204 : :
205 : : }
206 : :
207 : : /**
208 : : * blk_add_timer - Start timeout timer for a single request
209 : : * @req: request that is about to start running.
210 : : *
211 : : * Notes:
212 : : * Each request has its own timer, and as it is added to the queue, we
213 : : * set up the timer. When the request completes, we cancel the timer.
214 : : */
215 : 0 : void blk_add_timer(struct request *req)
216 : : {
217 : 401979 : __blk_add_timer(req, &req->q->timeout_list);
218 : 401979 : }
219 : :
|
