Code cleanup in contexts

[lttng-ust.git] / liblttng-ust / lttng-context-perf-counters.c

diff --git a/liblttng-ust/lttng-context-perf-counters.c b/liblttng-ust/lttng-context-perf-counters.c
index a7e1b63f4ab02f5666fbbe3c5c4a23b8dcda5a19..4816f89b5a4a536e4cc2741e6e5d658379692baf 100644 (file)
--- a/liblttng-ust/lttng-context-perf-counters.c
+++ b/liblttng-ust/lttng-context-perf-counters.c
@@ -20,6 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#define _LGPL_SOURCE
 #include <sys/types.h>
 #include <unistd.h>
 #include <string.h>
@@ -28,7 +29,6 @@
 #include <stdbool.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
-#include <linux/perf_event.h>
 #include <lttng/ust-events.h>
 #include <lttng/ust-tracer.h>
 #include <lttng/ringbuffer-config.h>
@@ -39,6 +39,7 @@
 #include <urcu/ref.h>
 #include <usterr-signal-safe.h>
 #include <signal.h>
+#include "perf_event.h"
 #include "lttng-tracer-core.h"
 
 /*
@@ -80,6 +81,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
@@ -92,13 +109,17 @@ uint64_t rdpmc(unsigned int counter)
        return low | ((uint64_t) high) << 32;
 }
 
-static bool arch_perf_use_read(void)
+static
+bool has_rdpmc(struct perf_event_mmap_page *pc)
 {
-       return false;
+       if (caa_unlikely(!pc->cap_bit0_is_deprecated))
+               return false;
+       /* Since Linux kernel 3.12. */
+       return pc->cap_user_rdpmc;
 }
 
 static
-uint64_t read_perf_counter(
+uint64_t arch_read_perf_counter(
                struct lttng_perf_counter_thread_field *thread_field)
 {
        uint32_t seq, idx;
@@ -113,7 +134,7 @@ uint64_t read_perf_counter(
                cmm_barrier();
 
                idx = pc->index;
-               if (idx) {
+               if (caa_likely(has_rdpmc(pc) && idx)) {
                        int64_t pmcval;
 
                        pmcval = rdpmc(idx - 1);
@@ -122,7 +143,8 @@ uint64_t read_perf_counter(
                        pmcval >>= 64 - pc->pmc_width;
                        count = pc->offset + pmcval;
                } else {
-                       count = 0;
+                       /* 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);
@@ -130,34 +152,33 @@ uint64_t read_perf_counter(
        return count;
 }
 
-#elif defined (__ARM_ARCH_7A__)
-
-static bool arch_perf_use_read(void)
-{
-       return true;
-}
-
 static
-uint64_t read_perf_counter(
-               struct lttng_perf_counter_thread_field *thread_field)
+int arch_perf_keep_fd(struct lttng_perf_counter_thread_field *thread_field)
 {
-       uint64_t count;
+       struct perf_event_mmap_page *pc = thread_field->pc;
 
-       if (caa_unlikely(thread_field->fd < 0))
+       if (!pc)
                return 0;
+       return !has_rdpmc(pc);
+}
 
-       if (caa_unlikely(read(thread_field->fd, &count, sizeof(count))
-                               < sizeof(count)))
-               return 0;
+#else
 
-       return count;
+/* 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);
 }
 
-#else /* defined(__x86_64__) || defined(__i386__) || defined(__ARM_ARCH_7A__) */
-
-#error "Perf event counters are only supported on x86 and ARMv7 so far."
+static
+int arch_perf_keep_fd(struct lttng_perf_counter_thread_field *thread_field)
+{
+       return 1;
+}
 
-#endif /* #else defined(__x86_64__) || defined(__i386__) || defined(__ARM_ARCH_7A__) */
+#endif
 
 static
 int sys_perf_event_open(struct perf_event_attr *attr,
@@ -194,9 +215,7 @@ void close_perf_fd(int fd)
        }
 }
 
-static
-struct perf_event_mmap_page *setup_perf(
-               struct lttng_perf_counter_thread_field *thread_field)
+static void setup_perf(struct lttng_perf_counter_thread_field *thread_field)
 {
        void *perf_addr;
 
@@ -204,13 +223,12 @@ struct perf_event_mmap_page *setup_perf(
                        PROT_READ, MAP_SHARED, thread_field->fd, 0);
        if (perf_addr == MAP_FAILED)
                perf_addr = NULL;
+       thread_field->pc = perf_addr;
 
-       if (!arch_perf_use_read()) {
+       if (!arch_perf_keep_fd(thread_field)) {
                close_perf_fd(thread_field->fd);
                thread_field->fd = -1;
        }
-
-       return perf_addr;
 }
 
 static
@@ -285,7 +303,7 @@ struct lttng_perf_counter_thread_field *
        thread_field->field = perf_field;
        thread_field->fd = open_perf_fd(&perf_field->attr);
        if (thread_field->fd >= 0)
-               thread_field->pc = setup_perf(thread_field);
+               setup_perf(thread_field);
        /*
         * Note: thread_field->pc can be NULL if setup_perf() fails.
         * Also, thread_field->fd can be -1 if open_perf_fd() fails.
@@ -330,7 +348,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);
+       return arch_read_perf_counter(perf_thread_field);
 }
 
 static
@@ -349,10 +367,7 @@ static
 void perf_counter_get_value(struct lttng_ctx_field *field,
                struct lttng_ctx_value *value)
 {
-       uint64_t v;
-
-       v = wrapper_perf_counter_read(field);
-       value->u.s64 = v;
+       value->u.s64 = wrapper_perf_counter_read(field);
 }
 
 /* Called with UST lock held */