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>
11 #ifdef CONFIG_FAIL_IO_TIMEOUT
13 static DECLARE_FAULT_ATTR(fail_io_timeout
);
15 static int __init
setup_fail_io_timeout(char *str
)
17 return setup_fault_attr(&fail_io_timeout
, str
);
19 __setup("fail_io_timeout=", setup_fail_io_timeout
);
21 int blk_should_fake_timeout(struct request_queue
*q
)
23 if (!test_bit(QUEUE_FLAG_FAIL_IO
, &q
->queue_flags
))
26 return should_fail(&fail_io_timeout
, 1);
29 static int __init
fail_io_timeout_debugfs(void)
31 struct dentry
*dir
= fault_create_debugfs_attr("fail_io_timeout",
32 NULL
, &fail_io_timeout
);
34 return IS_ERR(dir
) ? PTR_ERR(dir
) : 0;
37 late_initcall(fail_io_timeout_debugfs
);
39 ssize_t
part_timeout_show(struct device
*dev
, struct device_attribute
*attr
,
42 struct gendisk
*disk
= dev_to_disk(dev
);
43 int set
= test_bit(QUEUE_FLAG_FAIL_IO
, &disk
->queue
->queue_flags
);
45 return sprintf(buf
, "%d\n", set
!= 0);
48 ssize_t
part_timeout_store(struct device
*dev
, struct device_attribute
*attr
,
49 const char *buf
, size_t count
)
51 struct gendisk
*disk
= dev_to_disk(dev
);
55 struct request_queue
*q
= disk
->queue
;
56 char *p
= (char *) buf
;
58 val
= simple_strtoul(p
, &p
, 10);
59 spin_lock_irq(q
->queue_lock
);
61 queue_flag_set(QUEUE_FLAG_FAIL_IO
, q
);
63 queue_flag_clear(QUEUE_FLAG_FAIL_IO
, q
);
64 spin_unlock_irq(q
->queue_lock
);
70 #endif /* CONFIG_FAIL_IO_TIMEOUT */
73 * blk_delete_timer - Delete/cancel timer for a given function.
74 * @req: request that we are canceling timer for
77 void blk_delete_timer(struct request
*req
)
79 list_del_init(&req
->timeout_list
);
82 static void blk_rq_timed_out(struct request
*req
)
84 struct request_queue
*q
= req
->q
;
85 enum blk_eh_timer_return ret
;
87 ret
= q
->rq_timed_out_fn(req
);
90 __blk_complete_request(req
);
92 case BLK_EH_RESET_TIMER
:
93 blk_clear_rq_complete(req
);
96 case BLK_EH_NOT_HANDLED
:
98 * LLD handles this for now but in the future
99 * we can send a request msg to abort the command
100 * and we can move more of the generic scsi eh code to
105 printk(KERN_ERR
"block: bad eh return: %d\n", ret
);
110 void blk_rq_timed_out_timer(unsigned long data
)
112 struct request_queue
*q
= (struct request_queue
*) data
;
113 unsigned long flags
, next
= 0;
114 struct request
*rq
, *tmp
;
117 spin_lock_irqsave(q
->queue_lock
, flags
);
119 list_for_each_entry_safe(rq
, tmp
, &q
->timeout_list
, timeout_list
) {
120 if (time_after_eq(jiffies
, rq
->deadline
)) {
121 list_del_init(&rq
->timeout_list
);
124 * Check if we raced with end io completion
126 if (blk_mark_rq_complete(rq
))
128 blk_rq_timed_out(rq
);
129 } else if (!next_set
|| time_after(next
, rq
->deadline
)) {
136 mod_timer(&q
->timeout
, round_jiffies_up(next
));
138 spin_unlock_irqrestore(q
->queue_lock
, flags
);
142 * blk_abort_request -- Request request recovery for the specified command
143 * @req: pointer to the request of interest
145 * This function requests that the block layer start recovery for the
146 * request by deleting the timer and calling the q's timeout function.
147 * LLDDs who implement their own error recovery MAY ignore the timeout
148 * event if they generated blk_abort_req. Must hold queue lock.
150 void blk_abort_request(struct request
*req
)
152 if (blk_mark_rq_complete(req
))
154 blk_delete_timer(req
);
155 blk_rq_timed_out(req
);
157 EXPORT_SYMBOL_GPL(blk_abort_request
);
160 * blk_add_timer - Start timeout timer for a single request
161 * @req: request that is about to start running.
164 * Each request has its own timer, and as it is added to the queue, we
165 * set up the timer. When the request completes, we cancel the timer.
167 void blk_add_timer(struct request
*req
)
169 struct request_queue
*q
= req
->q
;
170 unsigned long expiry
;
172 if (!q
->rq_timed_out_fn
)
175 BUG_ON(!list_empty(&req
->timeout_list
));
176 BUG_ON(test_bit(REQ_ATOM_COMPLETE
, &req
->atomic_flags
));
179 * Some LLDs, like scsi, peek at the timeout to prevent a
180 * command from being retried forever.
183 req
->timeout
= q
->rq_timeout
;
185 req
->deadline
= jiffies
+ req
->timeout
;
186 list_add_tail(&req
->timeout_list
, &q
->timeout_list
);
189 * If the timer isn't already pending or this timeout is earlier
190 * than an existing one, modify the timer. Round up to next nearest
193 expiry
= round_jiffies_up(req
->deadline
);
195 if (!timer_pending(&q
->timeout
) ||
196 time_before(expiry
, q
->timeout
.expires
))
197 mod_timer(&q
->timeout
, expiry
);
201 * blk_abort_queue -- Abort all request on given queue
202 * @queue: pointer to queue
205 void blk_abort_queue(struct request_queue
*q
)
208 struct request
*rq
, *tmp
;
212 * Not a request based block device, nothing to abort
217 spin_lock_irqsave(q
->queue_lock
, flags
);
222 * Splice entries to local list, to avoid deadlocking if entries
223 * get readded to the timeout list by error handling
225 list_splice_init(&q
->timeout_list
, &list
);
227 list_for_each_entry_safe(rq
, tmp
, &list
, timeout_list
)
228 blk_abort_request(rq
);
231 * Occasionally, blk_abort_request() will return without
232 * deleting the element from the list. Make sure we add those back
233 * instead of leaving them on the local stack list.
235 list_splice(&list
, &q
->timeout_list
);
237 spin_unlock_irqrestore(q
->queue_lock
, flags
);
240 EXPORT_SYMBOL_GPL(blk_abort_queue
);
This page took 0.03511 seconds and 5 git commands to generate.