Merge branch 'perfcounters-rename-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'perfcounters-rename-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  perf: Tidy up after the big rename
  perf: Do the big rename: Performance Counters -> Performance Events
  perf_counter: Rename 'event' to event_id/hw_event
  perf_counter: Rename list_entry -> group_entry, counter_list -> group_list

Manually resolved some fairly trivial conflicts with the tracing tree in
include/trace/ftrace.h and kernel/trace/trace_syscalls.c.

18 files changed, 155 insertions, 155 deletions

diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 0aba8b6e9c54..b5f1953b6144 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -318,7 +318,7 @@ export PERL_PATH
 
 LIB_FILE=libperf.a
 
-LIB_H += ../../include/linux/perf_counter.h
+LIB_H += ../../include/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
 LIB_H += util/include/linux/list.h
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 043d85b7e254..1ec741615814 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -505,7 +505,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 return -1;
         }
 
-        if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
+        if (event->header.misc & PERF_RECORD_MISC_KERNEL) {
                 show = SHOW_KERNEL;
                 level = 'k';
 
@@ -513,7 +513,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dump_printf(" ...... dso: %s\n", dso->name);
 
-        } else if (event->header.misc & PERF_EVENT_MISC_USER) {
+        } else if (event->header.misc & PERF_RECORD_MISC_USER) {
 
                 show = SHOW_USER;
                 level = '.';
@@ -565,7 +565,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 
         thread = threads__findnew(event->mmap.pid, &threads, &last_match);
 
-        dump_printf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
+        dump_printf("%p [%p]: PERF_RECORD_MMAP %d: [%p(%p) @ %p]: %s\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->mmap.pid,
@@ -575,7 +575,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
                 event->mmap.filename);
 
         if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_EVENT_MMAP, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
                 return 0;
         }
 
@@ -591,14 +591,14 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
         struct thread *thread;
 
         thread = threads__findnew(event->comm.pid, &threads, &last_match);
-        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->comm.comm, event->comm.pid);
 
         if (thread == NULL ||
             thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                 return -1;
         }
         total_comm++;
@@ -614,7 +614,7 @@ process_fork_event(event_t *event, unsigned long offset, unsigned long head)
 
         thread = threads__findnew(event->fork.pid, &threads, &last_match);
         parent = threads__findnew(event->fork.ppid, &threads, &last_match);
-        dump_printf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
+        dump_printf("%p [%p]: PERF_RECORD_FORK: %d:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->fork.pid, event->fork.ppid);
@@ -627,7 +627,7 @@ process_fork_event(event_t *event, unsigned long offset, unsigned long head)
                 return 0;
 
         if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_EVENT_FORK, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
                 return -1;
         }
         total_fork++;
