1 /* 2 * linux/kernel/irq/spurious.c 3 * 4 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar 5 * 6 * This file contains spurious interrupt handling. 7 */ 8 9 #include <linux/jiffies.h> 10 #include <linux/irq.h> 11 #include <linux/module.h> 12 #include <linux/kallsyms.h> 13 #include <linux/interrupt.h> 14 #include <linux/moduleparam.h> 15 #include <linux/timer.h> 16 17 #include "internals.h" 18 19 static int irqfixup __read_mostly; 20 21 #define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10) 22 static void poll_spurious_irqs(unsigned long dummy); 23 static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs, 0, 0); 24 static int irq_poll_cpu; 25 static atomic_t irq_poll_active; 26 27 /* 28 * We wait here for a poller to finish. 29 * 30 * If the poll runs on this CPU, then we yell loudly and return 31 * false. That will leave the interrupt line disabled in the worst 32 * case, but it should never happen. 33 * 34 * We wait until the poller is done and then recheck disabled and 35 * action (about to be disabled). Only if it's still active, we return 36 * true and let the handler run. 37 */ 38 bool irq_wait_for_poll(struct irq_desc *desc) 39 { 40 if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), 41 "irq poll in progress on cpu %d for irq %d\n", 42 smp_processor_id(), desc->irq_data.irq)) 43 return false; 44 45 #ifdef CONFIG_SMP 46 do { 47 raw_spin_unlock(&desc->lock); 48 while (irqd_irq_inprogress(&desc->irq_data)) 49 cpu_relax(); 50 raw_spin_lock(&desc->lock); 51 } while (irqd_irq_inprogress(&desc->irq_data)); 52 /* Might have been disabled in meantime */ 53 return !irqd_irq_disabled(&desc->irq_data) && desc->action; 54 #else 55 return false; 56 #endif 57 } 58 59 60 /* 61 * Recovery handler for misrouted interrupts. 62 */ 63 static int try_one_irq(int irq, struct irq_desc *desc, bool force) 64 { 65 irqreturn_t ret = IRQ_NONE; 66 struct irqaction *action; 67 68 raw_spin_lock(&desc->lock); 69 70 /* PER_CPU and nested thread interrupts are never polled */ 71 if (irq_settings_is_per_cpu(desc) || irq_settings_is_nested_thread(desc)) 72 goto out; 73 74 /* 75 * Do not poll disabled interrupts unless the spurious 76 * disabled poller asks explicitely. 77 */ 78 if (irqd_irq_disabled(&desc->irq_data) && !force) 79 goto out; 80 81 /* 82 * All handlers must agree on IRQF_SHARED, so we test just the 83 * first. Check for action->next as well. 84 */ 85 action = desc->action; 86 if (!action || !(action->flags & IRQF_SHARED) || 87 (action->flags & __IRQF_TIMER) || 88 (action->handler(irq, action->dev_id) == IRQ_HANDLED) || 89 !action->next) 90 goto out; 91 92 /* Already running on another processor */ 93 if (irqd_irq_inprogress(&desc->irq_data)) { 94 /* 95 * Already running: If it is shared get the other 96 * CPU to go looking for our mystery interrupt too 97 */ 98 desc->istate |= IRQS_PENDING; 99 goto out; 100 } 101 102 /* Mark it poll in progress */ 103 desc->istate |= IRQS_POLL_INPROGRESS; 104 do { 105 if (handle_irq_event(desc) == IRQ_HANDLED) 106 ret = IRQ_HANDLED; 107 action = desc->action; 108 } while ((desc->istate & IRQS_PENDING) && action); 109 desc->istate &= ~IRQS_POLL_INPROGRESS; 110 out: 111 raw_spin_unlock(&desc->lock); 112 return ret == IRQ_HANDLED; 113 } 114 115 static int misrouted_irq(int irq) 116 { 117 struct irq_desc *desc; 118 int i, ok = 0; 119 120 if (atomic_inc_return(&irq_poll_active) != 1) 121 goto out; 122 123 irq_poll_cpu = smp_processor_id(); 124 125 for_each_irq_desc(i, desc) { 126 if (!i) 127 continue; 128 129 if (i == irq) /* Already tried */ 130 continue; 131 132 if (try_one_irq(i, desc, false)) 133 ok = 1; 134 } 135 out: 136 atomic_dec(&irq_poll_active); 137 /* So the caller can adjust the irq error counts */ 138 return ok; 139 } 140 141 static void poll_spurious_irqs(unsigned long dummy) 142 { 143 struct irq_desc *desc; 144 int i; 145 146 if (atomic_inc_return(&irq_poll_active) != 1) 147 goto out; 148 irq_poll_cpu = smp_processor_id(); 149 150 for_each_irq_desc(i, desc) { 151 unsigned int state; 152 153 if (!i) 154 continue; 155 156 /* Racy but it doesn't matter */ 157 state = desc->istate; 158 barrier(); 159 if (!(state & IRQS_SPURIOUS_DISABLED)) 160 continue; 161 162 local_irq_disable(); 163 try_one_irq(i, desc, true); 164 local_irq_enable(); 165 } 166 out: 167 atomic_dec(&irq_poll_active); 168 mod_timer(&poll_spurious_irq_timer, 169 jiffies + POLL_SPURIOUS_IRQ_INTERVAL); 170 } 171 172 static inline int bad_action_ret(irqreturn_t action_ret) 173 { 174 if (likely(action_ret <= (IRQ_HANDLED | IRQ_WAKE_THREAD))) 175 return 0; 176 return 1; 177 } 178 179 /* 180 * If 99,900 of the previous 100,000 interrupts have not been handled 181 * then assume that the IRQ is stuck in some manner. Drop a diagnostic 182 * and try to turn the IRQ off. 183 * 184 * (The other 100-of-100,000 interrupts may have been a correctly 185 * functioning device sharing an IRQ with the failing one) 186 */ 187 static void 188 __report_bad_irq(unsigned int irq, struct irq_desc *desc, 189 irqreturn_t action_ret) 190 { 191 struct irqaction *action; 192 unsigned long flags; 193 194 if (bad_action_ret(action_ret)) { 195 printk(KERN_ERR "irq event %d: bogus return value %x\n", 196 irq, action_ret); 197 } else { 198 printk(KERN_ERR "irq %d: nobody cared (try booting with " 199 "the \"irqpoll\" option)\n", irq); 200 } 201 dump_stack(); 202 printk(KERN_ERR "handlers:\n"); 203 204 /* 205 * We need to take desc->lock here. note_interrupt() is called 206 * w/o desc->lock held, but IRQ_PROGRESS set. We might race 207 * with something else removing an action. It's ok to take 208 * desc->lock here. See synchronize_irq(). 209 */ 210 raw_spin_lock_irqsave(&desc->lock, flags); 211 action = desc->action; 212 while (action) { 213 printk(KERN_ERR "[<%p>] %pf", action->handler, action->handler); 214 if (action->thread_fn) 215 printk(KERN_CONT " threaded [<%p>] %pf", 216 action->thread_fn, action->thread_fn); 217 printk(KERN_CONT "\n"); 218 action = action->next; 219 } 220 raw_spin_unlock_irqrestore(&desc->lock, flags); 221 } 222 223 static void 224 report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret) 225 { 226 static int count = 100; 227 228 if (count > 0) { 229 count--; 230 __report_bad_irq(irq, desc, action_ret); 231 } 232 } 233 234 static inline int 235 try_misrouted_irq(unsigned int irq, struct irq_desc *desc, 236 irqreturn_t action_ret) 237 { 238 struct irqaction *action; 239 240 if (!irqfixup) 241 return 0; 242 243 /* We didn't actually handle the IRQ - see if it was misrouted? */ 244 if (action_ret == IRQ_NONE) 245 return 1; 246 247 /* 248 * But for 'irqfixup == 2' we also do it for handled interrupts if 249 * they are marked as IRQF_IRQPOLL (or for irq zero, which is the 250 * traditional PC timer interrupt.. Legacy) 251 */ 252 if (irqfixup < 2) 253 return 0; 254 255 if (!irq) 256 return 1; 257 258 /* 259 * Since we don't get the descriptor lock, "action" can 260 * change under us. We don't really care, but we don't 261 * want to follow a NULL pointer. So tell the compiler to 262 * just load it once by using a barrier. 263 */ 264 action = desc->action; 265 barrier(); 266 return action && (action->flags & IRQF_IRQPOLL); 267 } 268 269 void note_interrupt(unsigned int irq, struct irq_desc *desc, 270 irqreturn_t action_ret) 271 { 272 if (desc->istate & IRQS_POLL_INPROGRESS) 273 return; 274 275 /* we get here again via the threaded handler */ 276 if (action_ret == IRQ_WAKE_THREAD) 277 return; 278 279 if (bad_action_ret(action_ret)) { 280 report_bad_irq(irq, desc, action_ret); 281 return; 282 } 283 284 if (unlikely(action_ret == IRQ_NONE)) { 285 /* 286 * If we are seeing only the odd spurious IRQ caused by 287 * bus asynchronicity then don't eventually trigger an error, 288 * otherwise the counter becomes a doomsday timer for otherwise 289 * working systems 290 */ 291 if (time_after(jiffies, desc->last_unhandled + HZ/10)) 292 desc->irqs_unhandled = 1; 293 else 294 desc->irqs_unhandled++; 295 desc->last_unhandled = jiffies; 296 } 297 298 if (unlikely(try_misrouted_irq(irq, desc, action_ret))) { 299 int ok = misrouted_irq(irq); 300 if (action_ret == IRQ_NONE) 301 desc->irqs_unhandled -= ok; 302 } 303 304 desc->irq_count++; 305 if (likely(desc->irq_count < 100000)) 306 return; 307 308 desc->irq_count = 0; 309 if (unlikely(desc->irqs_unhandled > 99900)) { 310 /* 311 * The interrupt is stuck 312 */ 313 __report_bad_irq(irq, desc, action_ret); 314 /* 315 * Now kill the IRQ 316 */ 317 printk(KERN_EMERG "Disabling IRQ #%d\n", irq); 318 desc->istate |= IRQS_SPURIOUS_DISABLED; 319 desc->depth++; 320 irq_disable(desc); 321 322 mod_timer(&poll_spurious_irq_timer, 323 jiffies + POLL_SPURIOUS_IRQ_INTERVAL); 324 } 325 desc->irqs_unhandled = 0; 326 } 327 328 bool noirqdebug __read_mostly; 329 330 int noirqdebug_setup(char *str) 331 { 332 noirqdebug = 1; 333 printk(KERN_INFO "IRQ lockup detection disabled\n"); 334 335 return 1; 336 } 337 338 __setup("noirqdebug", noirqdebug_setup); 339 module_param(noirqdebug, bool, 0644); 340 MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true"); 341 342 static int __init irqfixup_setup(char *str) 343 { 344 irqfixup = 1; 345 printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n"); 346 printk(KERN_WARNING "This may impact system performance.\n"); 347 348 return 1; 349 } 350 351 __setup("irqfixup", irqfixup_setup); 352 module_param(irqfixup, int, 0644); 353 354 static int __init irqpoll_setup(char *str) 355 { 356 irqfixup = 2; 357 printk(KERN_WARNING "Misrouted IRQ fixup and polling support " 358 "enabled\n"); 359 printk(KERN_WARNING "This may significantly impact system " 360 "performance\n"); 361 return 1; 362 } 363 364 __setup("irqpoll", irqpoll_setup); 365