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