@@ -639,23 +639,23 @@ static int
 process_event(event_t *event, unsigned long offset, unsigned long head)
 {
         switch (event->header.type) {
-        case PERF_EVENT_SAMPLE:
+        case PERF_RECORD_SAMPLE:
                 return process_sample_event(event, offset, head);
 
-        case PERF_EVENT_MMAP:
+        case PERF_RECORD_MMAP:
                 return process_mmap_event(event, offset, head);
 
-        case PERF_EVENT_COMM:
+        case PERF_RECORD_COMM:
                 return process_comm_event(event, offset, head);
 
-        case PERF_EVENT_FORK:
+        case PERF_RECORD_FORK:
                 return process_fork_event(event, offset, head);
         /*
          * We dont process them right now but they are fine:
          */
 
-        case PERF_EVENT_THROTTLE:
-        case PERF_EVENT_UNTHROTTLE:
+        case PERF_RECORD_THROTTLE:
+        case PERF_RECORD_UNTHROTTLE:
                 return 0;
 
         default:
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 2459e5a22ed8..a5a050af8e7d 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -77,7 +77,7 @@ static struct mmap_data		mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
 
 static unsigned long mmap_read_head(struct mmap_data *md)
 {
-        struct perf_counter_mmap_page *pc = md->base;
+        struct perf_event_mmap_page *pc = md->base;
         long head;
 
         head = pc->data_head;
@@ -88,7 +88,7 @@ static unsigned long mmap_read_head(struct mmap_data *md)
 
 static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
 {
-        struct perf_counter_mmap_page *pc = md->base;
+        struct perf_event_mmap_page *pc = md->base;
 
         /*
          * ensure all reads are done before we write the tail out.
@@ -233,7 +233,7 @@ static pid_t pid_synthesize_comm_event(pid_t pid, int full)
                 }
         }
 
-        comm_ev.header.type = PERF_EVENT_COMM;
+        comm_ev.header.type = PERF_RECORD_COMM;
         size = ALIGN(size, sizeof(u64));
         comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
 
@@ -288,7 +288,7 @@ static void pid_synthesize_mmap_samples(pid_t pid, pid_t tgid)
         while (1) {
                 char bf[BUFSIZ], *pbf = bf;
                 struct mmap_event mmap_ev = {
-                        .header = { .type = PERF_EVENT_MMAP },
+                        .header = { .type = PERF_RECORD_MMAP },
                 };
                 int n;
                 size_t size;
@@ -355,7 +355,7 @@ static void synthesize_all(void)
 
 static int group_fd;
 
-static struct perf_header_attr *get_header_attr(struct perf_counter_attr *a, int nr)
+static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
 {
         struct perf_header_attr *h_attr;
 
@@ -371,7 +371,7 @@ static struct perf_header_attr *get_header_attr(struct perf_counter_attr *a, int
 
 static void create_counter(int counter, int cpu, pid_t pid)
 {
-        struct perf_counter_attr *attr = attrs + counter;
+        struct perf_event_attr *attr = attrs + counter;
         struct perf_header_attr *h_attr;
         int track = !counter; /* only the first counter needs these */
         struct {
@@ -417,7 +417,7 @@ static void create_counter(int counter, int cpu, pid_t pid)
         attr->disabled          = 1;
 
 try_again:
-        fd[nr_cpu][counter] = sys_perf_counter_open(attr, pid, cpu, group_fd, 0);
+        fd[nr_cpu][counter] = sys_perf_event_open(attr, pid, cpu, group_fd, 0);
 
         if (fd[nr_cpu][counter] < 0) {
                 int err = errno;
@@ -444,7 +444,7 @@ try_again:
                 printf("\n");
                 error("perfcounter syscall returned with %d (%s)\n",
                         fd[nr_cpu][counter], strerror(err));
-                die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n");
+                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
                 exit(-1);
         }
 
@@ -478,7 +478,7 @@ try_again:
         if (multiplex && fd[nr_cpu][counter] != multiplex_fd) {
                 int ret;
 
-                ret = ioctl(fd[nr_cpu][counter], PERF_COUNTER_IOC_SET_OUTPUT, multiplex_fd);
+                ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd);
                 assert(ret != -1);
         } else {
                 event_array[nr_poll].fd = fd[nr_cpu][counter];
@@ -496,7 +496,7 @@ try_again:
                 }
         }
 
-        ioctl(fd[nr_cpu][counter], PERF_COUNTER_IOC_ENABLE);
+        ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE);
 }
 
 static void open_counters(int cpu, pid_t pid)
@@ -642,7 +642,7 @@ static int __cmd_record(int argc, const char **argv)
                 if (done) {
                         for (i = 0; i < nr_cpu; i++) {
                                 for (counter = 0; counter < nr_counters; counter++)
-                                        ioctl(fd[i][counter], PERF_COUNTER_IOC_DISABLE);
+                                        ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE);
                         }
                 }
         }
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index cdf9a8d27bb9..19669c20088e 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -1121,7 +1121,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 more_data += sizeof(u64);
         }
 
-        dump_printf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.misc,
@@ -1158,9 +1158,9 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         if (comm_list && !strlist__has_entry(comm_list, thread->comm))
                 return 0;
 
-        cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
+        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        if (cpumode == PERF_EVENT_MISC_KERNEL) {
+        if (cpumode == PERF_RECORD_MISC_KERNEL) {
                 show = SHOW_KERNEL;
                 level = 'k';
 
@@ -1168,7 +1168,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dump_printf(" ...... dso: %s\n", dso->name);
 
-        } else if (cpumode == PERF_EVENT_MISC_USER) {
+        } else if (cpumode == PERF_RECORD_MISC_USER) {
 
                 show = SHOW_USER;
                 level = '.';
@@ -1210,7 +1210,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
 
         thread = threads__findnew(event->mmap.pid, &threads, &last_match);
 
-        dump_printf("%p [%p]: PERF_EVENT_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
+        dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->mmap.pid,
@@ -1221,7 +1221,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
                 event->mmap.filename);
 
         if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_EVENT_MMAP, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
                 return 0;
         }
 
@@ -1238,14 +1238,14 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 
         thread = threads__findnew(event->comm.pid, &threads, &last_match);
 
-        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->comm.comm, event->comm.pid);
 
         if (thread == NULL ||
             thread__set_comm_adjust(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                 return -1;
         }
         total_comm++;
@@ -1262,10 +1262,10 @@ process_task_event(event_t *event, unsigned long offset, unsigned long head)
         thread = threads__findnew(event->fork.pid, &threads, &last_match);
         parent = threads__findnew(event->fork.ppid, &threads, &last_match);
 
-        dump_printf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
+        dump_printf("%p [%p]: PERF_RECORD_%s: (%d:%d):(%d:%d)\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
-                event->header.type == PERF_EVENT_FORK ? "FORK" : "EXIT",
+                event->header.type == PERF_RECORD_FORK ? "FORK" : "EXIT",
                 event->fork.pid, event->fork.tid,
                 event->fork.ppid, event->fork.ptid);
 
@@ -1276,11 +1276,11 @@ process_task_event(event_t *event, unsigned long offset, unsigned long head)
         if (thread == parent)
                 return 0;
 
-        if (event->header.type == PERF_EVENT_EXIT)
+        if (event->header.type == PERF_RECORD_EXIT)
                 return 0;
 
         if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_EVENT_FORK, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
                 return -1;
         }
         total_fork++;
