tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/err.h>
3#include <linux/zalloc.h>
4#include <errno.h>
5#include <sys/types.h>
6#include <sys/stat.h>
7#include <fcntl.h>
8#include <sys/param.h>
9#include "evlist.h"
10#include "evsel.h"
11#include "parse-events.h"
12#include "parse-events-hybrid.h"
13#include "debug.h"
14#include "pmu.h"
15#include "pmu-hybrid.h"
16#include "perf.h"
17
18static void config_hybrid_attr(struct perf_event_attr *attr,
19 int type, int pmu_type)
20{
21 /*
22 * attr.config layout for type PERF_TYPE_HARDWARE and
23 * PERF_TYPE_HW_CACHE
24 *
25 * PERF_TYPE_HARDWARE: 0xEEEEEEEE000000AA
26 * AA: hardware event ID
27 * EEEEEEEE: PMU type ID
28 * PERF_TYPE_HW_CACHE: 0xEEEEEEEE00DDCCBB
29 * BB: hardware cache ID
30 * CC: hardware cache op ID
31 * DD: hardware cache op result ID
32 * EEEEEEEE: PMU type ID
33 * If the PMU type ID is 0, the PERF_TYPE_RAW will be applied.
34 */
35 attr->type = type;
36 attr->config = attr->config | ((__u64)pmu_type << PERF_PMU_TYPE_SHIFT);
37}
38
39static int create_event_hybrid(__u32 config_type, int *idx,
40 struct list_head *list,
41 struct perf_event_attr *attr, char *name,
42 struct list_head *config_terms,
43 struct perf_pmu *pmu)
44{
45 struct evsel *evsel;
46 __u32 type = attr->type;
47 __u64 config = attr->config;
48
49 config_hybrid_attr(attr, config_type, pmu->type);
50 evsel = parse_events__add_event_hybrid(list, idx, attr, name,
51 pmu, config_terms);
52 if (evsel)
53 evsel->pmu_name = strdup(pmu->name);
54 else
55 return -ENOMEM;
56
57 attr->type = type;
58 attr->config = config;
59 return 0;
60}
61
62static int pmu_cmp(struct parse_events_state *parse_state,
63 struct perf_pmu *pmu)
64{
65 if (!parse_state->hybrid_pmu_name)
66 return 0;
67
68 return strcmp(parse_state->hybrid_pmu_name, pmu->name);
69}
70
71static int add_hw_hybrid(struct parse_events_state *parse_state,
72 struct list_head *list, struct perf_event_attr *attr,
73 char *name, struct list_head *config_terms)
74{
75 struct perf_pmu *pmu;
76 int ret;
77
78 perf_pmu__for_each_hybrid_pmu(pmu) {
79 if (pmu_cmp(parse_state, pmu))
80 continue;
81
82 ret = create_event_hybrid(PERF_TYPE_HARDWARE,
83 &parse_state->idx, list, attr, name,
84 config_terms, pmu);
85 if (ret)
86 return ret;
87 }
88
89 return 0;
90}
91
92static int create_raw_event_hybrid(int *idx, struct list_head *list,
93 struct perf_event_attr *attr, char *name,
94 struct list_head *config_terms,
95 struct perf_pmu *pmu)
96{
97 struct evsel *evsel;
98
99 attr->type = pmu->type;
100 evsel = parse_events__add_event_hybrid(list, idx, attr, name,
101 pmu, config_terms);
102 if (evsel)
103 evsel->pmu_name = strdup(pmu->name);
104 else
105 return -ENOMEM;
106
107 return 0;
108}
109
110static int add_raw_hybrid(struct parse_events_state *parse_state,
111 struct list_head *list, struct perf_event_attr *attr,
112 char *name, struct list_head *config_terms)
113{
114 struct perf_pmu *pmu;
115 int ret;
116
117 perf_pmu__for_each_hybrid_pmu(pmu) {
118 if (pmu_cmp(parse_state, pmu))
119 continue;
120
121 ret = create_raw_event_hybrid(&parse_state->idx, list, attr,
122 name, config_terms, pmu);
123 if (ret)
124 return ret;
125 }
126
127 return 0;
128}
129
130int parse_events__add_numeric_hybrid(struct parse_events_state *parse_state,
131 struct list_head *list,
132 struct perf_event_attr *attr,
133 char *name, struct list_head *config_terms,
134 bool *hybrid)
135{
136 *hybrid = false;
137 if (attr->type == PERF_TYPE_SOFTWARE)
138 return 0;
139
140 if (!perf_pmu__has_hybrid())
141 return 0;
142
143 *hybrid = true;
144 if (attr->type != PERF_TYPE_RAW) {
145 return add_hw_hybrid(parse_state, list, attr, name,
146 config_terms);
147 }
148
149 return add_raw_hybrid(parse_state, list, attr, name,
150 config_terms);
151}
152
153int parse_events__add_cache_hybrid(struct list_head *list, int *idx,
154 struct perf_event_attr *attr, char *name,
155 struct list_head *config_terms,
156 bool *hybrid,
157 struct parse_events_state *parse_state)
158{
159 struct perf_pmu *pmu;
160 int ret;
161
162 *hybrid = false;
163 if (!perf_pmu__has_hybrid())
164 return 0;
165
166 *hybrid = true;
167 perf_pmu__for_each_hybrid_pmu(pmu) {
168 if (pmu_cmp(parse_state, pmu))
169 continue;
170
171 ret = create_event_hybrid(PERF_TYPE_HW_CACHE, idx, list,
172 attr, name, config_terms, pmu);
173 if (ret)
174 return ret;
175 }
176
177 return 0;
178}