12 files changed, 215 insertions, 91 deletions

diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 52462ae2645..e032716c839 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -61,6 +61,9 @@ OPTIONS
 -r::
 --realtime=::
         Collect data with this RT SCHED_FIFO priority.
+-D::
+--no-delay::
+        Collect data without buffering.
 -A::
 --append::
         Append to the output file to do incremental profiling.
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 1b9b13ee2a7..2b5387d53ba 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -227,7 +227,7 @@ ifndef PERF_DEBUG
   CFLAGS_OPTIMIZE = -O6
 endif
 
-CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
+CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
 ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 7bc04903548..fcd29e8af29 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -49,6 +49,7 @@ static int			pipe_output			=      0;
 static const char               *output_name                    = "perf.data";
 static int                      group                           =      0;
 static int                      realtime_prio                   =      0;
+static bool                     nodelay                         =  false;
 static bool                     raw_samples                     =  false;
 static bool                     sample_id_all_avail             =   true;
 static bool                     system_wide                     =  false;
@@ -307,6 +308,11 @@ static void create_counter(struct perf_evsel *evsel, int cpu)
                 attr->sample_type       |= PERF_SAMPLE_CPU;
         }
 
+        if (nodelay) {
+                attr->watermark = 0;
+                attr->wakeup_events = 1;
+        }
+
         attr->mmap              = track;
         attr->comm              = track;
         attr->inherit           = !no_inherit;
@@ -477,6 +483,7 @@ static void atexit_header(void)
                         process_buildids();
                 perf_header__write(&session->header, output, true);
                 perf_session__delete(session);
+                perf_evsel_list__delete();
                 symbol__exit();
         }
 }
