5 files changed, 64 insertions, 24 deletions

diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 801addda3c43..e9d1c8205a3b 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -673,6 +673,18 @@ int request_irq(unsigned int irq, irq_handler_t handler,
         struct irq_desc *desc;
         int retval;
 
+        /*
+         * handle_IRQ_event() always ignores IRQF_DISABLED except for
+         * the _first_ irqaction (sigh).  That can cause oopsing, but
+         * the behavior is classified as "will not fix" so we need to
+         * start nudging drivers away from using that idiom.
+         */
+        if ((irqflags & (IRQF_SHARED|IRQF_DISABLED))
+                        == (IRQF_SHARED|IRQF_DISABLED))
+                pr_warning("IRQ %d/%s: IRQF_DISABLED is not "
+                                "guaranteed on shared IRQs\n",
+                                irq, devname);
+
 #ifdef CONFIG_LOCKDEP
         /*
          * Lockdep wants atomic interrupt handlers:
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 46a404173db2..90f3fb64dbce 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -136,16 +136,16 @@ static inline struct lock_class *hlock_class(struct held_lock *hlock)
 #ifdef CONFIG_LOCK_STAT
 static DEFINE_PER_CPU(struct lock_class_stats[MAX_LOCKDEP_KEYS], lock_stats);
 
-static int lock_contention_point(struct lock_class *class, unsigned long ip)
+static int lock_point(unsigned long points[], unsigned long ip)
 {
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
-                if (class->contention_point[i] == 0) {
-                        class->contention_point[i] = ip;
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
+                if (points[i] == 0) {
+                        points[i] = ip;
                         break;
                 }
-                if (class->contention_point[i] == ip)
+                if (points[i] == ip)
                         break;
         }
 
@@ -185,6 +185,9 @@ struct lock_class_stats lock_stats(struct lock_class *class)
                 for (i = 0; i < ARRAY_SIZE(stats.contention_point); i++)
                         stats.contention_point[i] += pcs->contention_point[i];
 
+                for (i = 0; i < ARRAY_SIZE(stats.contending_point); i++)
+                        stats.contending_point[i] += pcs->contending_point[i];
+
                 lock_time_add(&pcs->read_waittime, &stats.read_waittime);
                 lock_time_add(&pcs->write_waittime, &stats.write_waittime);
 
@@ -209,6 +212,7 @@ void clear_lock_stats(struct lock_class *class)
                 memset(cpu_stats, 0, sizeof(struct lock_class_stats));
         }
         memset(class->contention_point, 0, sizeof(class->contention_point));
+        memset(class->contending_point, 0, sizeof(class->contending_point));
 }
 
 static struct lock_class_stats *get_lock_stats(struct lock_class *class)
@@ -576,7 +580,8 @@ static void print_lock_class_header(struct lock_class *class, int depth)
 /*
  * printk all lock dependencies starting at <entry>:
  */
-static void print_lock_dependencies(struct lock_class *class, int depth)
+static void __used
+print_lock_dependencies(struct lock_class *class, int depth)
 {
         struct lock_list *entry;
 
@@ -2999,7 +3004,7 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
         struct held_lock *hlock, *prev_hlock;
         struct lock_class_stats *stats;
         unsigned int depth;
-        int i, point;
+        int i, contention_point, contending_point;
 
         depth = curr->lockdep_depth;
         if (DEBUG_LOCKS_WARN_ON(!depth))
@@ -3023,18 +3028,22 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
 found_it:
         hlock->waittime_stamp = sched_clock();
 
-        point = lock_contention_point(hlock_class(hlock), ip);
+        contention_point = lock_point(hlock_class(hlock)->contention_point, ip);
+        contending_point = lock_point(hlock_class(hlock)->contending_point,
+                                      lock->ip);
 
         stats = get_lock_stats(hlock_class(hlock));
-        if (point < ARRAY_SIZE(stats->contention_point))
-                stats->contention_point[point]++;
+        if (contention_point < LOCKSTAT_POINTS)
+                stats->contention_point[contention_point]++;
+        if (contending_point < LOCKSTAT_POINTS)
+                stats->contending_point[contending_point]++;
         if (lock->cpu != smp_processor_id())
                 stats->bounces[bounce_contended + !!hlock->read]++;
         put_lock_stats(stats);
 }
 
 static void
-__lock_acquired(struct lockdep_map *lock)
+__lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
         struct task_struct *curr = current;
         struct held_lock *hlock, *prev_hlock;
@@ -3083,6 +3092,7 @@ found_it:
         put_lock_stats(stats);
 
         lock->cpu = cpu;
+        lock->ip = ip;
 }
 
 void lock_contended(struct lockdep_map *lock, unsigned long ip)
