1// SPDX-License-Identifier: GPL-2.0-only
2#include "cgroup.h"
3#include "counts.h"
4#include "cputopo.h"
5#include "debug.h"
6#include "evsel.h"
7#include "pmu.h"
8#include "print-events.h"
9#include "smt.h"
10#include "stat.h"
11#include "time-utils.h"
12#include "tool_pmu.h"
13#include "tsc.h"
14#include <api/fs/fs.h>
15#include <api/io.h>
16#include <internal/threadmap.h>
17#include <perf/cpumap.h>
18#include <perf/threadmap.h>
19#include <fcntl.h>
20#include <strings.h>
21
22static const char *const tool_pmu__event_names[TOOL_PMU__EVENT_MAX] = {
23 NULL,
24 "duration_time",
25 "user_time",
26 "system_time",
27 "has_pmem",
28 "num_cores",
29 "num_cpus",
30 "num_cpus_online",
31 "num_dies",
32 "num_packages",
33 "slots",
34 "smt_on",
35 "system_tsc_freq",
36 "core_wide",
37 "target_cpu",
38};
39
40bool tool_pmu__skip_event(const char *name __maybe_unused)
41{
42#if !defined(__aarch64__)
43 /* The slots event should only appear on arm64. */
44 if (strcasecmp(s1: name, s2: "slots") == 0)
45 return true;
46#endif
47#if !defined(__i386__) && !defined(__x86_64__)
48 /* The system_tsc_freq event should only appear on x86. */
49 if (strcasecmp(name, "system_tsc_freq") == 0)
50 return true;
51#endif
52 return false;
53}
54
55int tool_pmu__num_skip_events(void)
56{
57 int num = 0;
58
59#if !defined(__aarch64__)
60 num++;
61#endif
62#if !defined(__i386__) && !defined(__x86_64__)
63 num++;
64#endif
65 return num;
66}
67
68const char *tool_pmu__event_to_str(enum tool_pmu_event ev)
69{
70 if ((ev > TOOL_PMU__EVENT_NONE && ev < TOOL_PMU__EVENT_MAX) &&
71 !tool_pmu__skip_event(name: tool_pmu__event_names[ev]))
72 return tool_pmu__event_names[ev];
73
74 return NULL;
75}
76
77enum tool_pmu_event tool_pmu__str_to_event(const char *str)
78{
79 int i;
80
81 if (tool_pmu__skip_event(name: str))
82 return TOOL_PMU__EVENT_NONE;
83
84 tool_pmu__for_each_event(i) {
85 if (!strcasecmp(s1: str, s2: tool_pmu__event_names[i]))
86 return i;
87 }
88 return TOOL_PMU__EVENT_NONE;
89}
90
91bool perf_pmu__is_tool(const struct perf_pmu *pmu)
92{
93 return pmu && pmu->type == PERF_PMU_TYPE_TOOL;
94}
95
96bool evsel__is_tool(const struct evsel *evsel)
97{
98 return perf_pmu__is_tool(pmu: evsel->pmu);
99}
100
101enum tool_pmu_event evsel__tool_event(const struct evsel *evsel)
102{
103 if (!evsel__is_tool(evsel))
104 return TOOL_PMU__EVENT_NONE;
105
106 return (enum tool_pmu_event)evsel->core.attr.config;
107}
108
109const char *evsel__tool_pmu_event_name(const struct evsel *evsel)
110{
111 return tool_pmu__event_to_str(ev: evsel->core.attr.config);
112}
113
114struct perf_cpu_map *tool_pmu__cpus(struct perf_event_attr *attr)
115{
116 static struct perf_cpu_map *cpu0_map;
117 enum tool_pmu_event event = (enum tool_pmu_event)attr->config;
118
119 if (event <= TOOL_PMU__EVENT_NONE || event >= TOOL_PMU__EVENT_MAX) {
120 pr_err("Invalid tool PMU event config %llx\n", attr->config);
121 return NULL;
122 }
123 if (event == TOOL_PMU__EVENT_USER_TIME || event == TOOL_PMU__EVENT_SYSTEM_TIME)
124 return cpu_map__online();
125
126 if (!cpu0_map)
127 cpu0_map = perf_cpu_map__new_int(0);
128 return perf_cpu_map__get(cpu0_map);
129}
130
131static bool read_until_char(struct io *io, char e)
132{
133 int c;
134
135 do {
136 c = io__get_char(io);
137 if (c == -1)
138 return false;
139 } while (c != e);
140 return true;
141}
142
143static int read_stat_field(int fd, struct perf_cpu cpu, int field, __u64 *val)
144{
145 char buf[256];
146 struct io io;
147 int i;
148
149 io__init(&io, fd, buf, sizeof(buf));
150
151 /* Skip lines to relevant CPU. */
152 for (i = -1; i < cpu.cpu; i++) {
153 if (!read_until_char(io: &io, e: '\n'))
154 return -EINVAL;
155 }
156 /* Skip to "cpu". */
157 if (io__get_char(&io) != 'c') return -EINVAL;
158 if (io__get_char(&io) != 'p') return -EINVAL;
159 if (io__get_char(&io) != 'u') return -EINVAL;
160
161 /* Skip N of cpuN. */
162 if (!read_until_char(io: &io, e: ' '))
163 return -EINVAL;
164
165 i = 1;
166 while (true) {
167 if (io__get_dec(&io, val) != ' ')
168 break;
169 if (field == i)
170 return 0;
171 i++;
172 }
173 return -EINVAL;
174}
175
176static int read_pid_stat_field(int fd, int field, __u64 *val)
177{
178 char buf[256];
179 struct io io;
180 int c, i;
181
182 io__init(&io, fd, buf, sizeof(buf));
183 if (io__get_dec(&io, val) != ' ')
184 return -EINVAL;
185 if (field == 1)
186 return 0;
187
188 /* Skip comm. */
189 if (io__get_char(&io) != '(' || !read_until_char(io: &io, e: ')'))
190 return -EINVAL;
191 if (field == 2)
192 return -EINVAL; /* String can't be returned. */
193
194 /* Skip state */
195 if (io__get_char(&io) != ' ' || io__get_char(&io) == -1)
196 return -EINVAL;
197 if (field == 3)
198 return -EINVAL; /* String can't be returned. */
199
200 /* Loop over numeric fields*/
201 if (io__get_char(&io) != ' ')
202 return -EINVAL;
203
204 i = 4;
205 while (true) {
206 c = io__get_dec(&io, val);
207 if (c == -1)
208 return -EINVAL;
209 if (c == -2) {
210 /* Assume a -ve was read */
211 c = io__get_dec(&io, val);
212 *val *= -1;
213 }
214 if (c != ' ')
215 return -EINVAL;
216 if (field == i)
217 return 0;
218 i++;
219 }
220 return -EINVAL;
221}
222
223int evsel__tool_pmu_prepare_open(struct evsel *evsel,
224 struct perf_cpu_map *cpus,
225 int nthreads)
226{
227 if ((evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
228 evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME) &&
229 !evsel->start_times) {
230 evsel->start_times = xyarray__new(perf_cpu_map__nr(cpus),
231 nthreads,
232 sizeof(__u64));
233 if (!evsel->start_times)
234 return -ENOMEM;
235 }
236 return 0;
237}
238
239#define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
240
241int evsel__tool_pmu_open(struct evsel *evsel,
242 struct perf_thread_map *threads,
243 int start_cpu_map_idx, int end_cpu_map_idx)
244{
245 enum tool_pmu_event ev = evsel__tool_event(evsel);
246 int pid = -1, idx = 0, thread = 0, nthreads, err = 0, old_errno;
247
248 if (ev == TOOL_PMU__EVENT_NUM_CPUS)
249 return 0;
250
251 if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
252 if (evsel->core.attr.sample_period) /* no sampling */
253 return -EINVAL;
254 evsel->start_time = rdclock();
255 return 0;
256 }
257
258 if (evsel->cgrp)
259 pid = evsel->cgrp->fd;
260
261 nthreads = perf_thread_map__nr(threads);
262 for (idx = start_cpu_map_idx; idx < end_cpu_map_idx; idx++) {
263 for (thread = 0; thread < nthreads; thread++) {
264 if (!evsel->cgrp && !evsel->core.system_wide)
265 pid = perf_thread_map__pid(threads, thread);
266
267 if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
268 bool system = ev == TOOL_PMU__EVENT_SYSTEM_TIME;
269 __u64 *start_time = NULL;
270 int fd;
271
272 if (evsel->core.attr.sample_period) {
273 /* no sampling */
274 err = -EINVAL;
275 goto out_close;
276 }
277 if (pid > -1) {
278 char buf[64];
279
280 snprintf(buf, size: sizeof(buf), fmt: "/proc/%d/stat", pid);
281 fd = open(buf, O_RDONLY);
282 evsel->pid_stat = true;
283 } else {
284 fd = open("/proc/stat", O_RDONLY);
285 }
286 FD(evsel, idx, thread) = fd;
287 if (fd < 0) {
288 err = -errno;
289 goto out_close;
290 }
291 start_time = xyarray__entry(evsel->start_times, idx, thread);
292 if (pid > -1) {
293 err = read_pid_stat_field(fd, field: system ? 15 : 14,
294 val: start_time);
295 } else {
296 struct perf_cpu cpu;
297
298 cpu = perf_cpu_map__cpu(evsel->core.cpus, idx);
299 err = read_stat_field(fd, cpu: cpu, field: system ? 3 : 1,
300 val: start_time);
301 }
302 if (err)
303 goto out_close;
304 }
305
306 }
307 }
308 return 0;
309out_close:
310 if (err)
311 threads->err_thread = thread;
312
313 old_errno = errno;
314 do {
315 while (--thread >= 0) {
316 if (FD(evsel, idx, thread) >= 0)
317 close(FD(evsel, idx, thread));
318 FD(evsel, idx, thread) = -1;
319 }
320 thread = nthreads;
321 } while (--idx >= 0);
322 errno = old_errno;
323 return err;
324}
325
326#if !defined(__i386__) && !defined(__x86_64__)
327u64 arch_get_tsc_freq(void)
328{
329 return 0;
330}
331#endif
332
333#if !defined(__aarch64__)
334u64 tool_pmu__cpu_slots_per_cycle(void)
335{
336 return 0;
337}
338#endif
339
340static bool has_pmem(void)
341{
342 static bool has_pmem, cached;
343 const char *sysfs = sysfs__mountpoint();
344 char path[PATH_MAX];
345
346 if (!cached) {
347 snprintf(buf: path, size: sizeof(path), fmt: "%s/firmware/acpi/tables/NFIT", sysfs);
348 has_pmem = access(path, F_OK) == 0;
349 cached = true;
350 }
351 return has_pmem;
352}
353
354bool tool_pmu__read_event(enum tool_pmu_event ev,
355 struct evsel *evsel,
356 bool system_wide,
357 const char *user_requested_cpu_list,
358 u64 *result)
359{
360 const struct cpu_topology *topology;
361
362 switch (ev) {
363 case TOOL_PMU__EVENT_HAS_PMEM:
364 *result = has_pmem() ? 1 : 0;
365 return true;
366
367 case TOOL_PMU__EVENT_NUM_CORES:
368 topology = online_topology();
369 *result = topology->core_cpus_lists;
370 return true;
371
372 case TOOL_PMU__EVENT_NUM_CPUS:
373 if (!evsel || perf_cpu_map__is_empty(evsel->core.cpus)) {
374 /* No evsel to be specific to. */
375 *result = cpu__max_present_cpu().cpu;
376 } else if (!perf_cpu_map__has_any_cpu(evsel->core.cpus)) {
377 /* Evsel just has specific CPUs. */
378 *result = perf_cpu_map__nr(evsel->core.cpus);
379 } else {
380 /*
381 * "Any CPU" event that can be scheduled on any CPU in
382 * the PMU's cpumask. The PMU cpumask should be saved in
383 * pmu_cpus. If not present fall back to max.
384 */
385 if (!perf_cpu_map__is_empty(evsel->core.pmu_cpus))
386 *result = perf_cpu_map__nr(evsel->core.pmu_cpus);
387 else
388 *result = cpu__max_present_cpu().cpu;
389 }
390 return true;
391
392 case TOOL_PMU__EVENT_NUM_CPUS_ONLINE: {
393 struct perf_cpu_map *online = cpu_map__online();
394
395 if (!online)
396 return false;
397
398 if (!evsel || perf_cpu_map__is_empty(evsel->core.cpus)) {
399 /* No evsel to be specific to. */
400 *result = perf_cpu_map__nr(online);
401 } else if (!perf_cpu_map__has_any_cpu(evsel->core.cpus)) {
402 /* Evsel just has specific CPUs. */
403 struct perf_cpu_map *tmp =
404 perf_cpu_map__intersect(online, evsel->core.cpus);
405
406 *result = perf_cpu_map__nr(tmp);
407 perf_cpu_map__put(tmp);
408 } else {
409 /*
410 * "Any CPU" event that can be scheduled on any CPU in
411 * the PMU's cpumask. The PMU cpumask should be saved in
412 * pmu_cpus, if not present then just the online cpu
413 * mask.
414 */
415 if (!perf_cpu_map__is_empty(evsel->core.pmu_cpus)) {
416 struct perf_cpu_map *tmp =
417 perf_cpu_map__intersect(online, evsel->core.pmu_cpus);
418
419 *result = perf_cpu_map__nr(tmp);
420 perf_cpu_map__put(tmp);
421 } else {
422 *result = perf_cpu_map__nr(online);
423 }
424 }
425 perf_cpu_map__put(online);
426 return true;
427 }
428 case TOOL_PMU__EVENT_NUM_DIES:
429 topology = online_topology();
430 *result = topology->die_cpus_lists;
431 return true;
432
433 case TOOL_PMU__EVENT_NUM_PACKAGES:
434 topology = online_topology();
435 *result = topology->package_cpus_lists;
436 return true;
437
438 case TOOL_PMU__EVENT_SLOTS:
439 *result = tool_pmu__cpu_slots_per_cycle();
440 return *result ? true : false;
441
442 case TOOL_PMU__EVENT_SMT_ON:
443 *result = smt_on() ? 1 : 0;
444 return true;
445
446 case TOOL_PMU__EVENT_SYSTEM_TSC_FREQ:
447 *result = arch_get_tsc_freq();
448 return true;
449
450 case TOOL_PMU__EVENT_CORE_WIDE:
451 *result = core_wide(system_wide, user_requested_cpu_list) ? 1 : 0;
452 return true;
453
454 case TOOL_PMU__EVENT_TARGET_CPU:
455 *result = system_wide || (user_requested_cpu_list != NULL) ? 1 : 0;
456 return true;
457
458 case TOOL_PMU__EVENT_NONE:
459 case TOOL_PMU__EVENT_DURATION_TIME:
460 case TOOL_PMU__EVENT_USER_TIME:
461 case TOOL_PMU__EVENT_SYSTEM_TIME:
462 case TOOL_PMU__EVENT_MAX:
463 default:
464 return false;
465 }
466}
467
468static void perf_counts__update(struct perf_counts_values *count,
469 const struct perf_counts_values *old_count,
470 bool raw, u64 val)
471{
472 /*
473 * The values of enabled and running must make a ratio of 100%. The
474 * exact values don't matter as long as they are non-zero to avoid
475 * issues with evsel__count_has_error.
476 */
477 if (old_count) {
478 count->val = raw ? val : old_count->val + val;
479 count->run = old_count->run + 1;
480 count->ena = old_count->ena + 1;
481 count->lost = old_count->lost;
482 } else {
483 count->val = val;
484 count->run++;
485 count->ena++;
486 count->lost = 0;
487 }
488}
489
490int evsel__tool_pmu_read(struct evsel *evsel, int cpu_map_idx, int thread)
491{
492 __u64 *start_time, cur_time, delta_start;
493 int err = 0;
494 struct perf_counts_values *count, *old_count = NULL;
495 bool adjust = false;
496 enum tool_pmu_event ev = evsel__tool_event(evsel);
497
498 count = perf_counts(counts: evsel->counts, cpu_map_idx, thread);
499 if (evsel->prev_raw_counts)
500 old_count = perf_counts(counts: evsel->prev_raw_counts, cpu_map_idx, thread);
501
502 switch (ev) {
503 case TOOL_PMU__EVENT_HAS_PMEM:
504 case TOOL_PMU__EVENT_NUM_CORES:
505 case TOOL_PMU__EVENT_NUM_CPUS:
506 case TOOL_PMU__EVENT_NUM_CPUS_ONLINE:
507 case TOOL_PMU__EVENT_NUM_DIES:
508 case TOOL_PMU__EVENT_NUM_PACKAGES:
509 case TOOL_PMU__EVENT_SLOTS:
510 case TOOL_PMU__EVENT_SMT_ON:
511 case TOOL_PMU__EVENT_CORE_WIDE:
512 case TOOL_PMU__EVENT_TARGET_CPU:
513 case TOOL_PMU__EVENT_SYSTEM_TSC_FREQ: {
514 u64 val = 0;
515
516 if (cpu_map_idx == 0 && thread == 0) {
517 if (!tool_pmu__read_event(ev, evsel,
518 system_wide: stat_config.system_wide,
519 user_requested_cpu_list: stat_config.user_requested_cpu_list,
520 result: &val)) {
521 count->lost++;
522 val = 0;
523 }
524 }
525 perf_counts__update(count, old_count, /*raw=*/false, val);
526 return 0;
527 }
528 case TOOL_PMU__EVENT_DURATION_TIME:
529 /*
530 * Pretend duration_time is only on the first CPU and thread, or
531 * else aggregation will scale duration_time by the number of
532 * CPUs/threads.
533 */
534 start_time = &evsel->start_time;
535 if (cpu_map_idx == 0 && thread == 0)
536 cur_time = rdclock();
537 else
538 cur_time = *start_time;
539 break;
540 case TOOL_PMU__EVENT_USER_TIME:
541 case TOOL_PMU__EVENT_SYSTEM_TIME: {
542 bool system = evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME;
543 int fd = FD(evsel, cpu_map_idx, thread);
544
545 start_time = xyarray__entry(evsel->start_times, cpu_map_idx, thread);
546 lseek(fd, SEEK_SET, 0);
547 if (evsel->pid_stat) {
548 /* The event exists solely on 1 CPU. */
549 if (cpu_map_idx == 0)
550 err = read_pid_stat_field(fd, field: system ? 15 : 14, val: &cur_time);
551 else
552 cur_time = 0;
553 } else {
554 /* The event is for all threads. */
555 if (thread == 0) {
556 struct perf_cpu cpu = perf_cpu_map__cpu(evsel->core.cpus,
557 cpu_map_idx);
558
559 err = read_stat_field(fd, cpu: cpu, field: system ? 3 : 1, val: &cur_time);
560 } else {
561 cur_time = 0;
562 }
563 }
564 adjust = true;
565 break;
566 }
567 case TOOL_PMU__EVENT_NONE:
568 case TOOL_PMU__EVENT_MAX:
569 default:
570 err = -EINVAL;
571 }
572 if (err)
573 return err;
574
575 delta_start = cur_time - *start_time;
576 if (adjust) {
577 __u64 ticks_per_sec = sysconf(_SC_CLK_TCK);
578
579 delta_start *= 1e9 / ticks_per_sec;
580 }
581 perf_counts__update(count, old_count, /*raw=*/true, val: delta_start);
582 return 0;
583}
584
585struct perf_pmu *tool_pmu__new(void)
586{
587 struct perf_pmu *tool = zalloc(sizeof(struct perf_pmu));
588
589 if (!tool)
590 return NULL;
591
592 if (perf_pmu__init(pmu: tool, type: PERF_PMU_TYPE_TOOL, name: "tool") != 0) {
593 perf_pmu__delete(pmu: tool);
594 return NULL;
595 }
596 tool->events_table = find_core_events_table("common", "common");
597 return tool;
598}
599

source code of linux/tools/perf/util/tool_pmu.c