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