Add generic fallback for perf counter read
[lttng-ust.git] / liblttng-ust / lttng-context-perf-counters.c
index 383d020ce42e02be05c4c89dbd578294091aa6c9..dbb1e6b1dcf368d339053ba1c199f90347007e79 100644 (file)
@@ -25,6 +25,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <stdbool.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <linux/perf_event.h>
@@ -79,6 +80,22 @@ size_t perf_counter_get_size(struct lttng_ctx_field *field, size_t offset)
        return size;
 }
 
+static
+uint64_t read_perf_counter_syscall(
+               struct lttng_perf_counter_thread_field *thread_field)
+{
+       uint64_t count;
+
+       if (caa_unlikely(thread_field->fd < 0))
+               return 0;
+
+       if (caa_unlikely(read(thread_field->fd, &count, sizeof(count))
+                               < sizeof(count)))
+               return 0;
+
+       return count;
+}
+
 #if defined(__x86_64__) || defined(__i386__)
 
 static
@@ -91,22 +108,13 @@ uint64_t rdpmc(unsigned int counter)
        return low | ((uint64_t) high) << 32;
 }
 
-static bool arch_perf_use_read(void)
-{
-       return false;
-}
-
-#else /* defined(__x86_64__) || defined(__i386__) */
-
-#error "Perf event counters are only supported on x86 so far."
-
-#endif /* #else defined(__x86_64__) || defined(__i386__) */
-
 static
-uint64_t read_perf_counter(struct perf_event_mmap_page *pc)
+uint64_t arch_read_perf_counter(
+               struct lttng_perf_counter_thread_field *thread_field)
 {
        uint32_t seq, idx;
        uint64_t count;
+       struct perf_event_mmap_page *pc = thread_field->pc;
 
        if (caa_unlikely(!pc))
                return 0;
@@ -116,17 +124,52 @@ uint64_t read_perf_counter(struct perf_event_mmap_page *pc)
                cmm_barrier();
 
                idx = pc->index;
-               if (idx)
-                       count = pc->offset + rdpmc(idx - 1);
-               else
-                       count = 0;
-
+               if (caa_likely(pc->cap_user_rdpmc && idx)) {
+                       int64_t pmcval;
+
+                       pmcval = rdpmc(idx - 1);
+                       /* Sign-extend the pmc register result. */
+                       pmcval <<= 64 - pc->pmc_width;
+                       pmcval >>= 64 - pc->pmc_width;
+                       count = pc->offset + pmcval;
+               } else {
+                       /* Fall-back on system call if rdpmc cannot be used. */
+                       return read_perf_counter_syscall(thread_field);
+               }
                cmm_barrier();
        } while (CMM_LOAD_SHARED(pc->lock) != seq);
 
        return count;
 }
 
+static
+int arch_perf_keep_fd(struct lttng_perf_counter_thread_field *thread_field)
+{
+       struct perf_event_mmap_page *pc = thread_field->pc;
+
+       if (!pc)
+               return 0;
+       return !pc->cap_user_rdpmc;
+}
+
+#else
+
+/* Generic (slow) implementation using a read system call. */
+static
+uint64_t arch_read_perf_counter(
+               struct lttng_perf_counter_thread_field *thread_field)
+{
+       return read_perf_counter_syscall(thread_field);
+}
+
+static
+int arch_perf_keep_fd(struct lttng_perf_counter_thread_field *thread_field)
+{
+       return 1;
+}
+
+#endif
+
 static
 int sys_perf_event_open(struct perf_event_attr *attr,
                pid_t pid, int cpu, int group_fd,
@@ -148,6 +191,20 @@ int open_perf_fd(struct perf_event_attr *attr)
        return fd;
 }
 
+static
+void close_perf_fd(int fd)
+{
+       int ret;
+
+       if (fd < 0)
+               return;
+
+       ret = close(fd);
+       if (ret) {
+               perror("Error closing LTTng-UST perf memory mapping FD");
+       }
+}
+
 static
 struct perf_event_mmap_page *setup_perf(
                struct lttng_perf_counter_thread_field *thread_field)
@@ -159,28 +216,14 @@ struct perf_event_mmap_page *setup_perf(
        if (perf_addr == MAP_FAILED)
                perf_addr = NULL;
 
-       if (!arch_perf_use_read()) {
+       if (!arch_perf_keep_fd(thread_field)) {
                close_perf_fd(thread_field->fd);
                thread_field->fd = -1;
        }
 
-end:
        return perf_addr;
 }
 
-static
-void close_perf_fd(int fd)
-{
-       int ret;
-
-       if (fd < 0)
-               return;
-
-       ret = close(fd);
-       if (ret)
-               perror("Error closing LTTng-UST perf memory mapping FD");
-}
-
 static
 void unmap_perf_page(struct perf_event_mmap_page *pc)
 {
@@ -298,7 +341,7 @@ uint64_t wrapper_perf_counter_read(struct lttng_ctx_field *field)
 
        perf_field = field->u.perf_counter;
        perf_thread_field = get_thread_field(perf_field);
-       return read_perf_counter(perf_thread_field->pc);
+       return arch_read_perf_counter(perf_thread_field);
 }
 
 static
@@ -369,6 +412,24 @@ void lttng_destroy_perf_counter_field(struct lttng_ctx_field *field)
        free(perf_field);
 }
 
+#ifdef __ARM_ARCH_7A__
+
+static
+int perf_get_exclude_kernel(void)
+{
+       return 0;
+}
+
+#else /* __ARM_ARCH_7A__ */
+
+static
+int perf_get_exclude_kernel(void)
+{
+       return 1;
+}
+
+#endif /* __ARM_ARCH_7A__ */
+
 /* Called with UST lock held */
 int lttng_add_perf_counter_to_ctx(uint32_t type,
                                uint64_t config,
@@ -419,7 +480,7 @@ int lttng_add_perf_counter_to_ctx(uint32_t type,
 
        perf_field->attr.type = type;
        perf_field->attr.config = config;
-       perf_field->attr.exclude_kernel = 1;
+       perf_field->attr.exclude_kernel = perf_get_exclude_kernel();
        CDS_INIT_LIST_HEAD(&perf_field->thread_field_list);
        field->u.perf_counter = perf_field;
 
This page took 0.025219 seconds and 4 git commands to generate.