@@ -842,6 +849,8 @@ const struct option record_options[] = {
                     "record events on existing thread id"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
+        OPT_BOOLEAN('D', "no-delay", &nodelay,
+                    "collect data without buffering"),
         OPT_BOOLEAN('R', "raw-samples", &raw_samples,
                     "collect raw sample records from all opened counters"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
@@ -927,6 +936,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         list_for_each_entry(pos, &evsel_list, node) {
                 if (perf_evsel__alloc_fd(pos, cpus->nr, threads->nr) < 0)
                         goto out_free_fd;
+                if (perf_header__push_event(pos->attr.config, event_name(pos)))
+                        goto out_free_fd;
         }
         event_array = malloc((sizeof(struct pollfd) * MAX_NR_CPUS *
                               MAX_COUNTERS * threads->nr));
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 7a4ebeb8b01..29e7ffd8569 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -489,7 +489,8 @@ static void create_tasks(void)
 
         err = pthread_attr_init(&attr);
         BUG_ON(err);
-        err = pthread_attr_setstacksize(&attr, (size_t)(16*1024));
+        err = pthread_attr_setstacksize(&attr,
+                        (size_t) max(16 * 1024, PTHREAD_STACK_MIN));
         BUG_ON(err);
         err = pthread_mutex_lock(&start_work_mutex);
         BUG_ON(err);
@@ -1842,15 +1843,15 @@ static const char *record_args[] = {
         "-f",
         "-m", "1024",
         "-c", "1",
-        "-e", "sched:sched_switch:r",
-        "-e", "sched:sched_stat_wait:r",
-        "-e", "sched:sched_stat_sleep:r",
-        "-e", "sched:sched_stat_iowait:r",
-        "-e", "sched:sched_stat_runtime:r",
-        "-e", "sched:sched_process_exit:r",
-        "-e", "sched:sched_process_fork:r",
-        "-e", "sched:sched_wakeup:r",
-        "-e", "sched:sched_migrate_task:r",
+        "-e", "sched:sched_switch",
+        "-e", "sched:sched_stat_wait",
+        "-e", "sched:sched_stat_sleep",
+        "-e", "sched:sched_stat_iowait",
+        "-e", "sched:sched_stat_runtime",
+        "-e", "sched:sched_process_exit",
+        "-e", "sched:sched_process_fork",
+        "-e", "sched:sched_wakeup",
+        "-e", "sched:sched_migrate_task",
 };
 
 static int __cmd_record(int argc, const char **argv)
@@ -1861,7 +1862,7 @@ static int __cmd_record(int argc, const char **argv)
         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 
-        if (rec_argv)
+        if (rec_argv == NULL)
                 return -ENOMEM;
 
         for (i = 0; i < ARRAY_SIZE(record_args); i++)
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 02b2d8013a6..0ff11d9b13b 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -316,6 +316,8 @@ static int run_perf_stat(int argc __used, const char **argv)
                                       "\t Consider tweaking"
                                       " /proc/sys/kernel/perf_event_paranoid or running as root.",
                                       system_wide ? "system-wide " : "");
+                        } else if (errno == ENOENT) {
+                                error("%s event is not supported. ", event_name(counter));
                         } else {
                                 error("open_counter returned with %d (%s). "
                                       "/bin/dmesg may provide additional information.\n",
@@ -683,8 +685,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 nr_counters = ARRAY_SIZE(default_attrs);
 
                 for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
-                        pos = perf_evsel__new(default_attrs[c].type,
-                                              default_attrs[c].config,
+                        pos = perf_evsel__new(&default_attrs[c],
                                               nr_counters);
                         if (pos == NULL)
                                 goto out;
@@ -742,6 +743,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
 out_free_fd:
         list_for_each_entry(pos, &evsel_list, node)
                 perf_evsel__free_stat_priv(pos);
+        perf_evsel_list__delete();
 out:
         thread_map__delete(threads);
         threads = NULL;
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 1c984342a57..ed5696198d3 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -234,6 +234,7 @@ out:
         return err;
 }
 
+#include "util/cpumap.h"
 #include "util/evsel.h"
 #include <sys/types.h>
 
@@ -264,6 +265,7 @@ static int test__open_syscall_event(void)
         int err = -1, fd;
         struct thread_map *threads;
         struct perf_evsel *evsel;
+        struct perf_event_attr attr;
         unsigned int nr_open_calls = 111, i;
         int id = trace_event__id("sys_enter_open");
 
@@ -278,7 +280,10 @@ static int test__open_syscall_event(void)
                 return -1;
         }
 
-        evsel = perf_evsel__new(PERF_TYPE_TRACEPOINT, id, 0);
+        memset(&attr, 0, sizeof(attr));
+        attr.type = PERF_TYPE_TRACEPOINT;
+        attr.config = id;
+        evsel = perf_evsel__new(&attr, 0);
         if (evsel == NULL) {
                 pr_debug("perf_evsel__new\n");
                 goto out_thread_map_delete;
@@ -317,6 +322,111 @@ out_thread_map_delete:
         return err;
 }
 
+#include <sched.h>
+
+static int test__open_syscall_event_on_all_cpus(void)
+{
+        int err = -1, fd, cpu;
+        struct thread_map *threads;
+        struct cpu_map *cpus;
+        struct perf_evsel *evsel;
+        struct perf_event_attr attr;
+        unsigned int nr_open_calls = 111, i;
+        cpu_set_t *cpu_set;
+        size_t cpu_set_size;
+        int id = trace_event__id("sys_enter_open");
+
+        if (id < 0) {
+                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                return -1;
+        }
+
+        threads = thread_map__new(-1, getpid());
+        if (threads == NULL) {
+                pr_debug("thread_map__new\n");
+                return -1;
+        }
+
+        cpus = cpu_map__new(NULL);
+        if (threads == NULL) {
+                pr_debug("thread_map__new\n");
+                return -1;
+        }
+
+        cpu_set = CPU_ALLOC(cpus->nr);
+
+        if (cpu_set == NULL)
+                goto out_thread_map_delete;
+
+        cpu_set_size = CPU_ALLOC_SIZE(cpus->nr);
+        CPU_ZERO_S(cpu_set_size, cpu_set);
+
+        memset(&attr, 0, sizeof(attr));
+        attr.type = PERF_TYPE_TRACEPOINT;
+        attr.config = id;
+        evsel = perf_evsel__new(&attr, 0);
+        if (evsel == NULL) {
+                pr_debug("perf_evsel__new\n");
+                goto out_cpu_free;
+        }
+
+        if (perf_evsel__open(evsel, cpus, threads) < 0) {
+                pr_debug("failed to open counter: %s, "
+                         "tweak /proc/sys/kernel/perf_event_paranoid?\n",
+                         strerror(errno));
+                goto out_evsel_delete;
+        }
+
+        for (cpu = 0; cpu < cpus->nr; ++cpu) {
+                unsigned int ncalls = nr_open_calls + cpu;
+
+                CPU_SET(cpu, cpu_set);
+                sched_setaffinity(0, cpu_set_size, cpu_set);
+                for (i = 0; i < ncalls; ++i) {
+                        fd = open("/etc/passwd", O_RDONLY);
+                        close(fd);
+                }
+                CPU_CLR(cpu, cpu_set);
+        }
+
+        /*
+         * Here we need to explicitely preallocate the counts, as if
+         * we use the auto allocation it will allocate just for 1 cpu,
+         * as we start by cpu 0.
+         */
+        if (perf_evsel__alloc_counts(evsel, cpus->nr) < 0) {
+                pr_debug("perf_evsel__alloc_counts(ncpus=%d)\n", cpus->nr);
+                goto out_close_fd;
+        }
+
+        for (cpu = 0; cpu < cpus->nr; ++cpu) {
+                unsigned int expected;
+
+                if (perf_evsel__read_on_cpu(evsel, cpu, 0) < 0) {
+                        pr_debug("perf_evsel__open_read_on_cpu\n");
+                        goto out_close_fd;
+                }
+
+                expected = nr_open_calls + cpu;
+                if (evsel->counts->cpu[cpu].val != expected) {
+                        pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls on cpu %d, got %Ld\n",
+                                 expected, cpu, evsel->counts->cpu[cpu].val);
+                        goto out_close_fd;
+                }
+        }
+
+        err = 0;
+out_close_fd:
+        perf_evsel__close_fd(evsel, 1, threads->nr);
+out_evsel_delete:
+        perf_evsel__delete(evsel);
+out_cpu_free:
+        CPU_FREE(cpu_set);
+out_thread_map_delete:
+        thread_map__delete(threads);
+        return err;
+}
+
 static struct test {
         const char *desc;
         int (*func)(void);
@@ -330,6 +440,10 @@ static struct test {
                 .func = test__open_syscall_event,
         },
         {
+                .desc = "detect open syscall event on all cpus",
+                .func = test__open_syscall_event_on_all_cpus,
+        },
+        {
                 .func = NULL,
         },
 };
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 1e67ab9c7eb..05344c6210a 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -1471,6 +1471,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 pos->attr.sample_period = default_interval;
         }
 
