Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf updates from Ingo Molnar:
 "Mostly tooling and PMU driver fixes, but also a number of late updates
  such as the reworking of the call-chain size limiting logic to make
  call-graph recording more robust, plus tooling side changes for the
  new 'backwards ring-buffer' extension to the perf ring-buffer"

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (34 commits)
  perf record: Read from backward ring buffer
  perf record: Rename variable to make code clear
  perf record: Prevent reading invalid data in record__mmap_read
  perf evlist: Add API to pause/resume
  perf trace: Use the ptr->name beautifier as default for "filename" args
  perf trace: Use the fd->name beautifier as default for "fd" args
  perf report: Add srcline_from/to branch sort keys
  perf evsel: Record fd into perf_mmap
  perf evsel: Add overwrite attribute and check write_backward
  perf tools: Set buildid dir under symfs when --symfs is provided
  perf trace: Only auto set call-graph to "dwarf" when syscalls are being traced
  perf annotate: Sort list of recognised instructions
  perf annotate: Fix identification of ARM blt and bls instructions
  perf tools: Fix usage of max_stack sysctl
  perf callchain: Stop validating callchains by the max_stack sysctl
  perf trace: Fix exit_group() formatting
  perf top: Use machine->kptr_restrict_warned
  perf trace: Warn when trying to resolve kernel addresses with kptr_restrict=1
  perf machine: Do not bail out if not managing to read ref reloc symbol
  perf/x86/intel/p4: Trival indentation fix, remove space
  ...

3 files changed, 36 insertions, 14 deletions

diff --git a/kernel/bpf/stackmap.c b/kernel/bpf/stackmap.c
index c8ee35287bfe..080a2dfb5800 100644
--- a/kernel/bpf/stackmap.c
+++ b/kernel/bpf/stackmap.c
@@ -136,7 +136,8 @@ u64 bpf_get_stackid(u64 r1, u64 r2, u64 flags, u64 r4, u64 r5)
                                BPF_F_FAST_STACK_CMP | BPF_F_REUSE_STACKID)))
                 return -EINVAL;
 
-        trace = get_perf_callchain(regs, init_nr, kernel, user, false, false);
+        trace = get_perf_callchain(regs, init_nr, kernel, user,
+                                   sysctl_perf_event_max_stack, false, false);
 
         if (unlikely(!trace))
                 /* couldn't fetch the stack trace */
diff --git a/kernel/events/callchain.c b/kernel/events/callchain.c
index b9325e7dcba1..179ef4640964 100644
--- a/kernel/events/callchain.c
+++ b/kernel/events/callchain.c
@@ -19,11 +19,13 @@ struct callchain_cpus_entries {
 };
 
 int sysctl_perf_event_max_stack __read_mostly = PERF_MAX_STACK_DEPTH;
+int sysctl_perf_event_max_contexts_per_stack __read_mostly = PERF_MAX_CONTEXTS_PER_STACK;
 
 static inline size_t perf_callchain_entry__sizeof(void)
 {
         return (sizeof(struct perf_callchain_entry) +
-                sizeof(__u64) * sysctl_perf_event_max_stack);
+                sizeof(__u64) * (sysctl_perf_event_max_stack +
+                                 sysctl_perf_event_max_contexts_per_stack));
 }
 
 static DEFINE_PER_CPU(int, callchain_recursion[PERF_NR_CONTEXTS]);
@@ -32,12 +34,12 @@ static DEFINE_MUTEX(callchain_mutex);
 static struct callchain_cpus_entries *callchain_cpus_entries;
 
 