@@ -3104,7 +3114,7 @@ void lock_contended(struct lockdep_map *lock, unsigned long ip)
 }
 EXPORT_SYMBOL_GPL(lock_contended);
 
-void lock_acquired(struct lockdep_map *lock)
+void lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
         unsigned long flags;
 
@@ -3117,7 +3127,7 @@ void lock_acquired(struct lockdep_map *lock)
         raw_local_irq_save(flags);
         check_flags(flags);
         current->lockdep_recursion = 1;
-        __lock_acquired(lock);
+        __lock_acquired(lock, ip);
         current->lockdep_recursion = 0;
         raw_local_irq_restore(flags);
 }
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index 20dbcbf9c7dd..13716b813896 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -470,11 +470,12 @@ static void seq_line(struct seq_file *m, char c, int offset, int length)
 
 static void snprint_time(char *buf, size_t bufsiz, s64 nr)
 {
-        unsigned long rem;
+        s64 div;
+        s32 rem;
 
         nr += 5; /* for display rounding */
-        rem = do_div(nr, 1000); /* XXX: do_div_signed */
-        snprintf(buf, bufsiz, "%lld.%02d", (long long)nr, (int)rem/10);
+        div = div_s64_rem(nr, 1000, &rem);
+        snprintf(buf, bufsiz, "%lld.%02d", (long long)div, (int)rem/10);
 }
 
 static void seq_time(struct seq_file *m, s64 time)
@@ -556,7 +557,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
         if (stats->read_holdtime.nr)
                 namelen += 2;
 
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
                 char sym[KSYM_SYMBOL_LEN];
                 char ip[32];
 
@@ -573,6 +574,23 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
                                 stats->contention_point[i],
                                 ip, sym);
         }
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
+                char sym[KSYM_SYMBOL_LEN];
+                char ip[32];
+
+                if (class->contending_point[i] == 0)
+                        break;
+
+                if (!i)
+                        seq_line(m, '-', 40-namelen, namelen);
+
+                sprint_symbol(sym, class->contending_point[i]);
+                snprintf(ip, sizeof(ip), "[<%p>]",
+                                (void *)class->contending_point[i]);
+                seq_printf(m, "%40s %14lu %29s %s\n", name,
+                                stats->contending_point[i],
+                                ip, sym);
+        }
         if (i) {
                 seq_puts(m, "\n");
                 seq_line(m, '.', 0, 40 + 1 + 10 * (14 + 1));
@@ -582,7 +600,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
 
 static void seq_header(struct seq_file *m)
 {
-        seq_printf(m, "lock_stat version 0.2\n");
+        seq_printf(m, "lock_stat version 0.3\n");
         seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
         seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
                         "%14s %14s\n",
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 12c779dc65d4..4f45d4b658ef 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -59,7 +59,7 @@ EXPORT_SYMBOL(__mutex_init);
  * We also put the fastpath first in the kernel image, to make sure the
  * branch is predicted by the CPU as default-untaken.
  */
-static void noinline __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count);
 
 /***
@@ -96,7 +96,7 @@ void inline __sched mutex_lock(struct mutex *lock)
 EXPORT_SYMBOL(mutex_lock);
 #endif
 
-static noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
+static __used noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
 
 /***
  * mutex_unlock - release the mutex
@@ -184,7 +184,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
         }
 
 done:
-        lock_acquired(&lock->dep_map);
+        lock_acquired(&lock->dep_map, ip);
         /* got the lock - rejoice! */
         mutex_remove_waiter(lock, &waiter, task_thread_info(task));
         debug_mutex_set_owner(lock, task_thread_info(task));
@@ -268,7 +268,7 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
 /*
  * Release the lock, slowpath:
  */
-static noinline void
+static __used noinline void
 __mutex_unlock_slowpath(atomic_t *lock_count)
 {
         __mutex_unlock_common_slowpath(lock_count, 1);
@@ -313,7 +313,7 @@ int __sched mutex_lock_killable(struct mutex *lock)
 }
 EXPORT_SYMBOL(mutex_lock_killable);
 
-static noinline void __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count)
 {
         struct mutex *lock = container_of(lock_count, struct mutex, count);
diff --git a/kernel/sched.c b/kernel/sched.c
index b7480fb5c3dc..1b8f8c3aecc4 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4339,7 +4339,7 @@ void __kprobes sub_preempt_count(int val)
         /*
          * Underflow?
          */
-        if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
+       if (DEBUG_LOCKS_WARN_ON(val > preempt_count() - (!!kernel_locked())))
                 return;
         /*
          * Is the spinlock portion underflowing?