Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
       4                 :            :  *
       5                 :            :  * This file contains spurious interrupt handling.
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/jiffies.h>
       9                 :            : #include <linux/irq.h>
      10                 :            : #include <linux/module.h>
      11                 :            : #include <linux/interrupt.h>
      12                 :            : #include <linux/moduleparam.h>
      13                 :            : #include <linux/timer.h>
      14                 :            : 
      15                 :            : #include "internals.h"
      16                 :            : 
      17                 :            : static int irqfixup __read_mostly;
      18                 :            : 
      19                 :            : #define POLL_SPURIOUS_IRQ_INTERVAL (HZ/10)
      20                 :            : static void poll_spurious_irqs(struct timer_list *unused);
      21                 :            : static DEFINE_TIMER(poll_spurious_irq_timer, poll_spurious_irqs);
      22                 :            : static int irq_poll_cpu;
      23                 :            : static atomic_t irq_poll_active;
      24                 :            : 
      25                 :            : /*
      26                 :            :  * We wait here for a poller to finish.
      27                 :            :  *
      28                 :            :  * If the poll runs on this CPU, then we yell loudly and return
      29                 :            :  * false. That will leave the interrupt line disabled in the worst
      30                 :            :  * case, but it should never happen.
      31                 :            :  *
      32                 :            :  * We wait until the poller is done and then recheck disabled and
      33                 :            :  * action (about to be disabled). Only if it's still active, we return
      34                 :            :  * true and let the handler run.
      35                 :            :  */
      36                 :          0 : bool irq_wait_for_poll(struct irq_desc *desc)
      37                 :            : {
      38                 :          0 :         if (WARN_ONCE(irq_poll_cpu == smp_processor_id(),
      39                 :            :                       "irq poll in progress on cpu %d for irq %d\n",
      40                 :            :                       smp_processor_id(), desc->irq_data.irq))
      41                 :            :                 return false;
      42                 :            : 
      43                 :            : #ifdef CONFIG_SMP
      44                 :            :         do {
      45                 :            :                 raw_spin_unlock(&desc->lock);
      46                 :          0 :                 while (irqd_irq_inprogress(&desc->irq_data))
      47                 :          0 :                         cpu_relax();
      48                 :          0 :                 raw_spin_lock(&desc->lock);
      49                 :          0 :         } while (irqd_irq_inprogress(&desc->irq_data));
      50                 :            :         /* Might have been disabled in meantime */
      51                 :          0 :         return !irqd_irq_disabled(&desc->irq_data) && desc->action;
      52                 :            : #else
      53                 :            :         return false;
      54                 :            : #endif
      55                 :            : }
      56                 :            : 
      57                 :            : 
      58                 :            : /*
      59                 :            :  * Recovery handler for misrouted interrupts.
      60                 :            :  */
      61                 :          0 : static int try_one_irq(struct irq_desc *desc, bool force)
      62                 :            : {
      63                 :            :         irqreturn_t ret = IRQ_NONE;
      64                 :            :         struct irqaction *action;
      65                 :            : 
      66                 :          0 :         raw_spin_lock(&desc->lock);
      67                 :            : 
      68                 :            :         /*
      69                 :            :          * PER_CPU, nested thread interrupts and interrupts explicitly
      70                 :            :          * marked polled are excluded from polling.
      71                 :            :          */
      72                 :          0 :         if (irq_settings_is_per_cpu(desc) ||
      73                 :          0 :             irq_settings_is_nested_thread(desc) ||
      74                 :            :             irq_settings_is_polled(desc))
      75                 :            :                 goto out;
      76                 :            : 
      77                 :            :         /*
      78                 :            :          * Do not poll disabled interrupts unless the spurious
      79                 :            :          * disabled poller asks explicitly.
      80                 :            :          */
      81                 :          0 :         if (irqd_irq_disabled(&desc->irq_data) && !force)
      82                 :            :                 goto out;
      83                 :            : 
      84                 :            :         /*
      85                 :            :          * All handlers must agree on IRQF_SHARED, so we test just the
      86                 :            :          * first.
      87                 :            :          */
      88                 :          0 :         action = desc->action;
      89                 :          0 :         if (!action || !(action->flags & IRQF_SHARED) ||
      90                 :            :             (action->flags & __IRQF_TIMER))
      91                 :            :                 goto out;
      92                 :            : 
      93                 :            :         /* Already running on another processor */
      94                 :          0 :         if (irqd_irq_inprogress(&desc->irq_data)) {
      95                 :            :                 /*
      96                 :            :                  * Already running: If it is shared get the other
      97                 :            :                  * CPU to go looking for our mystery interrupt too
      98                 :            :                  */
      99                 :          0 :                 desc->istate |= IRQS_PENDING;
     100                 :          0 :                 goto out;
     101                 :            :         }
     102                 :            : 
     103                 :            :         /* Mark it poll in progress */
     104                 :          0 :         desc->istate |= IRQS_POLL_INPROGRESS;
     105                 :            :         do {
     106                 :          0 :                 if (handle_irq_event(desc) == IRQ_HANDLED)
     107                 :            :                         ret = IRQ_HANDLED;
     108                 :            :                 /* Make sure that there is still a valid action */
     109                 :          0 :                 action = desc->action;
     110                 :          0 :         } while ((desc->istate & IRQS_PENDING) && action);
     111                 :          0 :         desc->istate &= ~IRQS_POLL_INPROGRESS;
     112                 :            : out:
     113                 :            :         raw_spin_unlock(&desc->lock);
     114                 :          0 :         return ret == IRQ_HANDLED;
     115                 :            : }
     116                 :            : 
     117                 :          0 : static int misrouted_irq(int irq)
     118                 :            : {
     119                 :            :         struct irq_desc *desc;
     120                 :            :         int i, ok = 0;
     121                 :            : 
     122                 :          0 :         if (atomic_inc_return(&irq_poll_active) != 1)
     123                 :            :                 goto out;
     124                 :            : 
     125                 :          0 :         irq_poll_cpu = smp_processor_id();
     126                 :            : 
     127                 :          0 :         for_each_irq_desc(i, desc) {
     128                 :          0 :                 if (!i)
     129                 :          0 :                          continue;
     130                 :            : 
     131                 :          0 :                 if (i == irq)   /* Already tried */
     132                 :          0 :                         continue;
     133                 :            : 
     134                 :          0 :                 if (try_one_irq(desc, false))
     135                 :            :                         ok = 1;
     136                 :            :         }
     137                 :            : out:
     138                 :            :         atomic_dec(&irq_poll_active);
     139                 :            :         /* So the caller can adjust the irq error counts */
     140                 :          0 :         return ok;
     141                 :            : }
     142                 :            : 
     143                 :          0 : static void poll_spurious_irqs(struct timer_list *unused)
     144                 :            : {
     145                 :            :         struct irq_desc *desc;
     146                 :            :         int i;
     147                 :            : 
     148                 :          0 :         if (atomic_inc_return(&irq_poll_active) != 1)
     149                 :            :                 goto out;
     150                 :          0 :         irq_poll_cpu = smp_processor_id();
     151                 :            : 
     152                 :          0 :         for_each_irq_desc(i, desc) {
     153                 :            :                 unsigned int state;
     154                 :            : 
     155                 :          0 :                 if (!i)
     156                 :          0 :                          continue;
     157                 :            : 
     158                 :            :                 /* Racy but it doesn't matter */
     159                 :          0 :                 state = desc->istate;
     160                 :          0 :                 barrier();
     161                 :          0 :                 if (!(state & IRQS_SPURIOUS_DISABLED))
     162                 :          0 :                         continue;
     163                 :            : 
     164                 :          0 :                 local_irq_disable();
     165                 :          0 :                 try_one_irq(desc, true);
     166                 :          0 :                 local_irq_enable();
     167                 :            :         }
     168                 :            : out:
     169                 :            :         atomic_dec(&irq_poll_active);
     170                 :          0 :         mod_timer(&poll_spurious_irq_timer,
     171                 :            :                   jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
     172                 :          0 : }
     173                 :            : 
     174                 :            : static inline int bad_action_ret(irqreturn_t action_ret)
     175                 :            : {
     176                 :            :         unsigned int r = action_ret;
     177                 :            : 
     178                 :          3 :         if (likely(r <= (IRQ_HANDLED | IRQ_WAKE_THREAD)))
     179                 :            :                 return 0;
     180                 :            :         return 1;
     181                 :            : }
     182                 :            : 
     183                 :            : /*
     184                 :            :  * If 99,900 of the previous 100,000 interrupts have not been handled
     185                 :            :  * then assume that the IRQ is stuck in some manner. Drop a diagnostic
     186                 :            :  * and try to turn the IRQ off.
     187                 :            :  *
     188                 :            :  * (The other 100-of-100,000 interrupts may have been a correctly
     189                 :            :  *  functioning device sharing an IRQ with the failing one)
     190                 :            :  */
     191                 :          0 : static void __report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret)
     192                 :            : {
     193                 :            :         unsigned int irq = irq_desc_get_irq(desc);
     194                 :            :         struct irqaction *action;
     195                 :            :         unsigned long flags;
     196                 :            : 
     197                 :          0 :         if (bad_action_ret(action_ret)) {
     198                 :          0 :                 printk(KERN_ERR "irq event %d: bogus return value %x\n",
     199                 :            :                                 irq, action_ret);
     200                 :            :         } else {
     201                 :          0 :                 printk(KERN_ERR "irq %d: nobody cared (try booting with "
     202                 :            :                                 "the \"irqpoll\" option)\n", irq);
     203                 :            :         }
     204                 :          0 :         dump_stack();
     205                 :          0 :         printk(KERN_ERR "handlers:\n");
     206                 :            : 
     207                 :            :         /*
     208                 :            :          * We need to take desc->lock here. note_interrupt() is called
     209                 :            :          * w/o desc->lock held, but IRQ_PROGRESS set. We might race
     210                 :            :          * with something else removing an action. It's ok to take
     211                 :            :          * desc->lock here. See synchronize_irq().
     212                 :            :          */
     213                 :          0 :         raw_spin_lock_irqsave(&desc->lock, flags);
     214                 :          0 :         for_each_action_of_desc(desc, action) {
     215                 :          0 :                 printk(KERN_ERR "[<%p>] %ps", action->handler, action->handler);
     216                 :          0 :                 if (action->thread_fn)
     217                 :          0 :                         printk(KERN_CONT " threaded [<%p>] %ps",
     218                 :            :                                         action->thread_fn, action->thread_fn);
     219                 :          0 :                 printk(KERN_CONT "\n");
     220                 :            :         }
     221                 :          0 :         raw_spin_unlock_irqrestore(&desc->lock, flags);
     222                 :          0 : }
     223                 :            : 
     224                 :            : static void report_bad_irq(struct irq_desc *desc, irqreturn_t action_ret)
     225                 :            : {
     226                 :            :         static int count = 100;
     227                 :            : 
     228                 :          0 :         if (count > 0) {
     229                 :          0 :                 count--;
     230                 :          0 :                 __report_bad_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                 :          3 :         if (!irqfixup)
     241                 :            :                 return 0;
     242                 :            : 
     243                 :            :         /* We didn't actually handle the IRQ - see if it was misrouted? */
     244                 :          0 :         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                 :          0 :         if (irqfixup < 2)
     253                 :            :                 return 0;
     254                 :            : 
     255                 :          0 :         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                 :          0 :         action = desc->action;
     265                 :          0 :         barrier();
     266                 :          0 :         return action && (action->flags & IRQF_IRQPOLL);
     267                 :            : }
     268                 :            : 
     269                 :            : #define SPURIOUS_DEFERRED       0x80000000
     270                 :            : 
     271                 :          3 : void note_interrupt(struct irq_desc *desc, irqreturn_t action_ret)
     272                 :            : {
     273                 :            :         unsigned int irq;
     274                 :            : 
     275                 :          3 :         if (desc->istate & IRQS_POLL_INPROGRESS ||
     276                 :            :             irq_settings_is_polled(desc))
     277                 :            :                 return;
     278                 :            : 
     279                 :          3 :         if (bad_action_ret(action_ret)) {
     280                 :            :                 report_bad_irq(desc, action_ret);
     281                 :            :                 return;
     282                 :            :         }
     283                 :            : 
     284                 :            :         /*
     285                 :            :          * We cannot call note_interrupt from the threaded handler
     286                 :            :          * because we need to look at the compound of all handlers
     287                 :            :          * (primary and threaded). Aside of that in the threaded
     288                 :            :          * shared case we have no serialization against an incoming
     289                 :            :          * hardware interrupt while we are dealing with a threaded
     290                 :            :          * result.
     291                 :            :          *
     292                 :            :          * So in case a thread is woken, we just note the fact and
     293                 :            :          * defer the analysis to the next hardware interrupt.
     294                 :            :          *
     295                 :            :          * The threaded handlers store whether they successfully
     296                 :            :          * handled an interrupt and we check whether that number
     297                 :            :          * changed versus the last invocation.
     298                 :            :          *
     299                 :            :          * We could handle all interrupts with the delayed by one
     300                 :            :          * mechanism, but for the non forced threaded case we'd just
     301                 :            :          * add pointless overhead to the straight hardirq interrupts
     302                 :            :          * for the sake of a few lines less code.
     303                 :            :          */
     304                 :          3 :         if (action_ret & IRQ_WAKE_THREAD) {
     305                 :            :                 /*
     306                 :            :                  * There is a thread woken. Check whether one of the
     307                 :            :                  * shared primary handlers returned IRQ_HANDLED. If
     308                 :            :                  * not we defer the spurious detection to the next
     309                 :            :                  * interrupt.
     310                 :            :                  */
     311                 :          0 :                 if (action_ret == IRQ_WAKE_THREAD) {
     312                 :            :                         int handled;
     313                 :            :                         /*
     314                 :            :                          * We use bit 31 of thread_handled_last to
     315                 :            :                          * denote the deferred spurious detection
     316                 :            :                          * active. No locking necessary as
     317                 :            :                          * thread_handled_last is only accessed here
     318                 :            :                          * and we have the guarantee that hard
     319                 :            :                          * interrupts are not reentrant.
     320                 :            :                          */
     321                 :          0 :                         if (!(desc->threads_handled_last & SPURIOUS_DEFERRED)) {
     322                 :          0 :                                 desc->threads_handled_last |= SPURIOUS_DEFERRED;
     323                 :          0 :                                 return;
     324                 :            :                         }
     325                 :            :                         /*
     326                 :            :                          * Check whether one of the threaded handlers
     327                 :            :                          * returned IRQ_HANDLED since the last
     328                 :            :                          * interrupt happened.
     329                 :            :                          *
     330                 :            :                          * For simplicity we just set bit 31, as it is
     331                 :            :                          * set in threads_handled_last as well. So we
     332                 :            :                          * avoid extra masking. And we really do not
     333                 :            :                          * care about the high bits of the handled
     334                 :            :                          * count. We just care about the count being
     335                 :            :                          * different than the one we saw before.
     336                 :            :                          */
     337                 :            :                         handled = atomic_read(&desc->threads_handled);
     338                 :          0 :                         handled |= SPURIOUS_DEFERRED;
     339                 :          0 :                         if (handled != desc->threads_handled_last) {
     340                 :            :                                 action_ret = IRQ_HANDLED;
     341                 :            :                                 /*
     342                 :            :                                  * Note: We keep the SPURIOUS_DEFERRED
     343                 :            :                                  * bit set. We are handling the
     344                 :            :                                  * previous invocation right now.
     345                 :            :                                  * Keep it for the current one, so the
     346                 :            :                                  * next hardware interrupt will
     347                 :            :                                  * account for it.
     348                 :            :                                  */
     349                 :          0 :                                 desc->threads_handled_last = handled;
     350                 :            :                         } else {
     351                 :            :                                 /*
     352                 :            :                                  * None of the threaded handlers felt
     353                 :            :                                  * responsible for the last interrupt
     354                 :            :                                  *
     355                 :            :                                  * We keep the SPURIOUS_DEFERRED bit
     356                 :            :                                  * set in threads_handled_last as we
     357                 :            :                                  * need to account for the current
     358                 :            :                                  * interrupt as well.
     359                 :            :                                  */
     360                 :            :                                 action_ret = IRQ_NONE;
     361                 :            :                         }
     362                 :            :                 } else {
     363                 :            :                         /*
     364                 :            :                          * One of the primary handlers returned
     365                 :            :                          * IRQ_HANDLED. So we don't care about the
     366                 :            :                          * threaded handlers on the same line. Clear
     367                 :            :                          * the deferred detection bit.
     368                 :            :                          *
     369                 :            :                          * In theory we could/should check whether the
     370                 :            :                          * deferred bit is set and take the result of
     371                 :            :                          * the previous run into account here as
     372                 :            :                          * well. But it's really not worth the
     373                 :            :                          * trouble. If every other interrupt is
     374                 :            :                          * handled we never trigger the spurious
     375                 :            :                          * detector. And if this is just the one out
     376                 :            :                          * of 100k unhandled ones which is handled
     377                 :            :                          * then we merily delay the spurious detection
     378                 :            :                          * by one hard interrupt. Not a real problem.
     379                 :            :                          */
     380                 :          0 :                         desc->threads_handled_last &= ~SPURIOUS_DEFERRED;
     381                 :            :                 }
     382                 :            :         }
     383                 :            : 
     384                 :          3 :         if (unlikely(action_ret == IRQ_NONE)) {
     385                 :            :                 /*
     386                 :            :                  * If we are seeing only the odd spurious IRQ caused by
     387                 :            :                  * bus asynchronicity then don't eventually trigger an error,
     388                 :            :                  * otherwise the counter becomes a doomsday timer for otherwise
     389                 :            :                  * working systems
     390                 :            :                  */
     391                 :          1 :                 if (time_after(jiffies, desc->last_unhandled + HZ/10))
     392                 :          1 :                         desc->irqs_unhandled = 1;
     393                 :            :                 else
     394                 :          1 :                         desc->irqs_unhandled++;
     395                 :          1 :                 desc->last_unhandled = jiffies;
     396                 :            :         }
     397                 :            : 
     398                 :            :         irq = irq_desc_get_irq(desc);
     399                 :          3 :         if (unlikely(try_misrouted_irq(irq, desc, action_ret))) {
     400                 :          0 :                 int ok = misrouted_irq(irq);
     401                 :          0 :                 if (action_ret == IRQ_NONE)
     402                 :          0 :                         desc->irqs_unhandled -= ok;
     403                 :            :         }
     404                 :            : 
     405                 :          3 :         desc->irq_count++;
     406                 :          3 :         if (likely(desc->irq_count < 100000))
     407                 :            :                 return;
     408                 :            : 
     409                 :          1 :         desc->irq_count = 0;
     410                 :          1 :         if (unlikely(desc->irqs_unhandled > 99900)) {
     411                 :            :                 /*
     412                 :            :                  * The interrupt is stuck
     413                 :            :                  */
     414                 :          0 :                 __report_bad_irq(desc, action_ret);
     415                 :            :                 /*
     416                 :            :                  * Now kill the IRQ
     417                 :            :                  */
     418                 :          0 :                 printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
     419                 :          0 :                 desc->istate |= IRQS_SPURIOUS_DISABLED;
     420                 :          0 :                 desc->depth++;
     421                 :          0 :                 irq_disable(desc);
     422                 :            : 
     423                 :          0 :                 mod_timer(&poll_spurious_irq_timer,
     424                 :            :                           jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
     425                 :            :         }
     426                 :          1 :         desc->irqs_unhandled = 0;
     427                 :            : }
     428                 :            : 
     429                 :            : bool noirqdebug __read_mostly;
     430                 :            : 
     431                 :          0 : int noirqdebug_setup(char *str)
     432                 :            : {
     433                 :          0 :         noirqdebug = 1;
     434                 :          0 :         printk(KERN_INFO "IRQ lockup detection disabled\n");
     435                 :            : 
     436                 :          0 :         return 1;
     437                 :            : }
     438                 :            : 
     439                 :            : __setup("noirqdebug", noirqdebug_setup);
     440                 :            : module_param(noirqdebug, bool, 0644);
     441                 :            : MODULE_PARM_DESC(noirqdebug, "Disable irq lockup detection when true");
     442                 :            : 
     443                 :          0 : static int __init irqfixup_setup(char *str)
     444                 :            : {
     445                 :          0 :         irqfixup = 1;
     446                 :          0 :         printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n");
     447                 :          0 :         printk(KERN_WARNING "This may impact system performance.\n");
     448                 :            : 
     449                 :          0 :         return 1;
     450                 :            : }
     451                 :            : 
     452                 :            : __setup("irqfixup", irqfixup_setup);
     453                 :            : module_param(irqfixup, int, 0644);
     454                 :            : 
     455                 :          0 : static int __init irqpoll_setup(char *str)
     456                 :            : {
     457                 :          0 :         irqfixup = 2;
     458                 :          0 :         printk(KERN_WARNING "Misrouted IRQ fixup and polling support "
     459                 :            :                                 "enabled\n");
     460                 :          0 :         printk(KERN_WARNING "This may significantly impact system "
     461                 :            :                                 "performance\n");
     462                 :          0 :         return 1;
     463                 :            : }
     464                 :            : 
     465                 :            : __setup("irqpoll", irqpoll_setup);