Merge branch 'for-3.11' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu into for-3.11

This is to receive percpu_refcount which will replace atomic_t
reference count in cgroup_subsys_state.

Signed-off-by: Tejun Heo <tj@kernel.org>

18 files changed, 195 insertions, 213 deletions

diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 83a2970295d1..6bd4a90d1991 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -1021,9 +1021,6 @@ static void audit_log_rule_change(char *action, struct audit_krule *rule, int re
  * @seq: netlink audit message sequence (serial) number
  * @data: payload data
  * @datasz: size of payload data
- * @loginuid: loginuid of sender
- * @sessionid: sessionid for netlink audit message
- * @sid: SE Linux Security ID of sender
  */
 int audit_receive_filter(int type, int pid, int seq, void *data, size_t datasz)
 {
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index df6814706cca..ebbfc043153f 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1688,11 +1688,14 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
                  */
                 cgroup_free_root(opts.new_root);
 
-                if (((root->flags | opts.flags) & CGRP_ROOT_SANE_BEHAVIOR) &&
-                    root->flags != opts.flags) {
-                        pr_err("cgroup: sane_behavior: new mount options should match the existing superblock\n");
-                        ret = -EINVAL;
-                        goto drop_new_super;
+                if (root->flags != opts.flags) {
+                        if ((root->flags | opts.flags) & CGRP_ROOT_SANE_BEHAVIOR) {
+                                pr_err("cgroup: sane_behavior: new mount options should match the existing superblock\n");
+                                ret = -EINVAL;
+                                goto drop_new_super;
+                        } else {
+                                pr_warning("cgroup: new mount options do not match the existing superblock, will be ignored\n");
+                        }
                 }
 
                 /* no subsys rebinding, so refcounts don't change */
diff --git a/kernel/cpu/idle.c b/kernel/cpu/idle.c
index 8b86c0c68edf..d5585f5e038e 100644
--- a/kernel/cpu/idle.c
+++ b/kernel/cpu/idle.c
@@ -40,11 +40,13 @@ __setup("hlt", cpu_idle_nopoll_setup);
 
 static inline int cpu_idle_poll(void)
 {
+        rcu_idle_enter();
         trace_cpu_idle_rcuidle(0, smp_processor_id());
         local_irq_enable();
         while (!need_resched())
                 cpu_relax();
         trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
+        rcu_idle_exit();
         return 1;
 }
 
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 6b41c1899a8b..9dc297faf7c0 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -4394,6 +4394,64 @@ perf_event_read_event(struct perf_event *event,
         perf_output_end(&handle);
 }
 
+typedef int  (perf_event_aux_match_cb)(struct perf_event *event, void *data);
+typedef void (perf_event_aux_output_cb)(struct perf_event *event, void *data);
+
+static void
+perf_event_aux_ctx(struct perf_event_context *ctx,
+                   perf_event_aux_match_cb match,
+                   perf_event_aux_output_cb output,
+                   void *data)
+{
+        struct perf_event *event;
+
+        list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
+                if (event->state < PERF_EVENT_STATE_INACTIVE)
+                        continue;
+                if (!event_filter_match(event))
+                        continue;
+                if (match(event, data))
+                        output(event, data);
+        }
+}
+
+static void
+perf_event_aux(perf_event_aux_match_cb match,
+               perf_event_aux_output_cb output,
+               void *data,
+               struct perf_event_context *task_ctx)
+{
+        struct perf_cpu_context *cpuctx;
+        struct perf_event_context *ctx;
+        struct pmu *pmu;
+        int ctxn;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(pmu, &pmus, entry) {
+                cpuctx = get_cpu_ptr(pmu->pmu_cpu_context);
+                if (cpuctx->unique_pmu != pmu)
+                        goto next;
+                perf_event_aux_ctx(&cpuctx->ctx, match, output, data);
+                if (task_ctx)
+                        goto next;
+                ctxn = pmu->task_ctx_nr;
+                if (ctxn < 0)
+                        goto next;
+                ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
+                if (ctx)
+                        perf_event_aux_ctx(ctx, match, output, data);
+next:
+                put_cpu_ptr(pmu->pmu_cpu_context);
+        }
+
+        if (task_ctx) {
+                preempt_disable();
+                perf_event_aux_ctx(task_ctx, match, output, data);
+                preempt_enable();
+        }
+        rcu_read_unlock();
+}
+
 /*
  * task tracking -- fork/exit
  *
@@ -4416,8 +4474,9 @@ struct perf_task_event {
 };
 
 static void perf_event_task_output(struct perf_event *event,
-                                     struct perf_task_event *task_event)
+                                   void *data)
 {
+        struct perf_task_event *task_event = data;
         struct perf_output_handle handle;
         struct perf_sample_data sample;
         struct task_struct *task = task_event->task;
@@ -4445,62 +4504,11 @@ out:
         task_event->event_id.header.size = size;
 }
 
-static int perf_event_task_match(struct perf_event *event)
-{
-        if (event->state < PERF_EVENT_STATE_INACTIVE)
-                return 0;
-
-        if (!event_filter_match(event))
-                return 0;
-
-        if (event->attr.comm || event->attr.mmap ||
-            event->attr.mmap_data || event->attr.task)
-                return 1;
-
-        return 0;
-}
-
-static void perf_event_task_ctx(struct perf_event_context *ctx,
-                                  struct perf_task_event *task_event)
+static int perf_event_task_match(struct perf_event *event,
+                                 void *data __maybe_unused)
 {
-        struct perf_event *event;
-
-        list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
-                if (perf_event_task_match(event))
-                        perf_event_task_output(event, task_event);
-        }
-}
-
-static void perf_event_task_event(struct perf_task_event *task_event)
-{
-        struct perf_cpu_context *cpuctx;
-        struct perf_event_context *ctx;
-        struct pmu *pmu;
-        int ctxn;
-
-        rcu_read_lock();
-        list_for_each_entry_rcu(pmu, &pmus, entry) {
-                cpuctx = get_cpu_ptr(pmu->pmu_cpu_context);
-                if (cpuctx->unique_pmu != pmu)
-                        goto next;
-                perf_event_task_ctx(&cpuctx->ctx, task_event);
-
-                ctx = task_event->task_ctx;
-                if (!ctx) {
-                        ctxn = pmu->task_ctx_nr;
-                        if (ctxn < 0)
-                                goto next;
-                        ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
-                        if (ctx)
-                                perf_event_task_ctx(ctx, task_event);
-                }
-next:
-                put_cpu_ptr(pmu->pmu_cpu_context);
-        }
-        if (task_event->task_ctx)
-                perf_event_task_ctx(task_event->task_ctx, task_event);
-
-        rcu_read_unlock();
+        return event->attr.comm || event->attr.mmap ||
+               event->attr.mmap_data || event->attr.task;
 }
 
 static void perf_event_task(struct task_struct *task,
@@ -4531,7 +4539,10 @@ static void perf_event_task(struct task_struct *task,
                 },
         };
 
-        perf_event_task_event(&task_event);
+        perf_event_aux(perf_event_task_match,
+                       perf_event_task_output,
+                       &task_event,
+                       task_ctx);
 }
 
 void perf_event_fork(struct task_struct *task)
@@ -4557,8 +4568,9 @@ struct perf_comm_event {
 };
 
 static void perf_event_comm_output(struct perf_event *event,
-                                     struct perf_comm_event *comm_event)
+                                   void *data)
 {
+        struct perf_comm_event *comm_event = data;
         struct perf_output_handle handle;
         struct perf_sample_data sample;
         int size = comm_event->event_id.header.size;
@@ -4585,39 +4597,16 @@ out:
         comm_event->event_id.header.size = size;
 }
 
-static int perf_event_comm_match(struct perf_event *event)
-{
-        if (event->state < PERF_EVENT_STATE_INACTIVE)
-                return 0;
-
-        if (!event_filter_match(event))
-                return 0;
-
-        if (event->attr.comm)
-                return 1;
-
-        return 0;
-}
-
-static void perf_event_comm_ctx(struct perf_event_context *ctx,
-                                  struct perf_comm_event *comm_event)
+static int perf_event_comm_match(struct perf_event *event,
+                                 void *data __maybe_unused)
 {
-        struct perf_event *event;
-
-        list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
-                if (perf_event_comm_match(event))
-                        perf_event_comm_output(event, comm_event);
-        }
+        return event->attr.comm;
 }
 
 static void perf_event_comm_event(struct perf_comm_event *comm_event)
 {
-        struct perf_cpu_context *cpuctx;
-        struct perf_event_context *ctx;
         char comm[TASK_COMM_LEN];
         unsigned int size;
-        struct pmu *pmu;
-        int ctxn;
 
         memset(comm, 0, sizeof(comm));
         strlcpy(comm, comm_event->task->comm, sizeof(comm));
@@ -4627,24 +4616,11 @@ static void perf_event_comm_event(struct perf_comm_event *comm_event)
         comm_event->comm_size = size;
 
         comm_event->event_id.header.size = sizeof(comm_event->event_id) + size;
-        rcu_read_lock();
-        list_for_each_entry_rcu(pmu, &pmus, entry) {
-                cpuctx = get_cpu_ptr(pmu->pmu_cpu_context);
-                if (cpuctx->unique_pmu != pmu)
-                        goto next;
-                perf_event_comm_ctx(&cpuctx->ctx, comm_event);
 
-                ctxn = pmu->task_ctx_nr;
-                if (ctxn < 0)
-                        goto next;
-
-                ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
-                if (ctx)
-                        perf_event_comm_ctx(ctx, comm_event);
-next:
-                put_cpu_ptr(pmu->pmu_cpu_context);
-        }
-        rcu_read_unlock();
+        perf_event_aux(perf_event_comm_match,
+                       perf_event_comm_output,
+                       comm_event,
+                       NULL);
 }
 
 void perf_event_comm(struct task_struct *task)
@@ -4706,8 +4682,9 @@ struct perf_mmap_event {
 };
 
 static void perf_event_mmap_output(struct perf_event *event,
-                                     struct perf_mmap_event *mmap_event)
+                                   void *data)
 {
+        struct perf_mmap_event *mmap_event = data;
         struct perf_output_handle handle;
         struct perf_sample_data sample;
         int size = mmap_event->event_id.header.size;
@@ -4734,46 +4711,24 @@ out:
 }
 
 static int perf_event_mmap_match(struct perf_event *event,
-                                   struct perf_mmap_event *mmap_event,
-                                   int executable)
-{
-        if (event->state < PERF_EVENT_STATE_INACTIVE)
-                return 0;
-
-        if (!event_filter_match(event))
-                return 0;
-
-        if ((!executable && event->attr.mmap_data) ||
-            (executable && event->attr.mmap))
-                return 1;
-
-        return 0;
-}
-
-static void perf_event_mmap_ctx(struct perf_event_context *ctx,
-                                  struct perf_mmap_event *mmap_event,
-                                  int executable)
+                                 void *data)
 {
-        struct perf_event *event;
+        struct perf_mmap_event *mmap_event = data;
+        struct vm_area_struct *vma = mmap_event->vma;
+        int executable = vma->vm_flags & VM_EXEC;
 
-        list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
-                if (perf_event_mmap_match(event, mmap_event, executable))
-                        perf_event_mmap_output(event, mmap_event);
-        }
+        return (!executable && event->attr.mmap_data) ||
+               (executable && event->attr.mmap);
 }
 
 static void perf_event_mmap_event(struct perf_mmap_event *mmap_event)
 {
-        struct perf_cpu_context *cpuctx;
-        struct perf_event_context *ctx;
         struct vm_area_struct *vma = mmap_event->vma;
         struct file *file = vma->vm_file;
         unsigned int size;
         char tmp[16];
         char *buf = NULL;
         const char *name;
-        struct pmu *pmu;
-        int ctxn;
 
         memset(tmp, 0, sizeof(tmp));
 
@@ -4829,27 +4784,10 @@ got_name:
 
         mmap_event->event_id.header.size = sizeof(mmap_event->event_id) + size;
 
-        rcu_read_lock();
-        list_for_each_entry_rcu(pmu, &pmus, entry) {
-                cpuctx = get_cpu_ptr(pmu->pmu_cpu_context);
-                if (cpuctx->unique_pmu != pmu)
-                        goto next;
-                perf_event_mmap_ctx(&cpuctx->ctx, mmap_event,
-                                        vma->vm_flags & VM_EXEC);
-
-                ctxn = pmu->task_ctx_nr;
-                if (ctxn < 0)
-                        goto next;
-
-                ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
-                if (ctx) {
-                        perf_event_mmap_ctx(ctx, mmap_event,
-                                        vma->vm_flags & VM_EXEC);
-                }
-next:
-                put_cpu_ptr(pmu->pmu_cpu_context);
-        }
-        rcu_read_unlock();
+        perf_event_aux(perf_event_mmap_match,
+                       perf_event_mmap_output,
+                       mmap_event,
+                       NULL);
 
         kfree(buf);
 }
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 1296e72e4161..8241906c4b61 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -569,6 +569,11 @@ int call_usermodehelper_exec(struct subprocess_info *sub_info, int wait)
         int retval = 0;
 
         helper_lock();
+        if (!sub_info->path) {
+                retval = -EINVAL;
+                goto out;
+        }
+
         if (sub_info->path[0] == '\0')
                 goto out;
 
diff --git a/kernel/module.c b/kernel/module.c
index b049939177f6..cab4bce49c23 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2431,10 +2431,10 @@ static void kmemleak_load_module(const struct module *mod,
         kmemleak_scan_area(mod, sizeof(struct module), GFP_KERNEL);
 
         for (i = 1; i < info->hdr->e_shnum; i++) {
-                const char *name = info->secstrings + info->sechdrs[i].sh_name;
-                if (!(info->sechdrs[i].sh_flags & SHF_ALLOC))
-                        continue;
-                if (!strstarts(name, ".data") && !strstarts(name, ".bss"))
+                /* Scan all writable sections that's not executable */
+                if (!(info->sechdrs[i].sh_flags & SHF_ALLOC) ||
+                    !(info->sechdrs[i].sh_flags & SHF_WRITE) ||
+                    (info->sechdrs[i].sh_flags & SHF_EXECINSTR))
                         continue;
 
                 kmemleak_scan_area((void *)info->sechdrs[i].sh_addr,
@@ -2769,24 +2769,11 @@ static void find_module_sections(struct module *mod, struct load_info *info)
         mod->trace_events = section_objs(info, "_ftrace_events",
                                          sizeof(*mod->trace_events),
                                          &mod->num_trace_events);
-        /*
-         * This section contains pointers to allocated objects in the trace
-         * code and not scanning it leads to false positives.
-         */
-        kmemleak_scan_area(mod->trace_events, sizeof(*mod->trace_events) *
-                           mod->num_trace_events, GFP_KERNEL);
 #endif
 #ifdef CONFIG_TRACING
         mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
                                          sizeof(*mod->trace_bprintk_fmt_start),
                                          &mod->num_trace_bprintk_fmt);
-        /*
-         * This section contains pointers to allocated objects in the trace
-         * code and not scanning it leads to false positives.
-         */
-        kmemleak_scan_area(mod->trace_bprintk_fmt_start,
-                           sizeof(*mod->trace_bprintk_fmt_start) *
-                           mod->num_trace_bprintk_fmt, GFP_KERNEL);
 #endif
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
         /* sechdrs[0].sh_size is always zero */
diff --git a/kernel/range.c b/kernel/range.c
index 071b0ab455cb..eb911dbce267 100644
--- a/kernel/range.c
+++ b/kernel/range.c
@@ -48,9 +48,11 @@ int add_range_with_merge(struct range *range, int az, int nr_range,
                 final_start = min(range[i].start, start);
                 final_end = max(range[i].end, end);
 
-                range[i].start = final_start;
-                range[i].end =  final_end;
-                return nr_range;
+                /* clear it and add it back for further merge */
+                range[i].start = 0;
+                range[i].end =  0;
+                return add_range_with_merge(range, az, nr_range,
+                        final_start, final_end);
         }
 
         /* Need to add it: */
diff --git a/kernel/rcutree_plugin.h b/kernel/rcutree_plugin.h
index 170814dc418f..3db5a375d8dd 100644
--- a/kernel/rcutree_plugin.h
+++ b/kernel/rcutree_plugin.h
@@ -88,7 +88,7 @@ static void __init rcu_bootup_announce_oddness(void)
 #ifdef CONFIG_RCU_NOCB_CPU
 #ifndef CONFIG_RCU_NOCB_CPU_NONE
         if (!have_rcu_nocb_mask) {
-                alloc_bootmem_cpumask_var(&rcu_nocb_mask);
+                zalloc_cpumask_var(&rcu_nocb_mask, GFP_KERNEL);
                 have_rcu_nocb_mask = true;
         }
 #ifdef CONFIG_RCU_NOCB_CPU_ZERO
@@ -1667,7 +1667,7 @@ int rcu_needs_cpu(int cpu, unsigned long *dj)
         rdtp->last_accelerate = jiffies;
 
         /* Request timer delay depending on laziness, and round. */
-        if (rdtp->all_lazy) {
+        if (!rdtp->all_lazy) {
                 *dj = round_up(rcu_idle_gp_delay + jiffies,
                                rcu_idle_gp_delay) - jiffies;
         } else {
diff --git a/kernel/time/Kconfig b/kernel/time/Kconfig
index e4c07b0692bb..70f27e89012b 100644
--- a/kernel/time/Kconfig
+++ b/kernel/time/Kconfig
@@ -12,11 +12,6 @@ config CLOCKSOURCE_WATCHDOG
 config ARCH_CLOCKSOURCE_DATA
         bool
 
-# Platforms has a persistent clock
-config ALWAYS_USE_PERSISTENT_CLOCK
-        bool
-        default n
-
 # Timekeeping vsyscall support
 config GENERIC_TIME_VSYSCALL
         bool
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 206bbfb34e09..24938d577669 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -786,11 +786,11 @@ bool tick_broadcast_oneshot_available(void)
 
 void __init tick_broadcast_init(void)
 {
-        alloc_cpumask_var(&tick_broadcast_mask, GFP_NOWAIT);
-        alloc_cpumask_var(&tmpmask, GFP_NOWAIT);
+        zalloc_cpumask_var(&tick_broadcast_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&tmpmask, GFP_NOWAIT);
 #ifdef CONFIG_TICK_ONESHOT
-        alloc_cpumask_var(&tick_broadcast_oneshot_mask, GFP_NOWAIT);
-        alloc_cpumask_var(&tick_broadcast_pending_mask, GFP_NOWAIT);
-        alloc_cpumask_var(&tick_broadcast_force_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&tick_broadcast_oneshot_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&tick_broadcast_pending_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&tick_broadcast_force_mask, GFP_NOWAIT);
 #endif
 }
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index bc67d4245e1d..f4208138fbf4 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -717,6 +717,7 @@ static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
         if (unlikely(!cpu_online(cpu))) {
                 if (cpu == tick_do_timer_cpu)
                         tick_do_timer_cpu = TICK_DO_TIMER_NONE;
+                return false;
         }
 
         if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
@@ -1168,7 +1169,7 @@ void tick_cancel_sched_timer(int cpu)
                 hrtimer_cancel(&ts->sched_timer);
 # endif
 
-        ts->nohz_mode = NOHZ_MODE_INACTIVE;
+        memset(ts, 0, sizeof(*ts));
 }
 #endif
 
diff --git a/kernel/timer.c b/kernel/timer.c
index a860bba34412..15ffdb3f1948 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1539,12 +1539,12 @@ static int __cpuinit init_timers_cpu(int cpu)
                         boot_done = 1;
                         base = &boot_tvec_bases;
                 }
+                spin_lock_init(&base->lock);
                 tvec_base_done[cpu] = 1;
         } else {
                 base = per_cpu(tvec_bases, cpu);
         }
 
-        spin_lock_init(&base->lock);
 
         for (j = 0; j < TVN_SIZE; j++) {
                 INIT_LIST_HEAD(base->tv5.vec + j);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index b59aea2c48c2..e444ff88f0a4 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -620,6 +620,9 @@ int ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
         if (cpu == RING_BUFFER_ALL_CPUS)
                 work = &buffer->irq_work;
         else {
+                if (!cpumask_test_cpu(cpu, buffer->cpumask))
+                        return -EINVAL;
+
                 cpu_buffer = buffer->buffers[cpu];
                 work = &cpu_buffer->irq_work;
         }
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index ae6fa2d1cdf7..4d79485b3237 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -6216,10 +6216,15 @@ __init static int tracer_alloc_buffers(void)
 
         trace_init_cmdlines();
 
-        register_tracer(&nop_trace);
-
+        /*
+         * register_tracer() might reference current_trace, so it
+         * needs to be set before we register anything. This is
+         * just a bootstrap of current_trace anyway.
+         */
         global_trace.current_trace = &nop_trace;
 
+        register_tracer(&nop_trace);
+
         /* All seems OK, enable tracing */
         tracing_disabled = 0;
 
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 7a0cf68027cc..27963e2bf4bf 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -2072,8 +2072,10 @@ event_enable_func(struct ftrace_hash *hash,
  out_reg:
         /* Don't let event modules unload while probe registered */
         ret = try_module_get(file->event_call->mod);
-        if (!ret)
+        if (!ret) {
+                ret = -EBUSY;
                 goto out_free;
+        }
 
         ret = __ftrace_event_enable_disable(file, 1, 1);
         if (ret < 0)
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index a6361178de5a..e1b653f7e1ca 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -750,7 +750,11 @@ static int filter_set_pred(struct event_filter *filter,
 
 static void __free_preds(struct event_filter *filter)
 {
+        int i;
+
         if (filter->preds) {
+                for (i = 0; i < filter->n_preds; i++)
+                        kfree(filter->preds[i].ops);
                 kfree(filter->preds);
                 filter->preds = NULL;
         }
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 636d45fe69b3..9f46e98ba8f2 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -35,7 +35,7 @@ struct trace_probe {
         const char              *symbol;        /* symbol name */
         struct ftrace_event_class       class;
         struct ftrace_event_call        call;
-        struct ftrace_event_file        **files;
+        struct ftrace_event_file * __rcu *files;
         ssize_t                 size;           /* trace entry size */
         unsigned int            nr_args;
         struct probe_arg        args[];
@@ -185,9 +185,14 @@ static struct trace_probe *find_trace_probe(const char *event,
 
 static int trace_probe_nr_files(struct trace_probe *tp)
 {
-        struct ftrace_event_file **file = tp->files;
+        struct ftrace_event_file **file;
         int ret = 0;
 
+        /*
+         * Since all tp->files updater is protected by probe_enable_lock,
+         * we don't need to lock an rcu_read_lock.
+         */
+        file = rcu_dereference_raw(tp->files);
         if (file)
                 while (*(file++))
                         ret++;
@@ -209,9 +214,10 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
         mutex_lock(&probe_enable_lock);
 
         if (file) {
-                struct ftrace_event_file **new, **old = tp->files;
+                struct ftrace_event_file **new, **old;
                 int n = trace_probe_nr_files(tp);
 
+                old = rcu_dereference_raw(tp->files);
                 /* 1 is for new one and 1 is for stopper */
                 new = kzalloc((n + 2) * sizeof(struct ftrace_event_file *),
                               GFP_KERNEL);
@@ -251,11 +257,17 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
 static int
 trace_probe_file_index(struct trace_probe *tp, struct ftrace_event_file *file)
 {
+        struct ftrace_event_file **files;
         int i;
 
-        if (tp->files) {
-                for (i = 0; tp->files[i]; i++)
-                        if (tp->files[i] == file)
+        /*
+         * Since all tp->files updater is protected by probe_enable_lock,
+         * we don't need to lock an rcu_read_lock.
+         */
+        files = rcu_dereference_raw(tp->files);
+        if (files) {
+                for (i = 0; files[i]; i++)
+                        if (files[i] == file)
                                 return i;
         }
 
@@ -274,10 +286,11 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
         mutex_lock(&probe_enable_lock);
 
         if (file) {
-                struct ftrace_event_file **new, **old = tp->files;
+                struct ftrace_event_file **new, **old;
                 int n = trace_probe_nr_files(tp);
                 int i, j;
 
+                old = rcu_dereference_raw(tp->files);
                 if (n == 0 || trace_probe_file_index(tp, file) < 0) {
                         ret = -EINVAL;
                         goto out_unlock;
@@ -872,9 +885,16 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs,
 static __kprobes void
 kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs)
 {
-        struct ftrace_event_file **file = tp->files;
+        /*
+         * Note: preempt is already disabled around the kprobe handler.
+         * However, we still need an smp_read_barrier_depends() corresponding
+         * to smp_wmb() in rcu_assign_pointer() to access the pointer.
+         */
+        struct ftrace_event_file **file = rcu_dereference_raw(tp->files);
+
+        if (unlikely(!file))
+                return;
 
-        /* Note: preempt is already disabled around the kprobe handler */
         while (*file) {
                 __kprobe_trace_func(tp, regs, *file);
                 file++;
@@ -925,9 +945,16 @@ static __kprobes void
 kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,
                      struct pt_regs *regs)
 {
-        struct ftrace_event_file **file = tp->files;
+        /*
+         * Note: preempt is already disabled around the kprobe handler.
+         * However, we still need an smp_read_barrier_depends() corresponding
+         * to smp_wmb() in rcu_assign_pointer() to access the pointer.
+         */
+        struct ftrace_event_file **file = rcu_dereference_raw(tp->files);
+
+        if (unlikely(!file))
+                return;
 
-        /* Note: preempt is already disabled around the kprobe handler */
         while (*file) {
                 __kretprobe_trace_func(tp, ri, regs, *file);
                 file++;
@@ -935,7 +962,7 @@ kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,
 }
 
 /* Event entry printers */
-enum print_line_t
+static enum print_line_t
 print_kprobe_event(struct trace_iterator *iter, int flags,
                    struct trace_event *event)
 {
@@ -971,7 +998,7 @@ partial:
         return TRACE_TYPE_PARTIAL_LINE;
 }
 
-enum print_line_t
+static enum print_line_t
 print_kretprobe_event(struct trace_iterator *iter, int flags,
                       struct trace_event *event)
 {
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 4aa9f5bc6b2d..ee8e29a2320c 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -296,7 +296,7 @@ static DEFINE_HASHTABLE(unbound_pool_hash, UNBOUND_POOL_HASH_ORDER);
 static struct workqueue_attrs *unbound_std_wq_attrs[NR_STD_WORKER_POOLS];
 
 struct workqueue_struct *system_wq __read_mostly;
-EXPORT_SYMBOL_GPL(system_wq);
+EXPORT_SYMBOL(system_wq);
 struct workqueue_struct *system_highpri_wq __read_mostly;
 EXPORT_SYMBOL_GPL(system_highpri_wq);
 struct workqueue_struct *system_long_wq __read_mostly;
@@ -1411,7 +1411,7 @@ bool queue_work_on(int cpu, struct workqueue_struct *wq,
         local_irq_restore(flags);
         return ret;
 }
-EXPORT_SYMBOL_GPL(queue_work_on);
+EXPORT_SYMBOL(queue_work_on);
 
 void delayed_work_timer_fn(unsigned long __data)
 {
@@ -1485,7 +1485,7 @@ bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
         local_irq_restore(flags);
         return ret;
 }
-EXPORT_SYMBOL_GPL(queue_delayed_work_on);
+EXPORT_SYMBOL(queue_delayed_work_on);
 
 /**
  * mod_delayed_work_on - modify delay of or queue a delayed work on specific CPU
@@ -2059,6 +2059,7 @@ static bool manage_workers(struct worker *worker)
         if (unlikely(!mutex_trylock(&pool->manager_mutex))) {
                 spin_unlock_irq(&pool->lock);
                 mutex_lock(&pool->manager_mutex);
+                spin_lock_irq(&pool->lock);
                 ret = true;
         }
 
@@ -4311,6 +4312,12 @@ bool current_is_workqueue_rescuer(void)
  * no synchronization around this function and the test result is
  * unreliable and only useful as advisory hints or for debugging.
  *
+ * If @cpu is WORK_CPU_UNBOUND, the test is performed on the local CPU.
+ * Note that both per-cpu and unbound workqueues may be associated with
+ * multiple pool_workqueues which have separate congested states.  A
+ * workqueue being congested on one CPU doesn't mean the workqueue is also
+ * contested on other CPUs / NUMA nodes.
+ *
  * RETURNS:
  * %true if congested, %false otherwise.
  */
@@ -4321,6 +4328,9 @@ bool workqueue_congested(int cpu, struct workqueue_struct *wq)
 
         rcu_read_lock_sched();
 
+        if (cpu == WORK_CPU_UNBOUND)
+                cpu = smp_processor_id();
+
         if (!(wq->flags & WQ_UNBOUND))
                 pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
         else
@@ -4895,7 +4905,8 @@ static void __init wq_numa_init(void)
         BUG_ON(!tbl);
 
         for_each_node(node)
-                BUG_ON(!alloc_cpumask_var_node(&tbl[node], GFP_KERNEL, node));
+                BUG_ON(!alloc_cpumask_var_node(&tbl[node], GFP_KERNEL,
+                                node_online(node) ? node : NUMA_NO_NODE));
 
         for_each_possible_cpu(cpu) {
                 node = cpu_to_node(cpu);