13 files changed, 142 insertions, 112 deletions

diff --git a/kernel/cpu.c b/kernel/cpu.c
index 5a732c5ef08b..8ea32e8d68b0 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -462,7 +462,7 @@ out:
  * It must be called by the arch code on the new cpu, before the new cpu
  * enables interrupts and before the "boot" cpu returns from __cpu_up().
  */
-void notify_cpu_starting(unsigned int cpu)
+void __cpuinit notify_cpu_starting(unsigned int cpu)
 {
         unsigned long val = CPU_STARTING;
 
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index c9767e641980..64c1c7253dae 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -25,6 +25,8 @@ static inline void unregister_handler_proc(unsigned int irq,
                                            struct irqaction *action) { }
 #endif
 
+extern int irq_select_affinity_usr(unsigned int irq);
+
 /*
  * Debugging printout:
  */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index c498a1b8c621..801addda3c43 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -82,24 +82,27 @@ int irq_can_set_affinity(unsigned int irq)
 int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
 {
         struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
 
         if (!desc->chip->set_affinity)
                 return -EINVAL;
 
+        spin_lock_irqsave(&desc->lock, flags);
+
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
-                unsigned long flags;
-
-                spin_lock_irqsave(&desc->lock, flags);
                 desc->affinity = cpumask;
                 desc->chip->set_affinity(irq, cpumask);
-                spin_unlock_irqrestore(&desc->lock, flags);
-        } else
-                set_pending_irq(irq, cpumask);
+        } else {
+                desc->status |= IRQ_MOVE_PENDING;
+                desc->pending_mask = cpumask;
+        }
 #else
         desc->affinity = cpumask;
         desc->chip->set_affinity(irq, cpumask);
 #endif
+        desc->status |= IRQ_AFFINITY_SET;
+        spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 
@@ -107,24 +110,59 @@ int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
 /*
  * Generic version of the affinity autoselector.
  */
-int irq_select_affinity(unsigned int irq)
+int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
 {
         cpumask_t mask;
-        struct irq_desc *desc;
 
         if (!irq_can_set_affinity(irq))
                 return 0;
 
         cpus_and(mask, cpu_online_map, irq_default_affinity);
 
-        desc = irq_to_desc(irq);
+        /*
+         * Preserve an userspace affinity setup, but make sure that
+         * one of the targets is online.
+         */
+        if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
+                if (cpus_intersects(desc->affinity, cpu_online_map))
+                        mask = desc->affinity;
+                else
+                        desc->status &= ~IRQ_AFFINITY_SET;
+        }
+
         desc->affinity = mask;
         desc->chip->set_affinity(irq, mask);
 
         return 0;
 }
+#else
+static inline int do_irq_select_affinity(unsigned int irq, struct irq_desc *d)
+{
+        return irq_select_affinity(irq);
+}
 #endif
 
+/*
+ * Called when affinity is set via /proc/irq
+ */
+int irq_select_affinity_usr(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&desc->lock, flags);
+        ret = do_irq_select_affinity(irq, desc);
+        spin_unlock_irqrestore(&desc->lock, flags);
+
+        return ret;
+}
+
+#else
+static inline int do_irq_select_affinity(int irq, struct irq_desc *desc)
+{
+        return 0;
+}
 #endif
 
 /**
@@ -327,7 +365,7 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
                  * IRQF_TRIGGER_* but the PIC does not support multiple
                  * flow-types?
                  */
-                pr_warning("No set_type function for IRQ %d (%s)\n", irq,
+                pr_debug("No set_type function for IRQ %d (%s)\n", irq,
                                 chip ? (chip->name ? : "unknown") : "unknown");
                 return 0;
         }
@@ -445,8 +483,12 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
                         /* Undo nested disables: */
                         desc->depth = 1;
 
+                /* Exclude IRQ from balancing if requested */
+                if (new->flags & IRQF_NOBALANCING)
+                        desc->status |= IRQ_NO_BALANCING;
+
                 /* Set default affinity mask once everything is setup */
