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