event-times.c

  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
 17static int attach__enable_on_exec(struct evlist *evlist)
 18{
 19	struct evsel *evsel = evlist__last(evlist);
 20	struct target target = {};
 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 = 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 = 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->core.attr.enable_on_exec = 1;
 40
 41	err = evlist__open(evlist);
 42	if (err < 0) {
 43		pr_debug("perf_evlist__open: %s\n",
 44			 str_error_r(errno, sbuf, sizeof(sbuf)));
 45		return err;
 46	}
 47
 48	return evlist__start_workload(evlist) == 1 ? TEST_OK : TEST_FAIL;
 49}
 50
 51static int detach__enable_on_exec(struct evlist *evlist)
 52{
 53	waitpid(evlist->workload.pid, NULL, 0);
 54	return 0;
 55}
 56
 57static int attach__current_disabled(struct evlist *evlist)
 58{
 59	struct evsel *evsel = evlist__last(evlist);
 60	struct perf_thread_map *threads;
 61	int err;
 62
 63	pr_debug("attaching to current thread as disabled\n");
 64
 65	threads = thread_map__new_by_tid(getpid());
 66	if (threads == NULL) {
 67		pr_debug("thread_map__new\n");
 68		return -1;
 69	}
 70
 71	evsel->core.attr.disabled = 1;
 72
 73	err = 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	perf_thread_map__put(threads);
 80	return evsel__enable(evsel) == 0 ? TEST_OK : TEST_FAIL;
 81}
 82
 83static int attach__current_enabled(struct evlist *evlist)
 84{
 85	struct evsel *evsel = evlist__last(evlist);
 86	struct perf_thread_map *threads;
 87	int err;
 88
 89	pr_debug("attaching to current thread as enabled\n");
 90
 91	threads = thread_map__new_by_tid(getpid());
 92	if (threads == NULL) {
 93		pr_debug("failed to call thread_map__new\n");
 94		return -1;
 95	}
 96
 97	err = evsel__open_per_thread(evsel, threads);
 98
 99	perf_thread_map__put(threads);
100	return err == 0 ? TEST_OK : TEST_FAIL;
101}
102
103static int detach__disable(struct evlist *evlist)
104{
105	struct evsel *evsel = evlist__last(evlist);
106
107	return evsel__enable(evsel);
108}
109
110static int attach__cpu_disabled(struct evlist *evlist)
111{
112	struct evsel *evsel = evlist__last(evlist);
113	struct perf_cpu_map *cpus;
114	int err;
115
116	pr_debug("attaching to CPU 0 as enabled\n");
117
118	cpus = perf_cpu_map__new("0");
119	if (cpus == NULL) {
120		pr_debug("failed to call perf_cpu_map__new\n");
121		return -1;
122	}
123
124	evsel->core.attr.disabled = 1;
125
126	err = evsel__open_per_cpu(evsel, cpus, -1);
127	perf_cpu_map__put(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	return evsel__enable(evsel);
137}
138
139static int attach__cpu_enabled(struct evlist *evlist)
140{
141	struct evsel *evsel = evlist__last(evlist);
142	struct perf_cpu_map *cpus;
143	int err;
144
145	pr_debug("attaching to CPU 0 as enabled\n");
146
147	cpus = perf_cpu_map__new("0");
148	if (cpus == NULL) {
149		pr_debug("failed to call perf_cpu_map__new\n");
150		return -1;
151	}
152
153	err = evsel__open_per_cpu(evsel, cpus, -1);
154	perf_cpu_map__put(cpus);
155	if (err == -EACCES)
156		return TEST_SKIP;
157
158	return err ? TEST_FAIL : TEST_OK;
159}
160
161static int test_times(int (attach)(struct evlist *),
162		      int (detach)(struct evlist *))
163{
164	struct perf_counts_values count;
165	struct evlist *evlist = NULL;
166	struct evsel *evsel;
167	int err = -1, i;
168
169	evlist = evlist__new();
170	if (!evlist) {
171		pr_debug("failed to create event list\n");
172		goto out_err;
173	}
174
175	err = parse_event(evlist, "cpu-clock:u");
176	if (err) {
177		pr_debug("failed to parse event cpu-clock:u\n");
178		goto out_err;
179	}
180
181	evsel = evlist__last(evlist);
182	evsel->core.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		evlist__delete(evlist);
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->core, 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
207out_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 */
218static int test__event_times(struct test_suite *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
242DEFINE_SUITE("Event times", event_times);