-                irq_select_affinity(irq);
+                do_irq_select_affinity(irq, desc);
 
         } else if ((new->flags & IRQF_TRIGGER_MASK)
                         && (new->flags & IRQF_TRIGGER_MASK)
@@ -459,10 +501,6 @@ __setup_irq(unsigned int irq, struct irq_desc * desc, struct irqaction *new)
 
         *p = new;
 
-        /* Exclude IRQ from balancing */
-        if (new->flags & IRQF_NOBALANCING)
-                desc->status |= IRQ_NO_BALANCING;
-
         /* Reset broken irq detection when installing new handler */
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 90b920d3f52b..9db681d95814 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -1,17 +1,6 @@
 
 #include <linux/irq.h>
 
-void set_pending_irq(unsigned int irq, cpumask_t mask)
-{
-        struct irq_desc *desc = irq_to_desc(irq);
-        unsigned long flags;
-
-        spin_lock_irqsave(&desc->lock, flags);
-        desc->status |= IRQ_MOVE_PENDING;
-        desc->pending_mask = mask;
-        spin_unlock_irqrestore(&desc->lock, flags);
-}
-
 void move_masked_irq(int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 4d161c70ba55..d257e7d6a8a4 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -62,7 +62,7 @@ static ssize_t irq_affinity_proc_write(struct file *file,
         if (!cpus_intersects(new_value, cpu_online_map))
                 /* Special case for empty set - allow the architecture
                    code to set default SMP affinity. */
-                return irq_select_affinity(irq) ? -EINVAL : count;
+                return irq_select_affinity_usr(irq) ? -EINVAL : count;
 
         irq_set_affinity(irq, new_value);
 
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 06e157119d2b..46a404173db2 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -3276,10 +3276,10 @@ void __init lockdep_info(void)
 {
         printk("Lock dependency validator: Copyright (c) 2006 Red Hat, Inc., Ingo Molnar\n");
 
-        printk("... MAX_LOCKDEP_SUBCLASSES:    %lu\n", MAX_LOCKDEP_SUBCLASSES);
+        printk("... MAX_LOCKDEP_SUBCLASSES:  %lu\n", MAX_LOCKDEP_SUBCLASSES);
         printk("... MAX_LOCK_DEPTH:          %lu\n", MAX_LOCK_DEPTH);
         printk("... MAX_LOCKDEP_KEYS:        %lu\n", MAX_LOCKDEP_KEYS);
-        printk("... CLASSHASH_SIZE:           %lu\n", CLASSHASH_SIZE);
+        printk("... CLASSHASH_SIZE:          %lu\n", CLASSHASH_SIZE);
         printk("... MAX_LOCKDEP_ENTRIES:     %lu\n", MAX_LOCKDEP_ENTRIES);
         printk("... MAX_LOCKDEP_CHAINS:      %lu\n", MAX_LOCKDEP_CHAINS);
         printk("... CHAINHASH_SIZE:          %lu\n", CHAINHASH_SIZE);
diff --git a/kernel/profile.c b/kernel/profile.c
index 5b7d1ac7124c..dc41827fbfee 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -351,7 +351,7 @@ out:
         put_cpu();
 }
 
-static int __devinit profile_cpu_callback(struct notifier_block *info,
+static int __cpuinit profile_cpu_callback(struct notifier_block *info,
                                         unsigned long action, void *__cpu)
 {
         int node, cpu = (unsigned long)__cpu;
@@ -596,7 +596,7 @@ out_cleanup:
 #define create_hash_tables()                    ({ 0; })
 #endif
 
-int create_proc_profile(void)
+int __ref create_proc_profile(void) /* false positive from hotcpu_notifier */
 {
         struct proc_dir_entry *entry;
 
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 1e68e4c39e2c..4c8bcd7dd8e0 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -612,7 +612,7 @@ int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
         return (copied == sizeof(data)) ? 0 : -EIO;
 }
 
-#if defined CONFIG_COMPAT && defined __ARCH_WANT_COMPAT_SYS_PTRACE
+#if defined CONFIG_COMPAT
 #include <linux/compat.h>
 
 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
@@ -709,4 +709,4 @@ asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
         unlock_kernel();
         return ret;
 }
-#endif  /* CONFIG_COMPAT && __ARCH_WANT_COMPAT_SYS_PTRACE */
+#endif  /* CONFIG_COMPAT */
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index e60205722d0c..78db083390f0 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -326,96 +326,89 @@ ftrace_record_ip(unsigned long ip)
 
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec,
-                      unsigned char *old, unsigned char *new, int enable)
+                      unsigned char *nop, int enable)
 {
         unsigned long ip, fl;
+        unsigned char *call, *old, *new;
 
         ip = rec->ip;
 
-        if (ftrace_filtered && enable) {
+        /*
+         * If this record is not to be traced and
+         * it is not enabled then do nothing.
+         *
+         * If this record is not to be traced and
+         * it is enabled then disabled it.
+         *
+         */
+        if (rec->flags & FTRACE_FL_NOTRACE) {
+                if (rec->flags & FTRACE_FL_ENABLED)
+                        rec->flags &= ~FTRACE_FL_ENABLED;
+                else
+                        return 0;
+
+        } else if (ftrace_filtered && enable) {
                 /*
-                 * If filtering is on:
-                 *
-                 * If this record is set to be filtered and
-                 * is enabled then do nothing.
-                 *
-                 * If this record is set to be filtered and
-                 * it is not enabled, enable it.
-                 *
-                 * If this record is not set to be filtered
-                 * and it is not enabled do nothing.
-                 *
-                 * If this record is set not to trace then
-                 * do nothing.
-                 *
-                 * If this record is set not to trace and
-                 * it is enabled then disable it.
-                 *
-                 * If this record is not set to be filtered and
-                 * it is enabled, disable it.
+                 * Filtering is on:
                  */
 
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
-                                   FTRACE_FL_ENABLED);
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
 
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
-                    !fl || (fl == FTRACE_FL_NOTRACE))
+                /* Record is filtered and enabled, do nothing */
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
                         return 0;
 
-                /*
-                 * If it is enabled disable it,
-                 * otherwise enable it!
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
-                        /* swap new and old */
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* Record is not filtered and is not enabled do nothing */
+                if (!fl)
+                        return 0;
+
+                /* Record is not filtered but enabled, disable it */
+                if (fl == FTRACE_FL_ENABLED)
                         rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                else
+                /* Otherwise record is filtered but not enabled, enable it */
                         rec->flags |= FTRACE_FL_ENABLED;
-                }
         } else {
+                /* Disable or not filtered */
 
                 if (enable) {
-                        /*
-                         * If this record is set not to trace and is
-                         * not enabled, do nothing.
-                         */
-                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
-                        if (fl == FTRACE_FL_NOTRACE)
-                                return 0;
-
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
-                } else
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
-
-                if (enable) {
+                        /* if record is enabled, do nothing */
                         if (rec->flags & FTRACE_FL_ENABLED)
                                 return 0;
+
                         rec->flags |= FTRACE_FL_ENABLED;
+
                 } else {
+
+                        /* if record is not enabled do nothing */
                         if (!(rec->flags & FTRACE_FL_ENABLED))
                                 return 0;
+
                         rec->flags &= ~FTRACE_FL_ENABLED;
                 }
         }
 
+        call = ftrace_call_replace(ip, FTRACE_ADDR);
+
+        if (rec->flags & FTRACE_FL_ENABLED) {
+                old = nop;
+                new = call;
+        } else {
+                old = call;
+                new = nop;
+        }
+
         return ftrace_modify_code(ip, old, new);
 }
 
 static void ftrace_replace_code(int enable)
 {
         int i, failed;
-        unsigned char *new = NULL, *old = NULL;
+        unsigned char *nop = NULL;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
 
-        if (enable)
-                old = ftrace_nop_replace();
-        else
-                new = ftrace_nop_replace();
+        nop = ftrace_nop_replace();
 
         for (pg = ftrace_pages_start; pg; pg = pg->next) {
                 for (i = 0; i < pg->index; i++) {
@@ -433,7 +426,7 @@ static void ftrace_replace_code(int enable)
                                 unfreeze_record(rec);
                         }
 
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, nop, enable);
                         if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                 rec->flags |= FTRACE_FL_FAILED;
                                 if ((system_state == SYSTEM_BOOTING) ||
@@ -534,8 +527,7 @@ static void ftrace_startup(void)
 
         mutex_lock(&ftrace_start_lock);
         ftrace_start++;
-        if (ftrace_start == 1)
-                command |= FTRACE_ENABLE_CALLS;
+        command |= FTRACE_ENABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
                 saved_ftrace_func = ftrace_trace_function;
@@ -734,6 +726,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                     ((iter->flags & FTRACE_ITER_FAILURES) &&
                      !(rec->flags & FTRACE_FL_FAILED)) ||
 
+                    ((iter->flags & FTRACE_ITER_FILTER) &&
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
+
                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
                      !(rec->flags & FTRACE_FL_NOTRACE))) {
                         rec = NULL;
@@ -1186,7 +1181,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 
         mutex_lock(&ftrace_sysctl_lock);
         mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftrace_start && ftrace_enabled)
+        if (ftrace_start && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
         mutex_unlock(&ftrace_start_lock);
         mutex_unlock(&ftrace_sysctl_lock);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 036456cbb4f7..668bbb5ef2bd 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -617,6 +617,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 list_del_init(&page->list);
                 free_buffer_page(page);
         }
+        mutex_unlock(&buffer->mutex);
         return -ENOMEM;
 }
 
