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