tools/perf/tests/event-times.c

   1 #include <linux/compiler.h>
   2 #include <errno.h>
   3 #include <inttypes.h>
   4 #include <string.h>
   5 #include "tests.h"
   6 #include "evlist.h"
   7 #include "evsel.h"
   8 #include "util.h"
   9 #include "debug.h"
  10 #include "thread_map.h"
  11 #include "target.h"
  12
  13 static int attach__enable_on_exec(struct perf_evlist *evlist)
  14 {
  15         struct perf_evsel *evsel = perf_evlist__last(evlist);
  16         struct target target = {
  17                 .uid = UINT_MAX,
  18         };
  19         const char *argv[] = { "true", NULL, };
  20         char sbuf[STRERR_BUFSIZE];
  21         int err;
  22
  23         pr_debug("attaching to spawned child, enable on exec\n");
  24
  25         err = perf_evlist__create_maps(evlist, &target);
  26         if (err < 0) {
  27                 pr_debug("Not enough memory to create thread/cpu maps\n");
  28                 return err;
  29         }
  30
  31         err = perf_evlist__prepare_workload(evlist, &target, argv, false, NULL);
  32         if (err < 0) {
  33                 pr_debug("Couldn't run the workload!\n");
  34                 return err;
  35         }
  36
  37         evsel->attr.enable_on_exec = 1;
  38
  39         err = perf_evlist__open(evlist);
  40         if (err < 0) {
  41                 pr_debug("perf_evlist__open: %s\n",
  42                          str_error_r(errno, sbuf, sizeof(sbuf)));
  43                 return err;
  44         }
  45
  46         return perf_evlist__start_workload(evlist) == 1 ? TEST_OK : TEST_FAIL;
  47 }
  48
  49 static int detach__enable_on_exec(struct perf_evlist *evlist)
  50 {
  51         waitpid(evlist->workload.pid, NULL, 0);
  52         return 0;
  53 }
  54
  55 static int attach__current_disabled(struct perf_evlist *evlist)
  56 {
  57         struct perf_evsel *evsel = perf_evlist__last(evlist);
  58         struct thread_map *threads;
  59         int err;
  60
  61         pr_debug("attaching to current thread as disabled\n");
  62
  63         threads = thread_map__new(-1, getpid(), UINT_MAX);
  64         if (threads == NULL) {
  65                 pr_debug("thread_map__new\n");
  66                 return -1;
  67         }
  68
  69         evsel->attr.disabled = 1;
  70
  71         err = perf_evsel__open_per_thread(evsel, threads);
  72         if (err) {
  73                 pr_debug("Failed to open event cpu-clock:u\n");
  74                 return err;
  75         }
  76
  77         thread_map__put(threads);
  78         return perf_evsel__enable(evsel) == 0 ? TEST_OK : TEST_FAIL;
  79 }
  80
  81 static int attach__current_enabled(struct perf_evlist *evlist)
  82 {
  83         struct perf_evsel *evsel = perf_evlist__last(evlist);
  84         struct thread_map *threads;
  85         int err;
  86
  87         pr_debug("attaching to current thread as enabled\n");
  88
  89         threads = thread_map__new(-1, getpid(), UINT_MAX);
  90         if (threads == NULL) {
  91                 pr_debug("failed to call thread_map__new\n");
  92                 return -1;
  93         }
  94
  95         err = perf_evsel__open_per_thread(evsel, threads);
  96
  97         thread_map__put(threads);
  98         return err == 0 ? TEST_OK : TEST_FAIL;
  99 }
 100
 101 static int detach__disable(struct perf_evlist *evlist)
 102 {
 103         struct perf_evsel *evsel = perf_evlist__last(evlist);
 104
 105         return perf_evsel__enable(evsel);
 106 }
 107
 108 static int attach__cpu_disabled(struct perf_evlist *evlist)
 109 {
 110         struct perf_evsel *evsel = perf_evlist__last(evlist);
 111         struct cpu_map *cpus;
 112         int err;
 113
 114         pr_debug("attaching to CPU 0 as enabled\n");
 115
 116         cpus = cpu_map__new("0");
 117         if (cpus == NULL) {
 118                 pr_debug("failed to call cpu_map__new\n");
 119                 return -1;
 120         }
 121
 122         evsel->attr.disabled = 1;
 123
 124         err = perf_evsel__open_per_cpu(evsel, cpus);
 125         if (err) {
 126                 if (err == -EACCES)
 127                         return TEST_SKIP;
 128
 129                 pr_debug("Failed to open event cpu-clock:u\n");
 130                 return err;
 131         }
 132
 133         cpu_map__put(cpus);
 134         return perf_evsel__enable(evsel);
 135 }
 136
 137 static int attach__cpu_enabled(struct perf_evlist *evlist)
 138 {
 139         struct perf_evsel *evsel = perf_evlist__last(evlist);
 140         struct cpu_map *cpus;
 141         int err;
 142
 143         pr_debug("attaching to CPU 0 as enabled\n");
 144
 145         cpus = cpu_map__new("0");
 146         if (cpus == NULL) {
 147                 pr_debug("failed to call cpu_map__new\n");
 148                 return -1;
 149         }
 150
 151         err = perf_evsel__open_per_cpu(evsel, cpus);
 152         if (err == -EACCES)
 153                 return TEST_SKIP;
 154
 155         cpu_map__put(cpus);
 156         return err ? TEST_FAIL : TEST_OK;
 157 }
 158
 159 static int test_times(int (attach)(struct perf_evlist *),
 160                       int (detach)(struct perf_evlist *))
 161 {
 162         struct perf_counts_values count;
 163         struct perf_evlist *evlist = NULL;
 164         struct perf_evsel *evsel;
 165         int err = -1, i;
 166
 167         evlist = perf_evlist__new();
 168         if (!evlist) {
 169                 pr_debug("failed to create event list\n");
 170                 goto out_err;
 171         }
 172
 173         err = parse_events(evlist, "cpu-clock:u", NULL);
 174         if (err) {
 175                 pr_debug("failed to parse event cpu-clock:u\n");
 176                 goto out_err;
 177         }
 178
 179         evsel = perf_evlist__last(evlist);
 180         evsel->attr.read_format |=
 181                 PERF_FORMAT_TOTAL_TIME_ENABLED |
 182                 PERF_FORMAT_TOTAL_TIME_RUNNING;
 183
 184         err = attach(evlist);
 185         if (err == TEST_SKIP) {
 186                 pr_debug("  SKIP  : not enough rights\n");
 187                 return err;
 188         }
 189
 190         TEST_ASSERT_VAL("failed to attach", !err);
 191
 192         for (i = 0; i < 100000000; i++) { }
 193
 194         TEST_ASSERT_VAL("failed to detach", !detach(evlist));
 195
 196         perf_evsel__read(evsel, 0, 0, &count);
 197
 198         err = !(count.ena == count.run);
 199
 200         pr_debug("  %s: ena %" PRIu64", run %" PRIu64"\n",
 201                  !err ? "OK    " : "FAILED",
 202                  count.ena, count.run);
 203
 204 out_err:
 205         perf_evlist__delete(evlist);
 206         return !err ? TEST_OK : TEST_FAIL;
 207 }
 208
 209 /*
 210  * This test creates software event 'cpu-clock'
 211  * attaches it in several ways (explained below)
 212  * and checks that enabled and running times
 213  * match.
 214  */
 215 int test__event_times(int subtest __maybe_unused)
 216 {
 217         int err, ret = 0;
 218
 219 #define _T(attach, detach)                      \
 220         err = test_times(attach, detach);       \
 221         if (err && (ret == TEST_OK || ret == TEST_SKIP))        \
 222                 ret = err;
 223
 224         /* attach on newly spawned process after exec */
 225         _T(attach__enable_on_exec,   detach__enable_on_exec)
 226         /* attach on current process as enabled */
 227         _T(attach__current_enabled,  detach__disable)
 228         /* attach on current process as disabled */
 229         _T(attach__current_disabled, detach__disable)
 230         /* attach on cpu as disabled */
 231         _T(attach__cpu_disabled,     detach__disable)
 232         /* attach on cpu as enabled */
 233         _T(attach__cpu_enabled,      detach__disable)
 234
 235 #undef _T
 236         return ret;
 237 }