@@ -1214,7 +1215,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
 
  out:
         if (resched)
-                preempt_enable_notrace();
+                preempt_enable_no_resched_notrace();
         else
                 preempt_enable_notrace();
         return NULL;
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 697eda36b86a..d86e3252f300 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -1936,6 +1936,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         mutex_unlock(&trace_types_lock);
+        kfree(iter);
 
         return ERR_PTR(-ENOMEM);
 }
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index f28484618ff0..e62cbf78eab6 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -18,12 +18,14 @@ struct header_iter {
 
 static struct trace_array *mmio_trace_array;
 static bool overrun_detected;
+static unsigned long prev_overruns;
 
 static void mmio_reset_data(struct trace_array *tr)
 {
         int cpu;
 
         overrun_detected = false;
+        prev_overruns = 0;
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
@@ -128,16 +130,12 @@ static void mmio_close(struct trace_iterator *iter)
 
 static unsigned long count_overruns(struct trace_iterator *iter)
 {
-        int cpu;
         unsigned long cnt = 0;
-/* FIXME: */
-#if 0
-        for_each_online_cpu(cpu) {
-                cnt += iter->overrun[cpu];
-                iter->overrun[cpu] = 0;
-        }
-#endif
-        (void)cpu;
+        unsigned long over = ring_buffer_overruns(iter->tr->buffer);
+
+        if (over > prev_overruns)
+                cnt = over - prev_overruns;
+        prev_overruns = over;
         return cnt;
 }
 
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index be682b62fe58..3bdb44bde4b7 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -184,11 +184,16 @@ static struct file_operations stack_max_size_fops = {
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        long i = (long)m->private;
+        long i;
 
         (*pos)++;
 
-        i++;
+        if (v == SEQ_START_TOKEN)
+                i = 0;
+        else {
+                i = *(long *)v;
+                i++;
+        }
 
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
@@ -201,12 +206,15 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        void *t = &m->private;
+        void *t = SEQ_START_TOKEN;
         loff_t l = 0;
 
         local_irq_disable();
         __raw_spin_lock(&max_stack_lock);
 
+        if (*pos == 0)
+                return SEQ_START_TOKEN;
+
         for (; t && l < *pos; t = t_next(m, t, &l))
                 ;
 
@@ -235,10 +243,10 @@ static int trace_lookup_stack(struct seq_file *m, long i)
 
 static int t_show(struct seq_file *m, void *v)
 {
-        long i = *(long *)v;
+        long i;
         int size;
 
-        if (i < 0) {
+        if (v == SEQ_START_TOKEN) {
                 seq_printf(m, "        Depth   Size      Location"
                            "    (%d entries)\n"
                            "        -----   ----      --------\n",
@@ -246,6 +254,8 @@ static int t_show(struct seq_file *m, void *v)
                 return 0;
         }
 
+        i = *(long *)v;
+
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
                 return 0;
@@ -275,10 +285,6 @@ static int stack_trace_open(struct inode *inode, struct file *file)
         int ret;
 
         ret = seq_open(file, &stack_trace_seq_ops);
-        if (!ret) {
-                struct seq_file *m = file->private_data;
-                m->private = (void *)-1;
-        }
 
         return ret;
 }