-__weak void perf_callchain_kernel(struct perf_callchain_entry *entry,
+__weak void perf_callchain_kernel(struct perf_callchain_entry_ctx *entry,
                                   struct pt_regs *regs)
 {
 }
 
-__weak void perf_callchain_user(struct perf_callchain_entry *entry,
+__weak void perf_callchain_user(struct perf_callchain_entry_ctx *entry,
                                 struct pt_regs *regs)
 {
 }
@@ -176,14 +178,15 @@ perf_callchain(struct perf_event *event, struct pt_regs *regs)
         if (!kernel && !user)
                 return NULL;
 
-        return get_perf_callchain(regs, 0, kernel, user, crosstask, true);
+        return get_perf_callchain(regs, 0, kernel, user, sysctl_perf_event_max_stack, crosstask, true);
 }
 
 struct perf_callchain_entry *
 get_perf_callchain(struct pt_regs *regs, u32 init_nr, bool kernel, bool user,
-                   bool crosstask, bool add_mark)
+                   u32 max_stack, bool crosstask, bool add_mark)
 {
         struct perf_callchain_entry *entry;
+        struct perf_callchain_entry_ctx ctx;
         int rctx;
 
         entry = get_callchain_entry(&rctx);
@@ -193,12 +196,16 @@ get_perf_callchain(struct pt_regs *regs, u32 init_nr, bool kernel, bool user,
         if (!entry)
                 goto exit_put;
 
-        entry->nr = init_nr;
+        ctx.entry     = entry;
+        ctx.max_stack = max_stack;
+        ctx.nr        = entry->nr = init_nr;
+        ctx.contexts       = 0;
+        ctx.contexts_maxed = false;
 
         if (kernel && !user_mode(regs)) {
                 if (add_mark)
-                        perf_callchain_store(entry, PERF_CONTEXT_KERNEL);
-                perf_callchain_kernel(entry, regs);
+                        perf_callchain_store_context(&ctx, PERF_CONTEXT_KERNEL);
+                perf_callchain_kernel(&ctx, regs);
         }
 
         if (user) {
@@ -214,8 +221,8 @@ get_perf_callchain(struct pt_regs *regs, u32 init_nr, bool kernel, bool user,
                                 goto exit_put;
 
                         if (add_mark)
-                                perf_callchain_store(entry, PERF_CONTEXT_USER);
-                        perf_callchain_user(entry, regs);
+                                perf_callchain_store_context(&ctx, PERF_CONTEXT_USER);
+                        perf_callchain_user(&ctx, regs);
                 }
         }
 
@@ -225,10 +232,15 @@ exit_put:
         return entry;
 }
 
+/*
+ * Used for sysctl_perf_event_max_stack and
+ * sysctl_perf_event_max_contexts_per_stack.
+ */
 int perf_event_max_stack_handler(struct ctl_table *table, int write,
                                  void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        int new_value = sysctl_perf_event_max_stack, ret;
+        int *value = table->data;
+        int new_value = *value, ret;
         struct ctl_table new_table = *table;
 
         new_table.data = &new_value;
@@ -240,7 +252,7 @@ int perf_event_max_stack_handler(struct ctl_table *table, int write,
         if (atomic_read(&nr_callchain_events))
                 ret = -EBUSY;
         else
-                sysctl_perf_event_max_stack = new_value;
+                *value = new_value;
 
         mutex_unlock(&callchain_mutex);
 
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 2effd84d83e3..87b2fc38398b 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -1149,13 +1149,22 @@ static struct ctl_table kern_table[] = {
         },
         {
                 .procname       = "perf_event_max_stack",
-                .data           = NULL, /* filled in by handler */
+                .data           = &sysctl_perf_event_max_stack,
                 .maxlen         = sizeof(sysctl_perf_event_max_stack),
                 .mode           = 0644,
                 .proc_handler   = perf_event_max_stack_handler,
                 .extra1         = &zero,
                 .extra2         = &six_hundred_forty_kb,
         },
+        {
+                .procname       = "perf_event_max_contexts_per_stack",
+                .data           = &sysctl_perf_event_max_contexts_per_stack,
+                .maxlen         = sizeof(sysctl_perf_event_max_contexts_per_stack),
+                .mode           = 0644,
+                .proc_handler   = perf_event_max_stack_handler,
+                .extra1         = &zero,
+                .extra2         = &one_thousand,
+        },
 #endif
 #ifdef CONFIG_KMEMCHECK
         {