1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright(C) 2015 Linaro Limited. All rights reserved.
4 * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
5 */
6
7#include <dirent.h>
8#include <errno.h>
9#include <stdbool.h>
10#include <linux/coresight-pmu.h>
11#include <linux/zalloc.h>
12#include <api/fs/fs.h>
13
14#include "../../../util/auxtrace.h"
15#include "../../../util/debug.h"
16#include "../../../util/evlist.h"
17#include "../../../util/pmu.h"
18#include "../../../util/pmus.h"
19#include "cs-etm.h"
20#include "arm-spe.h"
21#include "hisi-ptt.h"
22
23static struct perf_pmu **find_all_arm_spe_pmus(int *nr_spes, int *err)
24{
25 struct perf_pmu **arm_spe_pmus = NULL;
26 int ret, i, nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
27 /* arm_spe_xxxxxxxxx\0 */
28 char arm_spe_pmu_name[sizeof(ARM_SPE_PMU_NAME) + 10];
29
30 arm_spe_pmus = zalloc(sizeof(struct perf_pmu *) * nr_cpus);
31 if (!arm_spe_pmus) {
32 pr_err("spes alloc failed\n");
33 *err = -ENOMEM;
34 return NULL;
35 }
36
37 for (i = 0; i < nr_cpus; i++) {
38 ret = sprintf(buf: arm_spe_pmu_name, fmt: "%s%d", ARM_SPE_PMU_NAME, i);
39 if (ret < 0) {
40 pr_err("sprintf failed\n");
41 *err = -ENOMEM;
42 return NULL;
43 }
44
45 arm_spe_pmus[*nr_spes] = perf_pmus__find(name: arm_spe_pmu_name);
46 if (arm_spe_pmus[*nr_spes]) {
47 pr_debug2("%s %d: arm_spe_pmu %d type %d name %s\n",
48 __func__, __LINE__, *nr_spes,
49 arm_spe_pmus[*nr_spes]->type,
50 arm_spe_pmus[*nr_spes]->name);
51 (*nr_spes)++;
52 }
53 }
54
55 return arm_spe_pmus;
56}
57
58static struct perf_pmu **find_all_hisi_ptt_pmus(int *nr_ptts, int *err)
59{
60 struct perf_pmu **hisi_ptt_pmus = NULL;
61 struct dirent *dent;
62 char path[PATH_MAX];
63 DIR *dir = NULL;
64 int idx = 0;
65
66 perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
67 dir = opendir(path);
68 if (!dir) {
69 pr_err("can't read directory '%s'\n", path);
70 *err = -EINVAL;
71 return NULL;
72 }
73
74 while ((dent = readdir(dir))) {
75 if (strstr(dent->d_name, HISI_PTT_PMU_NAME))
76 (*nr_ptts)++;
77 }
78
79 if (!(*nr_ptts))
80 goto out;
81
82 hisi_ptt_pmus = zalloc(sizeof(struct perf_pmu *) * (*nr_ptts));
83 if (!hisi_ptt_pmus) {
84 pr_err("hisi_ptt alloc failed\n");
85 *err = -ENOMEM;
86 goto out;
87 }
88
89 rewinddir(dir);
90 while ((dent = readdir(dir))) {
91 if (strstr(dent->d_name, HISI_PTT_PMU_NAME) && idx < *nr_ptts) {
92 hisi_ptt_pmus[idx] = perf_pmus__find(name: dent->d_name);
93 if (hisi_ptt_pmus[idx])
94 idx++;
95 }
96 }
97
98out:
99 closedir(dir);
100 return hisi_ptt_pmus;
101}
102
103static struct perf_pmu *find_pmu_for_event(struct perf_pmu **pmus,
104 int pmu_nr, struct evsel *evsel)
105{
106 int i;
107
108 if (!pmus)
109 return NULL;
110
111 for (i = 0; i < pmu_nr; i++) {
112 if (evsel->core.attr.type == pmus[i]->type)
113 return pmus[i];
114 }
115
116 return NULL;
117}
118
119struct auxtrace_record
120*auxtrace_record__init(struct evlist *evlist, int *err)
121{
122 struct perf_pmu *cs_etm_pmu = NULL;
123 struct perf_pmu **arm_spe_pmus = NULL;
124 struct perf_pmu **hisi_ptt_pmus = NULL;
125 struct evsel *evsel;
126 struct perf_pmu *found_etm = NULL;
127 struct perf_pmu *found_spe = NULL;
128 struct perf_pmu *found_ptt = NULL;
129 int auxtrace_event_cnt = 0;
130 int nr_spes = 0;
131 int nr_ptts = 0;
132
133 if (!evlist)
134 return NULL;
135
136 cs_etm_pmu = perf_pmus__find(CORESIGHT_ETM_PMU_NAME);
137 arm_spe_pmus = find_all_arm_spe_pmus(nr_spes: &nr_spes, err);
138 hisi_ptt_pmus = find_all_hisi_ptt_pmus(nr_ptts: &nr_ptts, err);
139
140 evlist__for_each_entry(evlist, evsel) {
141 if (cs_etm_pmu && !found_etm)
142 found_etm = find_pmu_for_event(pmus: &cs_etm_pmu, pmu_nr: 1, evsel);
143
144 if (arm_spe_pmus && !found_spe)
145 found_spe = find_pmu_for_event(pmus: arm_spe_pmus, pmu_nr: nr_spes, evsel);
146
147 if (hisi_ptt_pmus && !found_ptt)
148 found_ptt = find_pmu_for_event(pmus: hisi_ptt_pmus, pmu_nr: nr_ptts, evsel);
149 }
150
151 free(arm_spe_pmus);
152 free(hisi_ptt_pmus);
153
154 if (found_etm)
155 auxtrace_event_cnt++;
156
157 if (found_spe)
158 auxtrace_event_cnt++;
159
160 if (found_ptt)
161 auxtrace_event_cnt++;
162
163 if (auxtrace_event_cnt > 1) {
164 pr_err("Concurrent AUX trace operation not currently supported\n");
165 *err = -EOPNOTSUPP;
166 return NULL;
167 }
168
169 if (found_etm)
170 return cs_etm_record_init(err);
171
172#if defined(__aarch64__)
173 if (found_spe)
174 return arm_spe_recording_init(err, found_spe);
175
176 if (found_ptt)
177 return hisi_ptt_recording_init(err, found_ptt);
178#endif
179
180 /*
181 * Clear 'err' even if we haven't found an event - that way perf
182 * record can still be used even if tracers aren't present. The NULL
183 * return value will take care of telling the infrastructure HW tracing
184 * isn't available.
185 */
186 *err = 0;
187 return NULL;
188}
189
190#if defined(__arm__)
191u64 compat_auxtrace_mmap__read_head(struct auxtrace_mmap *mm)
192{
193 struct perf_event_mmap_page *pc = mm->userpg;
194 u64 result;
195
196 __asm__ __volatile__(
197" ldrd %0, %H0, [%1]"
198 : "=&r" (result)
199 : "r" (&pc->aux_head), "Qo" (pc->aux_head)
200 );
201
202 return result;
203}
204
205int compat_auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail)
206{
207 struct perf_event_mmap_page *pc = mm->userpg;
208
209 /* Ensure all reads are done before we write the tail out */
210 smp_mb();
211
212 __asm__ __volatile__(
213" strd %2, %H2, [%1]"
214 : "=Qo" (pc->aux_tail)
215 : "r" (&pc->aux_tail), "r" (tail)
216 );
217
218 return 0;
219}
220#endif
221

source code of linux/tools/perf/arch/arm/util/auxtrace.c