This source file includes following definitions.
- kernel_version_show
- single_gpci_request
- h_gpci_get_value
- h_gpci_event_update
- h_gpci_event_start
- h_gpci_event_stop
- h_gpci_event_add
- h_gpci_event_init
- hv_gpci_init
1
2
3
4
5
6
7
8
9
10 #define pr_fmt(fmt) "hv-gpci: " fmt
11
12 #include <linux/init.h>
13 #include <linux/perf_event.h>
14 #include <asm/firmware.h>
15 #include <asm/hvcall.h>
16 #include <asm/io.h>
17
18 #include "hv-gpci.h"
19 #include "hv-common.h"
20
21
22
23
24
25
26
27
28 EVENT_DEFINE_RANGE_FORMAT(request, config, 0, 31);
29
30
31
32
33
34
35
36 EVENT_DEFINE_RANGE_FORMAT(starting_index, config, 32, 63);
37 EVENT_DEFINE_RANGE_FORMAT_LITE(phys_processor_idx, config, 32, 63);
38 EVENT_DEFINE_RANGE_FORMAT_LITE(sibling_part_id, config, 32, 63);
39 EVENT_DEFINE_RANGE_FORMAT_LITE(hw_chip_id, config, 32, 63);
40 EVENT_DEFINE_RANGE_FORMAT_LITE(partition_id, config, 32, 63);
41
42
43 EVENT_DEFINE_RANGE_FORMAT(secondary_index, config1, 0, 15);
44
45 EVENT_DEFINE_RANGE_FORMAT(counter_info_version, config1, 16, 23);
46
47 EVENT_DEFINE_RANGE_FORMAT(length, config1, 24, 31);
48
49 EVENT_DEFINE_RANGE_FORMAT(offset, config1, 32, 63);
50
51 static struct attribute *format_attrs[] = {
52 &format_attr_request.attr,
53 &format_attr_starting_index.attr,
54 &format_attr_phys_processor_idx.attr,
55 &format_attr_sibling_part_id.attr,
56 &format_attr_hw_chip_id.attr,
57 &format_attr_partition_id.attr,
58 &format_attr_secondary_index.attr,
59 &format_attr_counter_info_version.attr,
60
61 &format_attr_offset.attr,
62 &format_attr_length.attr,
63 NULL,
64 };
65
66 static struct attribute_group format_group = {
67 .name = "format",
68 .attrs = format_attrs,
69 };
70
71 static struct attribute_group event_group = {
72 .name = "events",
73 .attrs = hv_gpci_event_attrs,
74 };
75
76 #define HV_CAPS_ATTR(_name, _format) \
77 static ssize_t _name##_show(struct device *dev, \
78 struct device_attribute *attr, \
79 char *page) \
80 { \
81 struct hv_perf_caps caps; \
82 unsigned long hret = hv_perf_caps_get(&caps); \
83 if (hret) \
84 return -EIO; \
85 \
86 return sprintf(page, _format, caps._name); \
87 } \
88 static struct device_attribute hv_caps_attr_##_name = __ATTR_RO(_name)
89
90 static ssize_t kernel_version_show(struct device *dev,
91 struct device_attribute *attr,
92 char *page)
93 {
94 return sprintf(page, "0x%x\n", COUNTER_INFO_VERSION_CURRENT);
95 }
96
97 static DEVICE_ATTR_RO(kernel_version);
98 HV_CAPS_ATTR(version, "0x%x\n");
99 HV_CAPS_ATTR(ga, "%d\n");
100 HV_CAPS_ATTR(expanded, "%d\n");
101 HV_CAPS_ATTR(lab, "%d\n");
102 HV_CAPS_ATTR(collect_privileged, "%d\n");
103
104 static struct attribute *interface_attrs[] = {
105 &dev_attr_kernel_version.attr,
106 &hv_caps_attr_version.attr,
107 &hv_caps_attr_ga.attr,
108 &hv_caps_attr_expanded.attr,
109 &hv_caps_attr_lab.attr,
110 &hv_caps_attr_collect_privileged.attr,
111 NULL,
112 };
113
114 static struct attribute_group interface_group = {
115 .name = "interface",
116 .attrs = interface_attrs,
117 };
118
119 static const struct attribute_group *attr_groups[] = {
120 &format_group,
121 &event_group,
122 &interface_group,
123 NULL,
124 };
125
126 #define HGPCI_REQ_BUFFER_SIZE 4096
127 #define HGPCI_MAX_DATA_BYTES \
128 (HGPCI_REQ_BUFFER_SIZE - sizeof(struct hv_get_perf_counter_info_params))
129
130 static DEFINE_PER_CPU(char, hv_gpci_reqb[HGPCI_REQ_BUFFER_SIZE]) __aligned(sizeof(uint64_t));
131
132 struct hv_gpci_request_buffer {
133 struct hv_get_perf_counter_info_params params;
134 uint8_t bytes[HGPCI_MAX_DATA_BYTES];
135 } __packed;
136
137 static unsigned long single_gpci_request(u32 req, u32 starting_index,
138 u16 secondary_index, u8 version_in, u32 offset, u8 length,
139 u64 *value)
140 {
141 unsigned long ret;
142 size_t i;
143 u64 count;
144 struct hv_gpci_request_buffer *arg;
145
146 arg = (void *)get_cpu_var(hv_gpci_reqb);
147 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
148
149 arg->params.counter_request = cpu_to_be32(req);
150 arg->params.starting_index = cpu_to_be32(starting_index);
151 arg->params.secondary_index = cpu_to_be16(secondary_index);
152 arg->params.counter_info_version_in = version_in;
153
154 ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
155 virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
156 if (ret) {
157 pr_devel("hcall failed: 0x%lx\n", ret);
158 goto out;
159 }
160
161
162
163
164
165 count = 0;
166 for (i = offset; i < offset + length; i++)
167 count |= arg->bytes[i] << (i - offset);
168
169 *value = count;
170 out:
171 put_cpu_var(hv_gpci_reqb);
172 return ret;
173 }
174
175 static u64 h_gpci_get_value(struct perf_event *event)
176 {
177 u64 count;
178 unsigned long ret = single_gpci_request(event_get_request(event),
179 event_get_starting_index(event),
180 event_get_secondary_index(event),
181 event_get_counter_info_version(event),
182 event_get_offset(event),
183 event_get_length(event),
184 &count);
185 if (ret)
186 return 0;
187 return count;
188 }
189
190 static void h_gpci_event_update(struct perf_event *event)
191 {
192 s64 prev;
193 u64 now = h_gpci_get_value(event);
194 prev = local64_xchg(&event->hw.prev_count, now);
195 local64_add(now - prev, &event->count);
196 }
197
198 static void h_gpci_event_start(struct perf_event *event, int flags)
199 {
200 local64_set(&event->hw.prev_count, h_gpci_get_value(event));
201 }
202
203 static void h_gpci_event_stop(struct perf_event *event, int flags)
204 {
205 h_gpci_event_update(event);
206 }
207
208 static int h_gpci_event_add(struct perf_event *event, int flags)
209 {
210 if (flags & PERF_EF_START)
211 h_gpci_event_start(event, flags);
212
213 return 0;
214 }
215
216 static int h_gpci_event_init(struct perf_event *event)
217 {
218 u64 count;
219 u8 length;
220
221
222 if (event->attr.type != event->pmu->type)
223 return -ENOENT;
224
225
226 if (event->attr.config2) {
227 pr_devel("config2 set when reserved\n");
228 return -EINVAL;
229 }
230
231
232 if (has_branch_stack(event))
233 return -EOPNOTSUPP;
234
235 length = event_get_length(event);
236 if (length < 1 || length > 8) {
237 pr_devel("length invalid\n");
238 return -EINVAL;
239 }
240
241
242 if ((event_get_offset(event) + length) > HGPCI_MAX_DATA_BYTES) {
243 pr_devel("request outside of buffer: %zu > %zu\n",
244 (size_t)event_get_offset(event) + length,
245 HGPCI_MAX_DATA_BYTES);
246 return -EINVAL;
247 }
248
249
250 if (single_gpci_request(event_get_request(event),
251 event_get_starting_index(event),
252 event_get_secondary_index(event),
253 event_get_counter_info_version(event),
254 event_get_offset(event),
255 length,
256 &count)) {
257 pr_devel("gpci hcall failed\n");
258 return -EINVAL;
259 }
260
261 return 0;
262 }
263
264 static struct pmu h_gpci_pmu = {
265 .task_ctx_nr = perf_invalid_context,
266
267 .name = "hv_gpci",
268 .attr_groups = attr_groups,
269 .event_init = h_gpci_event_init,
270 .add = h_gpci_event_add,
271 .del = h_gpci_event_stop,
272 .start = h_gpci_event_start,
273 .stop = h_gpci_event_stop,
274 .read = h_gpci_event_update,
275 .capabilities = PERF_PMU_CAP_NO_EXCLUDE,
276 };
277
278 static int hv_gpci_init(void)
279 {
280 int r;
281 unsigned long hret;
282 struct hv_perf_caps caps;
283
284 hv_gpci_assert_offsets_correct();
285
286 if (!firmware_has_feature(FW_FEATURE_LPAR)) {
287 pr_debug("not a virtualized system, not enabling\n");
288 return -ENODEV;
289 }
290
291 hret = hv_perf_caps_get(&caps);
292 if (hret) {
293 pr_debug("could not obtain capabilities, not enabling, rc=%ld\n",
294 hret);
295 return -ENODEV;
296 }
297
298
299 h_gpci_pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;
300
301 r = perf_pmu_register(&h_gpci_pmu, h_gpci_pmu.name, -1);
302 if (r)
303 return r;
304
305 return 0;
306 }
307
308 device_initcall(hv_gpci_init);