2 files changed, 36 insertions, 15 deletions

diff --git a/include/linux/timer.h b/include/linux/timer.h
index 3f95c1fa615e..8c5a197e1587 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -49,18 +49,26 @@ extern struct tvec_base boot_tvec_bases;
 #endif
 
 /*
- * Note that all tvec_bases are 2 byte aligned and lower bit of
- * base in timer_list is guaranteed to be zero. Use the LSB to
- * indicate whether the timer is deferrable.
+ * Note that all tvec_bases are at least 4 byte aligned and lower two bits
+ * of base in timer_list is guaranteed to be zero. Use them for flags.
  *
  * A deferrable timer will work normally when the system is busy, but
  * will not cause a CPU to come out of idle just to service it; instead,
  * the timer will be serviced when the CPU eventually wakes up with a
  * subsequent non-deferrable timer.
+ *
+ * An irqsafe timer is executed with IRQ disabled and it's safe to wait for
+ * the completion of the running instance from IRQ handlers, for example,
+ * by calling del_timer_sync().
+ *
+ * Note: The irq disabled callback execution is a special case for
+ * workqueue locking issues. It's not meant for executing random crap
+ * with interrupts disabled. Abuse is monitored!
  */
 #define TIMER_DEFERRABLE                0x1LU
+#define TIMER_IRQSAFE                   0x2LU
 
-#define TIMER_FLAG_MASK                 0x1LU
+#define TIMER_FLAG_MASK                 0x3LU
 
 #define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \
                 .entry = { .prev = TIMER_ENTRY_STATIC },        \
diff --git a/kernel/timer.c b/kernel/timer.c
index 8d185a1677cc..706fe4c53e82 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -95,6 +95,11 @@ static inline unsigned int tbase_get_deferrable(struct tvec_base *base)
         return ((unsigned int)(unsigned long)base & TIMER_DEFERRABLE);
 }
 
+static inline unsigned int tbase_get_irqsafe(struct tvec_base *base)
+{
+        return ((unsigned int)(unsigned long)base & TIMER_IRQSAFE);
+}
+
 static inline struct tvec_base *tbase_get_base(struct tvec_base *base)
 {
         return ((struct tvec_base *)((unsigned long)base & ~TIMER_FLAG_MASK));
@@ -1002,14 +1007,14 @@ EXPORT_SYMBOL(try_to_del_timer_sync);
  *
  * Synchronization rules: Callers must prevent restarting of the timer,
  * otherwise this function is meaningless. It must not be called from
- * interrupt contexts. The caller must not hold locks which would prevent
- * completion of the timer's handler. The timer's handler must not call
- * add_timer_on(). Upon exit the timer is not queued and the handler is
- * not running on any CPU.
+ * interrupt contexts unless the timer is an irqsafe one. The caller must
+ * not hold locks which would prevent completion of the timer's
+ * handler. The timer's handler must not call add_timer_on(). Upon exit the
+ * timer is not queued and the handler is not running on any CPU.
  *
- * Note: You must not hold locks that are held in interrupt context
- *   while calling this function. Even if the lock has nothing to do
- *   with the timer in question.  Here's why:
+ * Note: For !irqsafe timers, you must not hold locks that are held in
+ *   interrupt context while calling this function. Even if the lock has
+ *   nothing to do with the timer in question.  Here's why:
  *
  *    CPU0                             CPU1
  *    ----                             ----
@@ -1046,7 +1051,7 @@ int del_timer_sync(struct timer_list *timer)
          * don't use it in hardirq context, because it
          * could lead to deadlock.
          */
-        WARN_ON(in_irq());
+        WARN_ON(in_irq() && !tbase_get_irqsafe(timer->base));
         for (;;) {
                 int ret = try_to_del_timer_sync(timer);
                 if (ret >= 0)
@@ -1153,19 +1158,27 @@ static inline void __run_timers(struct tvec_base *base)
                 while (!list_empty(head)) {
                         void (*fn)(unsigned long);
                         unsigned long data;
+                        bool irqsafe;
 
                         timer = list_first_entry(head, struct timer_list,entry);
                         fn = timer->function;
                         data = timer->data;
+                        irqsafe = tbase_get_irqsafe(timer->base);
 
                         timer_stats_account_timer(timer);
 
                         base->running_timer = timer;
                         detach_expired_timer(timer, base);
 
-                        spin_unlock_irq(&base->lock);
-                        call_timer_fn(timer, fn, data);
-                        spin_lock_irq(&base->lock);
+                        if (irqsafe) {
+                                spin_unlock(&base->lock);
+                                call_timer_fn(timer, fn, data);
+                                spin_lock(&base->lock);
+                        } else {
+                                spin_unlock_irq(&base->lock);
+                                call_timer_fn(timer, fn, data);
+                                spin_lock_irq(&base->lock);
+                        }
                 }
         }
         base->running_timer = NULL;