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 return init_fault_attr_dentries(&fail_io_timeout
, "fail_io_timeout");
34 late_initcall(fail_io_timeout_debugfs
);
36 ssize_t
part_timeout_show(struct device
*dev
, struct device_attribute
*attr
,
39 struct gendisk
*disk
= dev_to_disk(dev
);
40 int set
= test_bit(QUEUE_FLAG_FAIL_IO
, &disk
->queue
->queue_flags
);
42 return sprintf(buf
, "%d\n", set
!= 0);
45 ssize_t
part_timeout_store(struct device
*dev
, struct device_attribute
*attr
,
46 const char *buf
, size_t count
)
48 struct gendisk
*disk
= dev_to_disk(dev
);
52 struct request_queue
*q
= disk
->queue
;
53 char *p
= (char *) buf
;
55 val
= simple_strtoul(p
, &p
, 10);
56 spin_lock_irq(q
->queue_lock
);
58 queue_flag_set(QUEUE_FLAG_FAIL_IO
, q
);
60 queue_flag_clear(QUEUE_FLAG_FAIL_IO
, q
);
61 spin_unlock_irq(q
->queue_lock
);
67 #endif /* CONFIG_FAIL_IO_TIMEOUT */
70 * blk_delete_timer - Delete/cancel timer for a given function.
71 * @req: request that we are canceling timer for
74 void blk_delete_timer(struct request
*req
)
76 list_del_init(&req
->timeout_list
);
79 static void blk_rq_timed_out(struct request
*req
)
81 struct request_queue
*q
= req
->q
;
82 enum blk_eh_timer_return ret
;
84 ret
= q
->rq_timed_out_fn(req
);
87 __blk_complete_request(req
);
89 case BLK_EH_RESET_TIMER
:
90 blk_clear_rq_complete(req
);
93 case BLK_EH_NOT_HANDLED
:
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 void blk_rq_timed_out_timer(unsigned long data
)
109 struct request_queue
*q
= (struct request_queue
*) data
;
110 unsigned long flags
, next
= 0;
111 struct request
*rq
, *tmp
;
113 spin_lock_irqsave(q
->queue_lock
, flags
);
115 list_for_each_entry_safe(rq
, tmp
, &q
->timeout_list
, timeout_list
) {
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
))
124 blk_rq_timed_out(rq
);
125 } else if (!next
|| time_after(next
, rq
->deadline
))
130 * next can never be 0 here with the list non-empty, since we always
131 * bump ->deadline to 1 so we can detect if the timer was ever added
132 * or not. See comment in blk_add_timer()
135 mod_timer(&q
->timeout
, round_jiffies_up(next
));
137 spin_unlock_irqrestore(q
->queue_lock
, flags
);
141 * blk_abort_request -- Request request recovery for the specified command
142 * @req: pointer to the request of interest
144 * This function requests that the block layer start recovery for the
145 * request by deleting the timer and calling the q's timeout function.
146 * LLDDs who implement their own error recovery MAY ignore the timeout
147 * event if they generated blk_abort_req. Must hold queue lock.
149 void blk_abort_request(struct request
*req
)
151 if (blk_mark_rq_complete(req
))
153 blk_delete_timer(req
);
154 blk_rq_timed_out(req
);
156 EXPORT_SYMBOL_GPL(blk_abort_request
);
159 * blk_add_timer - Start timeout timer for a single request
160 * @req: request that is about to start running.
163 * Each request has its own timer, and as it is added to the queue, we
164 * set up the timer. When the request completes, we cancel the timer.
166 void blk_add_timer(struct request
*req
)
168 struct request_queue
*q
= req
->q
;
169 unsigned long expiry
;
171 if (!q
->rq_timed_out_fn
)
174 BUG_ON(!list_empty(&req
->timeout_list
));
175 BUG_ON(test_bit(REQ_ATOM_COMPLETE
, &req
->atomic_flags
));
178 * Some LLDs, like scsi, peek at the timeout to prevent a
179 * command from being retried forever.
182 req
->timeout
= q
->rq_timeout
;
184 req
->deadline
= jiffies
+ req
->timeout
;
185 list_add_tail(&req
->timeout_list
, &q
->timeout_list
);
188 * If the timer isn't already pending or this timeout is earlier
189 * than an existing one, modify the timer. Round up to next nearest
192 expiry
= round_jiffies_up(req
->deadline
);
194 if (!timer_pending(&q
->timeout
) ||
195 time_before(expiry
, q
->timeout
.expires
))
196 mod_timer(&q
->timeout
, expiry
);
200 * blk_abort_queue -- Abort all request on given queue
201 * @queue: pointer to queue
204 void blk_abort_queue(struct request_queue
*q
)
207 struct request
*rq
, *tmp
;
211 * Not a request based block device, nothing to abort
216 spin_lock_irqsave(q
->queue_lock
, flags
);
221 * Splice entries to local list, to avoid deadlocking if entries
222 * get readded to the timeout list by error handling
224 list_splice_init(&q
->timeout_list
, &list
);
226 list_for_each_entry_safe(rq
, tmp
, &list
, timeout_list
)
227 blk_abort_request(rq
);
230 * Occasionally, blk_abort_request() will return without
231 * deleting the element from the list. Make sure we add those back
232 * instead of leaving them on the local stack list.
234 list_splice(&list
, &q
->timeout_list
);
236 spin_unlock_irqrestore(q
->queue_lock
, flags
);
239 EXPORT_SYMBOL_GPL(blk_abort_queue
);
This page took 0.035312 seconds and 6 git commands to generate.