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