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

Pull perf updates from Ingo Molnar:
 "Features:

   - Add "uretprobes" - an optimization to uprobes, like kretprobes are
     an optimization to kprobes.  "perf probe -x file sym%return" now
     works like kretprobes.  By Oleg Nesterov.

   - Introduce per core aggregation in 'perf stat', from Stephane
     Eranian.

   - Add memory profiling via PEBS, from Stephane Eranian.

   - Event group view for 'annotate' in --stdio, --tui and --gtk, from
     Namhyung Kim.

   - Add support for AMD NB and L2I "uncore" counters, by Jacob Shin.

   - Add Ivy Bridge-EP uncore support, by Zheng Yan

   - IBM zEnterprise EC12 oprofile support patchlet from Robert Richter.

   - Add perf test entries for checking breakpoint overflow signal
     handler issues, from Jiri Olsa.

   - Add perf test entry for for checking number of EXIT events, from
     Namhyung Kim.

   - Add perf test entries for checking --cpu in record and stat, from
     Jiri Olsa.

   - Introduce perf stat --repeat forever, from Frederik Deweerdt.

   - Add --no-demangle to report/top, from Namhyung Kim.

   - PowerPC fixes plus a couple of cleanups/optimizations in uprobes
     and trace_uprobes, by Oleg Nesterov.

  Various fixes and refactorings:

   - Fix dependency of the python binding wrt libtraceevent, from
     Naohiro Aota.

   - Simplify some perf_evlist methods and to allow 'stat' to share code
     with 'record' and 'trace', by Arnaldo Carvalho de Melo.

   - Remove dead code in related to libtraceevent integration, from
     Namhyung Kim.

   - Revert "perf sched: Handle PERF_RECORD_EXIT events" to get 'perf
     sched lat' back working, by Arnaldo Carvalho de Melo

   - We don't use Newt anymore, just plain libslang, by Arnaldo Carvalho
     de Melo.

   - Kill a bunch of die() calls, from Namhyung Kim.

   - Fix build on non-glibc systems due to libio.h absence, from Cody P
     Schafer.

   - Remove some perf_session and tracing dead code, from David Ahern.

   - Honor parallel jobs, fix from Borislav Petkov

   - Introduce tools/lib/lk library, initially just removing duplication
     among tools/perf and tools/vm.  from Borislav Petkov

  ... and many more I missed to list, see the shortlog and git log for
  more details."

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (136 commits)
  perf/x86/intel/P4: Robistify P4 PMU types
  perf/x86/amd: Fix AMD NB and L2I "uncore" support
  perf/x86/amd: Remove old-style NB counter support from perf_event_amd.c
  perf/x86: Check all MSRs before passing hw check
  perf/x86/amd: Add support for AMD NB and L2I "uncore" counters
  perf/x86/intel: Add Ivy Bridge-EP uncore support
  perf/x86/intel: Fix SNB-EP CBO and PCU uncore PMU filter management
  perf/x86: Avoid kfree() in CPU_{STARTING,DYING}
  uprobes/perf: Avoid perf_trace_buf_prepare/submit if ->perf_events is empty
  uprobes/tracing: Don't pass addr=ip to perf_trace_buf_submit()
  uprobes/tracing: Change create_trace_uprobe() to support uretprobes
  uprobes/tracing: Make seq_printf() code uretprobe-friendly
  uprobes/tracing: Make register_uprobe_event() paths uretprobe-friendly
  uprobes/tracing: Make uprobe_{trace,perf}_print() uretprobe-friendly
  uprobes/tracing: Introduce is_ret_probe() and uretprobe_dispatcher()
  uprobes/tracing: Introduce uprobe_{trace,perf}_print() helpers
  uprobes/tracing: Generalize struct uprobe_trace_entry_head
  uprobes/tracing: Kill the pointless local_save_flags/preempt_count calls
  uprobes/tracing: Kill the pointless seq_print_ip_sym() call
  uprobes/tracing: Kill the pointless task_pt_regs() calls
  ...

1 files changed, 186 insertions, 0 deletions

diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c
new file mode 100644
index 000000000000..68daa289e94c
--- /dev/null
+++ b/tools/perf/tests/bp_signal.c
@@ -0,0 +1,186 @@
+/*
+ * Inspired by breakpoint overflow test done by
+ * Vince Weaver <vincent.weaver@maine.edu> for perf_event_tests
+ * (git://github.com/deater/perf_event_tests)
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <linux/compiler.h>
+#include <linux/hw_breakpoint.h>
+
+#include "tests.h"
+#include "debug.h"
+#include "perf.h"
+
+static int fd1;
+static int fd2;
+static int overflows;
+
+__attribute__ ((noinline))
+static int test_function(void)
+{
+        return time(NULL);
+}
+
+static void sig_handler(int signum __maybe_unused,
+                        siginfo_t *oh __maybe_unused,
+                        void *uc __maybe_unused)
+{
+        overflows++;
+
+        if (overflows > 10) {
+                /*
+                 * This should be executed only once during
+                 * this test, if we are here for the 10th
+                 * time, consider this the recursive issue.
+                 *
+                 * We can get out of here by disable events,
+                 * so no new SIGIO is delivered.
+                 */
+                ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
+                ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
+        }
+}
+
+static int bp_event(void *fn, int setup_signal)
+{
+        struct perf_event_attr pe;
+        int fd;
+
+        memset(&pe, 0, sizeof(struct perf_event_attr));
+        pe.type = PERF_TYPE_BREAKPOINT;
+        pe.size = sizeof(struct perf_event_attr);
+
+        pe.config = 0;
+        pe.bp_type = HW_BREAKPOINT_X;
+        pe.bp_addr = (unsigned long) fn;
+        pe.bp_len = sizeof(long);
+
+        pe.sample_period = 1;
+        pe.sample_type = PERF_SAMPLE_IP;
+        pe.wakeup_events = 1;
+
+        pe.disabled = 1;
+        pe.exclude_kernel = 1;
+        pe.exclude_hv = 1;
+
+        fd = sys_perf_event_open(&pe, 0, -1, -1, 0);
+        if (fd < 0) {
+                pr_debug("failed opening event %llx\n", pe.config);
+                return TEST_FAIL;
+        }
+
+        if (setup_signal) {
+                fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
+                fcntl(fd, F_SETSIG, SIGIO);
+                fcntl(fd, F_SETOWN, getpid());
+        }
+
+        ioctl(fd, PERF_EVENT_IOC_RESET, 0);
+
+        return fd;
+}
+
+static long long bp_count(int fd)
+{
+        long long count;
+        int ret;
+
+        ret = read(fd, &count, sizeof(long long));
+        if (ret != sizeof(long long)) {
+                pr_debug("failed to read: %d\n", ret);
+                return TEST_FAIL;
+        }
+
+        return count;
+}
+
+int test__bp_signal(void)
+{
+        struct sigaction sa;
+        long long count1, count2;
+
+        /* setup SIGIO signal handler */
+        memset(&sa, 0, sizeof(struct sigaction));
+        sa.sa_sigaction = (void *) sig_handler;
+        sa.sa_flags = SA_SIGINFO;
+
+        if (sigaction(SIGIO, &sa, NULL) < 0) {
+                pr_debug("failed setting up signal handler\n");
+                return TEST_FAIL;
+        }
+
+        /*
+         * We create following events:
+         *
+         * fd1 - breakpoint event on test_function with SIGIO
+         *       signal configured. We should get signal
+         *       notification each time the breakpoint is hit
+         *
+         * fd2 - breakpoint event on sig_handler without SIGIO
+         *       configured.
+         *
+         * Following processing should happen:
+         *   - execute test_function
+         *   - fd1 event breakpoint hit -> count1 == 1
+         *   - SIGIO is delivered       -> overflows == 1
+         *   - fd2 event breakpoint hit -> count2 == 1
+         *
+         * The test case check following error conditions:
+         * - we get stuck in signal handler because of debug
+         *   exception being triggered receursively due to
+         *   the wrong RF EFLAG management
+         *
+         * - we never trigger the sig_handler breakpoint due
+         *   to the rong RF EFLAG management
+         *
+         */
+
+        fd1 = bp_event(test_function, 1);
+        fd2 = bp_event(sig_handler, 0);
+
+        ioctl(fd1, PERF_EVENT_IOC_ENABLE, 0);
+        ioctl(fd2, PERF_EVENT_IOC_ENABLE, 0);
+
+        /*
+         * Kick off the test by trigering 'fd1'
+         * breakpoint.
+         */
+        test_function();
+
+        ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
+        ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
+
+        count1 = bp_count(fd1);
+        count2 = bp_count(fd2);
+
+        close(fd1);
+        close(fd2);
+
+        pr_debug("count1 %lld, count2 %lld, overflow %d\n",
+                 count1, count2, overflows);
+
+        if (count1 != 1) {
+                if (count1 == 11)
+                        pr_debug("failed: RF EFLAG recursion issue detected\n");
+                else
+                        pr_debug("failed: wrong count for bp1%lld\n", count1);
+        }
+
+        if (overflows != 1)
+                pr_debug("failed: wrong overflow hit\n");
+
+        if (count2 != 1)
+                pr_debug("failed: wrong count for bp2\n");
+
+        return count1 == 1 && overflows == 1 && count2 == 1 ?
+                TEST_OK : TEST_FAIL;
+}