+        sym_evsel = list_entry(evsel_list.next, struct perf_evsel, node);
+
         symbol_conf.priv_size = (sizeof(struct sym_entry) +
                                  (nr_counters + 1) * sizeof(unsigned long));
 
@@ -1488,6 +1490,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 out_free_fd:
         list_for_each_entry(pos, &evsel_list, node)
                 perf_evsel__free_mmap(pos);
+        perf_evsel_list__delete();
 
         return status;
 }
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 5b1ecd66bb3..595d0f4a710 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -286,8 +286,6 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         status = p->fn(argc, argv, prefix);
         exit_browser(status);
 
-        perf_evsel_list__delete();
-
         if (status)
                 return status & 0xff;
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index c95267e63c5..f5cfed60af9 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -6,14 +6,13 @@
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 
-struct perf_evsel *perf_evsel__new(u32 type, u64 config, int idx)
+struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
 {
         struct perf_evsel *evsel = zalloc(sizeof(*evsel));
 
         if (evsel != NULL) {
                 evsel->idx         = idx;
-                evsel->attr.type   = type;
-                evsel->attr.config = config;
+                evsel->attr        = *attr;
                 INIT_LIST_HEAD(&evsel->node);
         }
 
@@ -128,59 +127,75 @@ int __perf_evsel__read(struct perf_evsel *evsel,
         return 0;
 }
 
-int perf_evsel__open_per_cpu(struct perf_evsel *evsel, struct cpu_map *cpus)
+static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
+                              struct thread_map *threads)
 {
-        int cpu;
+        int cpu, thread;
 
-        if (evsel->fd == NULL && perf_evsel__alloc_fd(evsel, cpus->nr, 1) < 0)
+        if (evsel->fd == NULL &&
+            perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
                 return -1;
 
         for (cpu = 0; cpu < cpus->nr; cpu++) {
-                FD(evsel, cpu, 0) = sys_perf_event_open(&evsel->attr, -1,
-                                                        cpus->map[cpu], -1, 0);
-                if (FD(evsel, cpu, 0) < 0)
-                        goto out_close;
+                for (thread = 0; thread < threads->nr; thread++) {
+                        FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
+                                                                     threads->map[thread],
+                                                                     cpus->map[cpu], -1, 0);
+                        if (FD(evsel, cpu, thread) < 0)
+                                goto out_close;
+                }
         }
 
         return 0;
 
 out_close:
-        while (--cpu >= 0) {
-                close(FD(evsel, cpu, 0));
-                FD(evsel, cpu, 0) = -1;
-        }
+        do {
+                while (--thread >= 0) {
+                        close(FD(evsel, cpu, thread));
+                        FD(evsel, cpu, thread) = -1;
+                }
+                thread = threads->nr;
+        } while (--cpu >= 0);
         return -1;
 }
 