@@ -1291,7 +1291,7 @@ process_task_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_lost_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        dump_printf("%p [%p]: PERF_EVENT_LOST: id:%Ld: lost:%Ld\n",
+        dump_printf("%p [%p]: PERF_RECORD_LOST: id:%Ld: lost:%Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->lost.id,
@@ -1305,7 +1305,7 @@ process_lost_event(event_t *event, unsigned long offset, unsigned long head)
 static int
 process_read_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        struct perf_counter_attr *attr;
+        struct perf_event_attr *attr;
 
         attr = perf_header__find_attr(event->read.id, header);
 
@@ -1319,7 +1319,7 @@ process_read_event(event_t *event, unsigned long offset, unsigned long head)
                                            event->read.value);
         }
 
-        dump_printf("%p [%p]: PERF_EVENT_READ: %d %d %s %Lu\n",
+        dump_printf("%p [%p]: PERF_RECORD_READ: %d %d %s %Lu\n",
                         (void *)(offset + head),
                         (void *)(long)(event->header.size),
                         event->read.pid,
@@ -1337,31 +1337,31 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
         trace_event(event);
 
         switch (event->header.type) {
-        case PERF_EVENT_SAMPLE:
+        case PERF_RECORD_SAMPLE:
                 return process_sample_event(event, offset, head);
 
-        case PERF_EVENT_MMAP:
+        case PERF_RECORD_MMAP:
                 return process_mmap_event(event, offset, head);
 
-        case PERF_EVENT_COMM:
+        case PERF_RECORD_COMM:
                 return process_comm_event(event, offset, head);
 
-        case PERF_EVENT_FORK:
-        case PERF_EVENT_EXIT:
+        case PERF_RECORD_FORK:
+        case PERF_RECORD_EXIT:
                 return process_task_event(event, offset, head);
 
-        case PERF_EVENT_LOST:
+        case PERF_RECORD_LOST:
                 return process_lost_event(event, offset, head);
 
-        case PERF_EVENT_READ:
+        case PERF_RECORD_READ:
                 return process_read_event(event, offset, head);
 
         /*
          * We dont process them right now but they are fine:
          */
 
-        case PERF_EVENT_THROTTLE:
-        case PERF_EVENT_UNTHROTTLE:
+        case PERF_RECORD_THROTTLE:
+        case PERF_RECORD_UNTHROTTLE:
                 return 0;
 
         default:
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 275d79c6627a..ea9c15c0cdfe 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -1573,7 +1573,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 more_data += sizeof(u64);
         }
 
-        dump_printf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.misc,
@@ -1589,9 +1589,9 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 return -1;
         }
 
-        cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
+        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        if (cpumode == PERF_EVENT_MISC_KERNEL) {
+        if (cpumode == PERF_RECORD_MISC_KERNEL) {
                 show = SHOW_KERNEL;
                 level = 'k';
 
@@ -1599,7 +1599,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dump_printf(" ...... dso: %s\n", dso->name);
 
-        } else if (cpumode == PERF_EVENT_MISC_USER) {
+        } else if (cpumode == PERF_RECORD_MISC_USER) {
 
                 show = SHOW_USER;
                 level = '.';
@@ -1626,23 +1626,23 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
 
         nr_events++;
         switch (event->header.type) {
-        case PERF_EVENT_MMAP:
+        case PERF_RECORD_MMAP:
                 return 0;
-        case PERF_EVENT_LOST:
+        case PERF_RECORD_LOST:
                 nr_lost_chunks++;
                 nr_lost_events += event->lost.lost;
                 return 0;
 
-        case PERF_EVENT_COMM:
+        case PERF_RECORD_COMM:
                 return process_comm_event(event, offset, head);
 
-        case PERF_EVENT_EXIT ... PERF_EVENT_READ:
+        case PERF_RECORD_EXIT ... PERF_RECORD_READ:
                 return 0;
 
-        case PERF_EVENT_SAMPLE:
+        case PERF_RECORD_SAMPLE:
                 return process_sample_event(event, offset, head);
 
-        case PERF_EVENT_MAX:
+        case PERF_RECORD_MAX:
         default:
                 return -1;
         }
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 61b828236c11..16af2d82e858 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -48,7 +48,7 @@
 #include <sys/prctl.h>
 #include <math.h>
 
-static struct perf_counter_attr default_attrs[] = {
+static struct perf_event_attr default_attrs[] = {
 
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK      },
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES},
@@ -130,11 +130,11 @@ struct stats			runtime_cycles_stats;
          attrs[counter].config == PERF_COUNT_##c)
 
 #define ERR_PERF_OPEN \
-"Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"
+"Error: counter %d, sys_perf_event_open() syscall returned with %d (%s)\n"
 
 static void create_perf_stat_counter(int counter, int pid)
 {
-        struct perf_counter_attr *attr = attrs + counter;
+        struct perf_event_attr *attr = attrs + counter;
 
         if (scale)
                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
@@ -144,7 +144,7 @@ static void create_perf_stat_counter(int counter, int pid)
                 unsigned int cpu;
 
                 for (cpu = 0; cpu < nr_cpus; cpu++) {
-                        fd[cpu][counter] = sys_perf_counter_open(attr, -1, cpu, -1, 0);
+                        fd[cpu][counter] = sys_perf_event_open(attr, -1, cpu, -1, 0);
                         if (fd[cpu][counter] < 0 && verbose)
                                 fprintf(stderr, ERR_PERF_OPEN, counter,
                                         fd[cpu][counter], strerror(errno));
@@ -154,7 +154,7 @@ static void create_perf_stat_counter(int counter, int pid)
                 attr->disabled       = 1;
                 attr->enable_on_exec = 1;
 
-                fd[0][counter] = sys_perf_counter_open(attr, pid, -1, -1, 0);
+                fd[0][counter] = sys_perf_event_open(attr, pid, -1, -1, 0);
                 if (fd[0][counter] < 0 && verbose)
                         fprintf(stderr, ERR_PERF_OPEN, counter,
                                 fd[0][counter], strerror(errno));
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 600406396274..4405681b3134 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -937,21 +937,21 @@ process_event(event_t *event)
 
         switch (event->header.type) {
 
-        case PERF_EVENT_COMM:
+        case PERF_RECORD_COMM:
                 return process_comm_event(event);
-        case PERF_EVENT_FORK:
+        case PERF_RECORD_FORK:
                 return process_fork_event(event);
-        case PERF_EVENT_EXIT:
+        case PERF_RECORD_EXIT:
                 return process_exit_event(event);
-        case PERF_EVENT_SAMPLE:
+        case PERF_RECORD_SAMPLE:
                 return queue_sample_event(event);
 
         /*
          * We dont process them right now but they are fine:
          */
-        case PERF_EVENT_MMAP:
-        case PERF_EVENT_THROTTLE:
-        case PERF_EVENT_UNTHROTTLE:
+        case PERF_RECORD_MMAP:
+        case PERF_RECORD_THROTTLE:
+        case PERF_RECORD_UNTHROTTLE:
                 return 0;
 
         default:
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 4002ccb36750..1ca88896eee4 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -901,7 +901,7 @@ struct mmap_data {
 
 static unsigned int mmap_read_head(struct mmap_data *md)
 {
-        struct perf_counter_mmap_page *pc = md->base;
+        struct perf_event_mmap_page *pc = md->base;
         int head;
 
         head = pc->data_head;
@@ -977,9 +977,9 @@ static void mmap_read_counter(struct mmap_data *md)
 
                 old += size;
 
-                if (event->header.type == PERF_EVENT_SAMPLE) {
+                if (event->header.type == PERF_RECORD_SAMPLE) {
                         int user =
-        (event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK) == PERF_EVENT_MISC_USER;
+        (event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK) == PERF_RECORD_MISC_USER;
                         process_event(event->ip.ip, md->counter, user);
                 }
         }
@@ -1005,7 +1005,7 @@ int group_fd;
 
 static void start_counter(int i, int counter)
 {
-        struct perf_counter_attr *attr;
+        struct perf_event_attr *attr;
         int cpu;
 
         cpu = profile_cpu;
@@ -1019,7 +1019,7 @@ static void start_counter(int i, int counter)
         attr->inherit           = (cpu < 0) && inherit;
 
 try_again:
-        fd[i][counter] = sys_perf_counter_open(attr, target_pid, cpu, group_fd, 0);
+        fd[i][counter] = sys_perf_event_open(attr, target_pid, cpu, group_fd, 0);
 
         if (fd[i][counter] < 0) {
                 int err = errno;
@@ -1044,7 +1044,7 @@ try_again:
                 printf("\n");
                 error("perfcounter syscall returned with %d (%s)\n",
                         fd[i][counter], strerror(err));
-                die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n");
+                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
                 exit(-1);
         }
         assert(fd[i][counter] >= 0);
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 914ab366e369..e9d256e2f47d 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -35,14 +35,14 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 
         thread = threads__findnew(event->comm.pid, &threads, &last_match);
 
-        dump_printf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
+        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->comm.comm, event->comm.pid);
 
         if (thread == NULL ||
             thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_EVENT_COMM, skipping event.\n");
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                 return -1;
         }
         total_comm++;
@@ -82,7 +82,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 more_data += sizeof(u64);
         }
 
-        dump_printf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
                 event->header.misc,
@@ -98,9 +98,9 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 return -1;
         }
 
-        cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
+        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        if (cpumode == PERF_EVENT_MISC_KERNEL) {
+        if (cpumode == PERF_RECORD_MISC_KERNEL) {
                 show = SHOW_KERNEL;
                 level = 'k';
 
@@ -108,7 +108,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
 
                 dump_printf(" ...... dso: %s\n", dso->name);
 
-        } else if (cpumode == PERF_EVENT_MISC_USER) {
+        } else if (cpumode == PERF_RECORD_MISC_USER) {
 
                 show = SHOW_USER;
                 level = '.';
@@ -146,19 +146,19 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
         trace_event(event);
 
         switch (event->header.type) {
-        case PERF_EVENT_MMAP ... PERF_EVENT_LOST:
+        case PERF_RECORD_MMAP ... PERF_RECORD_LOST:
                 return 0;
 
-        case PERF_EVENT_COMM:
+        case PERF_RECORD_COMM:
                 return process_comm_event(event, offset, head);
 
-        case PERF_EVENT_EXIT ... PERF_EVENT_READ:
+        case PERF_RECORD_EXIT ... PERF_RECORD_READ:
                 return 0;
 
-        case PERF_EVENT_SAMPLE:
+        case PERF_RECORD_SAMPLE:
                 return process_sample_event(event, offset, head);
 
-        case PERF_EVENT_MAX:
+        case PERF_RECORD_MAX:
         default:
                 return -1;
         }
diff --git a/tools/perf/design.txt b/tools/perf/design.txt
index f71e0d245cba..f1946d107b10 100644
--- a/tools/perf/design.txt
+++ b/tools/perf/design.txt
@@ -18,10 +18,10 @@ underlying hardware counters.
 Performance counters are accessed via special file descriptors.
 There's one file descriptor per virtual counter used.
 
-The special file descriptor is opened via the perf_counter_open()
+The special file descriptor is opened via the perf_event_open()
 system call:
 
-   int sys_perf_counter_open(struct perf_counter_hw_event *hw_event_uptr,
+   int sys_perf_event_open(struct perf_event_hw_event *hw_event_uptr,
                              pid_t pid, int cpu, int group_fd,
                              unsigned long flags);
 
@@ -32,9 +32,9 @@ can be used to set the blocking mode, etc.
 Multiple counters can be kept open at a time, and the counters
 can be poll()ed.
 
-When creating a new counter fd, 'perf_counter_hw_event' is:
+When creating a new counter fd, 'perf_event_hw_event' is:
 
-struct perf_counter_hw_event {
+struct perf_event_hw_event {
         /*
          * The MSB of the config word signifies if the rest contains cpu
          * specific (raw) counter configuration data, if unset, the next
@@ -93,7 +93,7 @@ specified by 'event_id':
 
 /*
  * Generalized performance counter event types, used by the hw_event.event_id
- * parameter of the sys_perf_counter_open() syscall:
+ * parameter of the sys_perf_event_open() syscall:
  */
 enum hw_event_ids {
         /*
@@ -159,7 +159,7 @@ in size.
  * reads on the counter should return the indicated quantities,
  * in increasing order of bit value, after the counter value.
  */
-enum perf_counter_read_format {
+enum perf_event_read_format {
         PERF_FORMAT_TOTAL_TIME_ENABLED  =  1,
         PERF_FORMAT_TOTAL_TIME_RUNNING  =  2,
 };
@@ -178,7 +178,7 @@ interrupt:
  * Bits that can be set in hw_event.record_type to request information
  * in the overflow packets.
  */
-enum perf_counter_record_format {
+enum perf_event_record_format {
         PERF_RECORD_IP          = 1U << 0,
         PERF_RECORD_TID         = 1U << 1,
         PERF_RECORD_TIME        = 1U << 2,
@@ -228,7 +228,7 @@ these events are recorded in the ring-buffer (see below).
 The 'comm' bit allows tracking of process comm data on process creation.
 This too is recorded in the ring-buffer (see below).
 
-The 'pid' parameter to the perf_counter_open() system call allows the
+The 'pid' parameter to the perf_event_open() system call allows the
 counter to be specific to a task:
 
  pid == 0: if the pid parameter is zero, the counter is attached to the
@@ -258,7 +258,7 @@ The 'flags' parameter is currently unused and must be zero.
 
 The 'group_fd' parameter allows counter "groups" to be set up.  A
 counter group has one counter which is the group "leader".  The leader
-is created first, with group_fd = -1 in the perf_counter_open call
+is created first, with group_fd = -1 in the perf_event_open call
 that creates it.  The rest of the group members are created
 subsequently, with group_fd giving the fd of the group leader.
 (A single counter on its own is created with group_fd = -1 and is
@@ -277,13 +277,13 @@ tracking are logged into a ring-buffer. This ring-buffer is created and
 accessed through mmap().
 
 The mmap size should be 1+2^n pages, where the first page is a meta-data page
-(struct perf_counter_mmap_page) that contains various bits of information such
+(struct perf_event_mmap_page) that contains various bits of information such
 as where the ring-buffer head is.
 
 /*
  * Structure of the page that can be mapped via mmap
  */
-struct perf_counter_mmap_page {
+struct perf_event_mmap_page {
         __u32   version;                /* version number of this structure */
         __u32   compat_version;         /* lowest version this is compat with */
 
@@ -317,7 +317,7 @@ struct perf_counter_mmap_page {
          * Control data for the mmap() data buffer.
          *
          * User-space reading this value should issue an rmb(), on SMP capable
-         * platforms, after reading this value -- see perf_counter_wakeup().
+         * platforms, after reading this value -- see perf_event_wakeup().
          */
         __u32   data_head;              /* head in the data section */
 };
@@ -327,9 +327,9 @@ NOTE: the hw-counter userspace bits are arch specific and are currently only
 
 The following 2^n pages are the ring-buffer which contains events of the form:
 
-#define PERF_EVENT_MISC_KERNEL          (1 << 0)
-#define PERF_EVENT_MISC_USER            (1 << 1)
-#define PERF_EVENT_MISC_OVERFLOW        (1 << 2)
+#define PERF_RECORD_MISC_KERNEL          (1 << 0)
+#define PERF_RECORD_MISC_USER            (1 << 1)
+#define PERF_RECORD_MISC_OVERFLOW        (1 << 2)
 
 struct perf_event_header {
         __u32   type;
@@ -353,8 +353,8 @@ enum perf_event_type {
          *      char                            filename[];
          * };
          */
-        PERF_EVENT_MMAP                 = 1,
-        PERF_EVENT_MUNMAP               = 2,
+        PERF_RECORD_MMAP                 = 1,
+        PERF_RECORD_MUNMAP               = 2,
 
         /*
          * struct {
@@ -364,10 +364,10 @@ enum perf_event_type {
          *      char                            comm[];
          * };
          */
-        PERF_EVENT_COMM                 = 3,
+        PERF_RECORD_COMM                 = 3,
 
         /*
-         * When header.misc & PERF_EVENT_MISC_OVERFLOW the event_type field
+         * When header.misc & PERF_RECORD_MISC_OVERFLOW the event_type field
          * will be PERF_RECORD_*
          *
          * struct {
@@ -397,7 +397,7 @@ Notification of new events is possible through poll()/select()/epoll() and
 fcntl() managing signals.
 
 Normally a notification is generated for every page filled, however one can
-additionally set perf_counter_hw_event.wakeup_events to generate one every
+additionally set perf_event_hw_event.wakeup_events to generate one every
 so many counter overflow events.
 
 Future work will include a splice() interface to the ring-buffer.
@@ -409,11 +409,11 @@ events but does continue to exist and maintain its count value.
 
 An individual counter or counter group can be enabled with
 
-        ioctl(fd, PERF_COUNTER_IOC_ENABLE);
+        ioctl(fd, PERF_EVENT_IOC_ENABLE);
 
 or disabled with
 
-        ioctl(fd, PERF_COUNTER_IOC_DISABLE);
+        ioctl(fd, PERF_EVENT_IOC_DISABLE);
 
 Enabling or disabling the leader of a group enables or disables the
 whole group; that is, while the group leader is disabled, none of the
@@ -424,16 +424,16 @@ other counter.
 
 Additionally, non-inherited overflow counters can use
 
-        ioctl(fd, PERF_COUNTER_IOC_REFRESH, nr);
+        ioctl(fd, PERF_EVENT_IOC_REFRESH, nr);
 
 to enable a counter for 'nr' events, after which it gets disabled again.
 
 A process can enable or disable all the counter groups that are
 attached to it, using prctl:
 
-        prctl(PR_TASK_PERF_COUNTERS_ENABLE);
+        prctl(PR_TASK_PERF_EVENTS_ENABLE);
 
-        prctl(PR_TASK_PERF_COUNTERS_DISABLE);
+        prctl(PR_TASK_PERF_EVENTS_DISABLE);
 
 This applies to all counters on the current process, whether created
 by this process or by another, and doesn't affect any counters that
@@ -447,11 +447,11 @@ Arch requirements
 If your architecture does not have hardware performance metrics, you can
 still use the generic software counters based on hrtimers for sampling.
 
-So to start with, in order to add HAVE_PERF_COUNTERS to your Kconfig, you
+So to start with, in order to add HAVE_PERF_EVENTS to your Kconfig, you
 will need at least this:
-        - asm/perf_counter.h - a basic stub will suffice at first
+        - asm/perf_event.h - a basic stub will suffice at first
         - support for atomic64 types (and associated helper functions)
-        - set_perf_counter_pending() implemented
+        - set_perf_event_pending() implemented
 
 If your architecture does have hardware capabilities, you can override the
-weak stub hw_perf_counter_init() to register hardware counters.
+weak stub hw_perf_event_init() to register hardware counters.
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 2abeb20d0bf3..8cc4623afd6f 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -52,15 +52,15 @@
 #include <sys/types.h>
 #include <sys/syscall.h>
 
-#include "../../include/linux/perf_counter.h"
+#include "../../include/linux/perf_event.h"
 #include "util/types.h"
 
 /*
- * prctl(PR_TASK_PERF_COUNTERS_DISABLE) will (cheaply) disable all
+ * prctl(PR_TASK_PERF_EVENTS_DISABLE) will (cheaply) disable all
  * counters in the current task.
  */
-#define PR_TASK_PERF_COUNTERS_DISABLE   31
-#define PR_TASK_PERF_COUNTERS_ENABLE    32
+#define PR_TASK_PERF_EVENTS_DISABLE   31
+#define PR_TASK_PERF_EVENTS_ENABLE    32
 
 #ifndef NSEC_PER_SEC
 # define NSEC_PER_SEC                   1000000000ULL
@@ -90,12 +90,12 @@ static inline unsigned long long rdclock(void)
         _min1 < _min2 ? _min1 : _min2; })
 
 static inline int
-sys_perf_counter_open(struct perf_counter_attr *attr,
+sys_perf_event_open(struct perf_event_attr *attr,
                       pid_t pid, int cpu, int group_fd,
                       unsigned long flags)
 {
         attr->size = sizeof(*attr);
-        return syscall(__NR_perf_counter_open, attr, pid, cpu,
+        return syscall(__NR_perf_event_open, attr, pid, cpu,
                        group_fd, flags);
 }
 
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 018d414a09d1..2c9c26d6ded0 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -1,5 +1,5 @@
-#ifndef __PERF_EVENT_H
-#define __PERF_EVENT_H
+#ifndef __PERF_RECORD_H
+#define __PERF_RECORD_H
 #include "../perf.h"
 #include "util.h"
 #include <linux/list.h>
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index bb4fca3efcc3..e306857b2c2b 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -9,7 +9,7 @@
 /*
  * Create new perf.data header attribute:
  */
-struct perf_header_attr *perf_header_attr__new(struct perf_counter_attr *attr)
+struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
 {
         struct perf_header_attr *self = malloc(sizeof(*self));
 
@@ -134,7 +134,7 @@ struct perf_file_section {
 };
 
 struct perf_file_attr {
-        struct perf_counter_attr        attr;
+        struct perf_event_attr  attr;
         struct perf_file_section        ids;
 };
 
@@ -320,7 +320,7 @@ u64 perf_header__sample_type(struct perf_header *header)
         return type;
 }
 
-struct perf_counter_attr *
+struct perf_event_attr *
 perf_header__find_attr(u64 id, struct perf_header *header)
 {
         int i;
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 7b0e84a87179..a0761bc7863c 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -1,12 +1,12 @@
 #ifndef _PERF_HEADER_H
 #define _PERF_HEADER_H
 
-#include "../../../include/linux/perf_counter.h"
+#include "../../../include/linux/perf_event.h"
 #include <sys/types.h>
 #include "types.h"
 
 struct perf_header_attr {
-        struct perf_counter_attr attr;
+        struct perf_event_attr attr;
         int ids, size;
         u64 *id;
         off_t id_offset;
@@ -34,11 +34,11 @@ char *perf_header__find_event(u64 id);
 
 
 struct perf_header_attr *
-perf_header_attr__new(struct perf_counter_attr *attr);
+perf_header_attr__new(struct perf_event_attr *attr);
 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
 
 u64 perf_header__sample_type(struct perf_header *header);
-struct perf_counter_attr *
+struct perf_event_attr *
 perf_header__find_attr(u64 id, struct perf_header *header);
 
 
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 89172fd0038b..13ab4b842d49 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -10,7 +10,7 @@
 
 int                                     nr_counters;
 
-struct perf_counter_attr                attrs[MAX_COUNTERS];
+struct perf_event_attr          attrs[MAX_COUNTERS];
 
 struct event_symbol {
         u8              type;
@@ -48,13 +48,13 @@ static struct event_symbol event_symbols[] = {
   { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
 };
 
-#define __PERF_COUNTER_FIELD(config, name) \
-        ((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
+#define __PERF_EVENT_FIELD(config, name) \
+        ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
 
-#define PERF_COUNTER_RAW(config)        __PERF_COUNTER_FIELD(config, RAW)
-#define PERF_COUNTER_CONFIG(config)     __PERF_COUNTER_FIELD(config, CONFIG)
-#define PERF_COUNTER_TYPE(config)       __PERF_COUNTER_FIELD(config, TYPE)
-#define PERF_COUNTER_ID(config)         __PERF_COUNTER_FIELD(config, EVENT)
+#define PERF_EVENT_RAW(config)  __PERF_EVENT_FIELD(config, RAW)
+#define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
+#define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE)
+#define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
 
 static const char *hw_event_names[] = {
         "cycles",
@@ -352,7 +352,7 @@ static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int
 }
 
 static enum event_result
-parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
+parse_generic_hw_event(const char **str, struct perf_event_attr *attr)
 {
         const char *s = *str;
         int cache_type = -1, cache_op = -1, cache_result = -1;
@@ -417,7 +417,7 @@ parse_single_tracepoint_event(char *sys_name,
                               const char *evt_name,
                               unsigned int evt_length,
                               char *flags,
-                              struct perf_counter_attr *attr,
+                              struct perf_event_attr *attr,
                               const char **strp)
 {
         char evt_path[MAXPATHLEN];
@@ -505,7 +505,7 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
 
 
 static enum event_result parse_tracepoint_event(const char **strp,
-                                    struct perf_counter_attr *attr)
+                                    struct perf_event_attr *attr)
 {
         const char *evt_name;
         char *flags;
@@ -563,7 +563,7 @@ static int check_events(const char *str, unsigned int i)
 }
 
 static enum event_result
-parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
+parse_symbolic_event(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
         unsigned int i;
@@ -582,7 +582,7 @@ parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
 }
 
 static enum event_result
-parse_raw_event(const char **strp, struct perf_counter_attr *attr)
+parse_raw_event(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
         u64 config;
@@ -601,7 +601,7 @@ parse_raw_event(const char **strp, struct perf_counter_attr *attr)
 }
 
 static enum event_result
-parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
+parse_numeric_event(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
         char *endp;
@@ -623,7 +623,7 @@ parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
 }
 
 static enum event_result
-parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
+parse_event_modifier(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
         int eu = 1, ek = 1, eh = 1;
@@ -656,7 +656,7 @@ parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
  * Symbolic names are (almost) exactly matched.
  */
 static enum event_result
-parse_event_symbols(const char **str, struct perf_counter_attr *attr)
+parse_event_symbols(const char **str, struct perf_event_attr *attr)
 {
         enum event_result ret;
 
@@ -711,7 +711,7 @@ static void store_event_type(const char *orgname)
 
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
-        struct perf_counter_attr attr;
+        struct perf_event_attr attr;
         enum event_result ret;
 
         if (strchr(str, ':'))
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 60704c15961f..30c608112845 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -16,7 +16,7 @@ extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
 
 extern int                      nr_counters;
 
-extern struct perf_counter_attr attrs[MAX_COUNTERS];
+extern struct perf_event_attr attrs[MAX_COUNTERS];
 
 extern const char *event_name(int ctr);
 extern const char *__event_name(int type, u64 config);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 1fd824c1f1c4..af4b0573b37f 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -480,12 +480,12 @@ out:
 }
 
 static struct tracepoint_path *
-get_tracepoints_path(struct perf_counter_attr *pattrs, int nb_counters)
+get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
 {
         struct tracepoint_path path, *ppath = &path;
         int i;
 
-        for (i = 0; i < nb_counters; i++) {
+        for (i = 0; i < nb_events; i++) {
                 if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
                         continue;
                 ppath->next = tracepoint_id_to_path(pattrs[i].config);
@@ -496,7 +496,7 @@ get_tracepoints_path(struct perf_counter_attr *pattrs, int nb_counters)
 
         return path.next;
 }
-void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters)
+void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
 {
         char buf[BUFSIZ];
         struct tracepoint_path *tps;
@@ -530,7 +530,7 @@ void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters)
         page_size = getpagesize();
         write_or_die(&page_size, 4);
 
-        tps = get_tracepoints_path(pattrs, nb_counters);
+        tps = get_tracepoints_path(pattrs, nb_events);
 
         read_header_files();
         read_ftrace_files(tps);
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index d35ebf1e29ff..693f815c9429 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -240,6 +240,6 @@ unsigned long long
 raw_field_value(struct event *event, const char *name, void *data);
 void *raw_field_ptr(struct event *event, const char *name, void *data);
 
-void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters);
+void read_tracing_data(struct perf_event_attr *pattrs, int nb_events);
 
 #endif /* _TRACE_EVENTS_H */