-int perf_evsel__open_per_thread(struct perf_evsel *evsel, struct thread_map *threads)
+static struct {
+        struct cpu_map map;
+        int cpus[1];
+} empty_cpu_map = {
+        .map.nr = 1,
+        .cpus   = { -1, },
+};
+
+static struct {
+        struct thread_map map;
+        int threads[1];
+} empty_thread_map = {
+        .map.nr  = 1,
+        .threads = { -1, },
+};
+
+int perf_evsel__open(struct perf_evsel *evsel,
+                     struct cpu_map *cpus, struct thread_map *threads)
 {
-        int thread;
-
-        if (evsel->fd == NULL && perf_evsel__alloc_fd(evsel, 1, threads->nr))
-                return -1;
 
-        for (thread = 0; thread < threads->nr; thread++) {
-                FD(evsel, 0, thread) = sys_perf_event_open(&evsel->attr,
-                                                           threads->map[thread], -1, -1, 0);
-                if (FD(evsel, 0, thread) < 0)
-                        goto out_close;
+        if (cpus == NULL) {
+                /* Work around old compiler warnings about strict aliasing */
+                cpus = &empty_cpu_map.map;
         }
 
-        return 0;
+        if (threads == NULL)
+                threads = &empty_thread_map.map;
 
-out_close:
-        while (--thread >= 0) {
-                close(FD(evsel, 0, thread));
-                FD(evsel, 0, thread) = -1;
-        }
-        return -1;
+        return __perf_evsel__open(evsel, cpus, threads);
 }
 
-int perf_evsel__open(struct perf_evsel *evsel, 
-                     struct cpu_map *cpus, struct thread_map *threads)
+int perf_evsel__open_per_cpu(struct perf_evsel *evsel, struct cpu_map *cpus)
 {
-        if (threads == NULL)
-                return perf_evsel__open_per_cpu(evsel, cpus);
+        return __perf_evsel__open(evsel, cpus, &empty_thread_map.map);
+}
 
-        return perf_evsel__open_per_thread(evsel, threads);
+int perf_evsel__open_per_thread(struct perf_evsel *evsel, struct thread_map *threads)
+{
+        return __perf_evsel__open(evsel, &empty_cpu_map.map, threads);
 }
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index a0ccd69c3fc..b2d755fe88a 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -37,7 +37,7 @@ struct perf_evsel {
 struct cpu_map;
 struct thread_map;
 
-struct perf_evsel *perf_evsel__new(u32 type, u64 config, int idx);
+struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx);
 void perf_evsel__delete(struct perf_evsel *evsel);
 
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 649083f27e0..bc2732ee23e 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -490,7 +490,6 @@ parse_multiple_tracepoint_event(char *sys_name, const char *evt_exp,
         return EVT_HANDLED_ALL;
 }
 
-
 static enum event_result parse_tracepoint_event(const char **strp,
                                     struct perf_event_attr *attr)
 {
@@ -530,12 +529,13 @@ static enum event_result parse_tracepoint_event(const char **strp,
         if (evt_length >= MAX_EVENT_LENGTH)
                 return EVT_FAILED;
         if (strpbrk(evt_name, "*?")) {
-                *strp += strlen(sys_name) + evt_length;
+                *strp += strlen(sys_name) + evt_length + 1; /* 1 == the ':' */
                 return parse_multiple_tracepoint_event(sys_name, evt_name,
                                                        flags);
-        } else
+        } else {
                 return parse_single_tracepoint_event(sys_name, evt_name,
                                                      evt_length, attr, strp);
+        }
 }
 
 static enum event_result
@@ -778,41 +778,11 @@ modifier:
         return ret;
 }
 
-static int store_event_type(const char *orgname)
-{
-        char filename[PATH_MAX], *c;
-        FILE *file;
-        int id, n;
-
-        sprintf(filename, "%s/", debugfs_path);
-        strncat(filename, orgname, strlen(orgname));
-        strcat(filename, "/id");
-
-        c = strchr(filename, ':');
-        if (c)
-                *c = '/';
-
-        file = fopen(filename, "r");
-        if (!file)
-                return 0;
-        n = fscanf(file, "%i", &id);
-        fclose(file);
-        if (n < 1) {
-                pr_err("cannot store event ID\n");
-                return -EINVAL;
-        }
-        return perf_header__push_event(id, orgname);
-}
-
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
         struct perf_event_attr attr;
         enum event_result ret;
 
-        if (strchr(str, ':'))
-                if (store_event_type(str) < 0)
-                        return -1;
-
         for (;;) {
                 memset(&attr, 0, sizeof(attr));
                 ret = parse_event_symbols(&str, &attr);
@@ -824,7 +794,7 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
 
                 if (ret != EVT_HANDLED_ALL) {
                         struct perf_evsel *evsel;
-                        evsel = perf_evsel__new(attr.type, attr.config,
+                        evsel = perf_evsel__new(&attr,
                                                 nr_counters);
                         if (evsel == NULL)
                                 return -1;
@@ -1014,8 +984,15 @@ void print_events(void)
 
 int perf_evsel_list__create_default(void)
 {
-        struct perf_evsel *evsel = perf_evsel__new(PERF_TYPE_HARDWARE,
-                                                   PERF_COUNT_HW_CPU_CYCLES, 0);
+        struct perf_evsel *evsel;
+        struct perf_event_attr attr;
+
+        memset(&attr, 0, sizeof(attr));
+        attr.type = PERF_TYPE_HARDWARE;
+        attr.config = PERF_COUNT_HW_CPU_CYCLES;
+
+        evsel = perf_evsel__new(&attr, 0);
+
         if (evsel == NULL)
                 return -ENOMEM;
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 6fb4694d05f..313dac2d94c 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1007,7 +1007,7 @@ more:
         if (size == 0)
                 size = 8;
 
-        if (head + event->header.size >= mmap_size) {
+        if (head + event->header.size > mmap_size) {
                 if (mmaps[map_idx]) {
                         munmap(mmaps[map_idx], mmap_size);
                         mmaps[map_idx] = NULL;