1 /*
2 * Copyright 2014, Michael Ellerman, IBM Corp.
3 * Licensed under GPLv2.
4 */
5
6 #define _GNU_SOURCE /* For CPU_ZERO etc. */
7
8 #include <sched.h>
9 #include <sys/wait.h>
10 #include <setjmp.h>
11 #include <signal.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <sys/ioctl.h>
16
17 #include "trace.h"
18 #include "reg.h"
19 #include "ebb.h"
20
21
22 void (*ebb_user_func)(void);
23
ebb_hook(void)24 void ebb_hook(void)
25 {
26 if (ebb_user_func)
27 ebb_user_func();
28 }
29
30 struct ebb_state ebb_state;
31
32 u64 sample_period = 0x40000000ull;
33
reset_ebb_with_clear_mask(unsigned long mmcr0_clear_mask)34 void reset_ebb_with_clear_mask(unsigned long mmcr0_clear_mask)
35 {
36 u64 val;
37
38 /* 2) clear MMCR0[PMAO] - docs say BESCR[PMEO] should do this */
39 /* 3) set MMCR0[PMAE] - docs say BESCR[PME] should do this */
40 val = mfspr(SPRN_MMCR0);
41 mtspr(SPRN_MMCR0, (val & ~mmcr0_clear_mask) | MMCR0_PMAE);
42
43 /* 4) clear BESCR[PMEO] */
44 mtspr(SPRN_BESCRR, BESCR_PMEO);
45
46 /* 5) set BESCR[PME] */
47 mtspr(SPRN_BESCRS, BESCR_PME);
48
49 /* 6) rfebb 1 - done in our caller */
50 }
51
reset_ebb(void)52 void reset_ebb(void)
53 {
54 reset_ebb_with_clear_mask(MMCR0_PMAO | MMCR0_FC);
55 }
56
57 /* Called outside of the EBB handler to check MMCR0 is sane */
ebb_check_mmcr0(void)58 int ebb_check_mmcr0(void)
59 {
60 u64 val;
61
62 val = mfspr(SPRN_MMCR0);
63 if ((val & (MMCR0_FC | MMCR0_PMAO)) == MMCR0_FC) {
64 /* It's OK if we see FC & PMAO, but not FC by itself */
65 printf("Outside of loop, only FC set 0x%llx\n", val);
66 return 1;
67 }
68
69 return 0;
70 }
71
ebb_check_count(int pmc,u64 sample_period,int fudge)72 bool ebb_check_count(int pmc, u64 sample_period, int fudge)
73 {
74 u64 count, upper, lower;
75
76 count = ebb_state.stats.pmc_count[PMC_INDEX(pmc)];
77
78 lower = ebb_state.stats.ebb_count * (sample_period - fudge);
79
80 if (count < lower) {
81 printf("PMC%d count (0x%llx) below lower limit 0x%llx (-0x%llx)\n",
82 pmc, count, lower, lower - count);
83 return false;
84 }
85
86 upper = ebb_state.stats.ebb_count * (sample_period + fudge);
87
88 if (count > upper) {
89 printf("PMC%d count (0x%llx) above upper limit 0x%llx (+0x%llx)\n",
90 pmc, count, upper, count - upper);
91 return false;
92 }
93
94 printf("PMC%d count (0x%llx) is between 0x%llx and 0x%llx delta +0x%llx/-0x%llx\n",
95 pmc, count, lower, upper, count - lower, upper - count);
96
97 return true;
98 }
99
standard_ebb_callee(void)100 void standard_ebb_callee(void)
101 {
102 int found, i;
103 u64 val;
104
105 val = mfspr(SPRN_BESCR);
106 if (!(val & BESCR_PMEO)) {
107 ebb_state.stats.spurious++;
108 goto out;
109 }
110
111 ebb_state.stats.ebb_count++;
112 trace_log_counter(ebb_state.trace, ebb_state.stats.ebb_count);
113
114 val = mfspr(SPRN_MMCR0);
115 trace_log_reg(ebb_state.trace, SPRN_MMCR0, val);
116
117 found = 0;
118 for (i = 1; i <= 6; i++) {
119 if (ebb_state.pmc_enable[PMC_INDEX(i)])
120 found += count_pmc(i, sample_period);
121 }
122
123 if (!found)
124 ebb_state.stats.no_overflow++;
125
126 out:
127 reset_ebb();
128 }
129
130 extern void ebb_handler(void);
131
setup_ebb_handler(void (* callee)(void))132 void setup_ebb_handler(void (*callee)(void))
133 {
134 u64 entry;
135
136 #if defined(_CALL_ELF) && _CALL_ELF == 2
137 entry = (u64)ebb_handler;
138 #else
139 struct opd
140 {
141 u64 entry;
142 u64 toc;
143 } *opd;
144
145 opd = (struct opd *)ebb_handler;
146 entry = opd->entry;
147 #endif
148 printf("EBB Handler is at %#llx\n", entry);
149
150 ebb_user_func = callee;
151
152 /* Ensure ebb_user_func is set before we set the handler */
153 mb();
154 mtspr(SPRN_EBBHR, entry);
155
156 /* Make sure the handler is set before we return */
157 mb();
158 }
159
clear_ebb_stats(void)160 void clear_ebb_stats(void)
161 {
162 memset(&ebb_state.stats, 0, sizeof(ebb_state.stats));
163 }
164
dump_summary_ebb_state(void)165 void dump_summary_ebb_state(void)
166 {
167 printf("ebb_state:\n" \
168 " ebb_count = %d\n" \
169 " spurious = %d\n" \
170 " negative = %d\n" \
171 " no_overflow = %d\n" \
172 " pmc[1] count = 0x%llx\n" \
173 " pmc[2] count = 0x%llx\n" \
174 " pmc[3] count = 0x%llx\n" \
175 " pmc[4] count = 0x%llx\n" \
176 " pmc[5] count = 0x%llx\n" \
177 " pmc[6] count = 0x%llx\n",
178 ebb_state.stats.ebb_count, ebb_state.stats.spurious,
179 ebb_state.stats.negative, ebb_state.stats.no_overflow,
180 ebb_state.stats.pmc_count[0], ebb_state.stats.pmc_count[1],
181 ebb_state.stats.pmc_count[2], ebb_state.stats.pmc_count[3],
182 ebb_state.stats.pmc_count[4], ebb_state.stats.pmc_count[5]);
183 }
184
decode_mmcr0(u32 value)185 static char *decode_mmcr0(u32 value)
186 {
187 static char buf[16];
188
189 buf[0] = '\0';
190
191 if (value & (1 << 31))
192 strcat(buf, "FC ");
193 if (value & (1 << 26))
194 strcat(buf, "PMAE ");
195 if (value & (1 << 7))
196 strcat(buf, "PMAO ");
197
198 return buf;
199 }
200
decode_bescr(u64 value)201 static char *decode_bescr(u64 value)
202 {
203 static char buf[16];
204
205 buf[0] = '\0';
206
207 if (value & (1ull << 63))
208 strcat(buf, "GE ");
209 if (value & (1ull << 32))
210 strcat(buf, "PMAE ");
211 if (value & 1)
212 strcat(buf, "PMAO ");
213
214 return buf;
215 }
216
dump_ebb_hw_state(void)217 void dump_ebb_hw_state(void)
218 {
219 u64 bescr;
220 u32 mmcr0;
221
222 mmcr0 = mfspr(SPRN_MMCR0);
223 bescr = mfspr(SPRN_BESCR);
224
225 printf("HW state:\n" \
226 "MMCR0 0x%016x %s\n" \
227 "MMCR2 0x%016lx\n" \
228 "EBBHR 0x%016lx\n" \
229 "BESCR 0x%016llx %s\n" \
230 "PMC1 0x%016lx\n" \
231 "PMC2 0x%016lx\n" \
232 "PMC3 0x%016lx\n" \
233 "PMC4 0x%016lx\n" \
234 "PMC5 0x%016lx\n" \
235 "PMC6 0x%016lx\n" \
236 "SIAR 0x%016lx\n",
237 mmcr0, decode_mmcr0(mmcr0), mfspr(SPRN_MMCR2),
238 mfspr(SPRN_EBBHR), bescr, decode_bescr(bescr),
239 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2), mfspr(SPRN_PMC3),
240 mfspr(SPRN_PMC4), mfspr(SPRN_PMC5), mfspr(SPRN_PMC6),
241 mfspr(SPRN_SIAR));
242 }
243
dump_ebb_state(void)244 void dump_ebb_state(void)
245 {
246 dump_summary_ebb_state();
247
248 dump_ebb_hw_state();
249
250 trace_buffer_print(ebb_state.trace);
251 }
252
count_pmc(int pmc,uint32_t sample_period)253 int count_pmc(int pmc, uint32_t sample_period)
254 {
255 uint32_t start_value;
256 u64 val;
257
258 /* 0) Read PMC */
259 start_value = pmc_sample_period(sample_period);
260
261 val = read_pmc(pmc);
262 if (val < start_value)
263 ebb_state.stats.negative++;
264 else
265 ebb_state.stats.pmc_count[PMC_INDEX(pmc)] += val - start_value;
266
267 trace_log_reg(ebb_state.trace, SPRN_PMC1 + pmc - 1, val);
268
269 /* 1) Reset PMC */
270 write_pmc(pmc, start_value);
271
272 /* Report if we overflowed */
273 return val >= COUNTER_OVERFLOW;
274 }
275
ebb_event_enable(struct event * e)276 int ebb_event_enable(struct event *e)
277 {
278 int rc;
279
280 /* Ensure any SPR writes are ordered vs us */
281 mb();
282
283 rc = ioctl(e->fd, PERF_EVENT_IOC_ENABLE);
284 if (rc)
285 return rc;
286
287 rc = event_read(e);
288
289 /* Ditto */
290 mb();
291
292 return rc;
293 }
294
ebb_freeze_pmcs(void)295 void ebb_freeze_pmcs(void)
296 {
297 mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
298 mb();
299 }
300
ebb_unfreeze_pmcs(void)301 void ebb_unfreeze_pmcs(void)
302 {
303 /* Unfreeze counters */
304 mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_FC);
305 mb();
306 }
307
ebb_global_enable(void)308 void ebb_global_enable(void)
309 {
310 /* Enable EBBs globally and PMU EBBs */
311 mtspr(SPRN_BESCR, 0x8000000100000000ull);
312 mb();
313 }
314
ebb_global_disable(void)315 void ebb_global_disable(void)
316 {
317 /* Disable EBBs & freeze counters, events are still scheduled */
318 mtspr(SPRN_BESCRR, BESCR_PME);
319 mb();
320 }
321
event_ebb_init(struct event * e)322 void event_ebb_init(struct event *e)
323 {
324 e->attr.config |= (1ull << 63);
325 }
326
event_bhrb_init(struct event * e,unsigned ifm)327 void event_bhrb_init(struct event *e, unsigned ifm)
328 {
329 e->attr.config |= (1ull << 62) | ((u64)ifm << 60);
330 }
331
event_leader_ebb_init(struct event * e)332 void event_leader_ebb_init(struct event *e)
333 {
334 event_ebb_init(e);
335
336 e->attr.exclusive = 1;
337 e->attr.pinned = 1;
338 }
339
ebb_child(union pipe read_pipe,union pipe write_pipe)340 int ebb_child(union pipe read_pipe, union pipe write_pipe)
341 {
342 struct event event;
343 uint64_t val;
344
345 FAIL_IF(wait_for_parent(read_pipe));
346
347 event_init_named(&event, 0x1001e, "cycles");
348 event_leader_ebb_init(&event);
349
350 event.attr.exclude_kernel = 1;
351 event.attr.exclude_hv = 1;
352 event.attr.exclude_idle = 1;
353
354 FAIL_IF(event_open(&event));
355
356 ebb_enable_pmc_counting(1);
357 setup_ebb_handler(standard_ebb_callee);
358 ebb_global_enable();
359
360 FAIL_IF(event_enable(&event));
361
362 if (event_read(&event)) {
363 /*
364 * Some tests expect to fail here, so don't report an error on
365 * this line, and return a distinguisable error code. Tell the
366 * parent an error happened.
367 */
368 notify_parent_of_error(write_pipe);
369 return 2;
370 }
371
372 mtspr(SPRN_PMC1, pmc_sample_period(sample_period));
373
374 FAIL_IF(notify_parent(write_pipe));
375 FAIL_IF(wait_for_parent(read_pipe));
376 FAIL_IF(notify_parent(write_pipe));
377
378 while (ebb_state.stats.ebb_count < 20) {
379 FAIL_IF(core_busy_loop());
380
381 /* To try and hit SIGILL case */
382 val = mfspr(SPRN_MMCRA);
383 val |= mfspr(SPRN_MMCR2);
384 val |= mfspr(SPRN_MMCR0);
385 }
386
387 ebb_global_disable();
388 ebb_freeze_pmcs();
389
390 count_pmc(1, sample_period);
391
392 dump_ebb_state();
393
394 event_close(&event);
395
396 FAIL_IF(ebb_state.stats.ebb_count == 0);
397
398 return 0;
399 }
400
401 static jmp_buf setjmp_env;
402
sigill_handler(int signal)403 static void sigill_handler(int signal)
404 {
405 printf("Took sigill\n");
406 longjmp(setjmp_env, 1);
407 }
408
409 static struct sigaction sigill_action = {
410 .sa_handler = sigill_handler,
411 };
412
catch_sigill(void (* func)(void))413 int catch_sigill(void (*func)(void))
414 {
415 if (sigaction(SIGILL, &sigill_action, NULL)) {
416 perror("sigaction");
417 return 1;
418 }
419
420 if (setjmp(setjmp_env) == 0) {
421 func();
422 return 1;
423 }
424
425 return 0;
426 }
427
write_pmc1(void)428 void write_pmc1(void)
429 {
430 mtspr(SPRN_PMC1, 0);
431 }
432
write_pmc(int pmc,u64 value)433 void write_pmc(int pmc, u64 value)
434 {
435 switch (pmc) {
436 case 1: mtspr(SPRN_PMC1, value); break;
437 case 2: mtspr(SPRN_PMC2, value); break;
438 case 3: mtspr(SPRN_PMC3, value); break;
439 case 4: mtspr(SPRN_PMC4, value); break;
440 case 5: mtspr(SPRN_PMC5, value); break;
441 case 6: mtspr(SPRN_PMC6, value); break;
442 }
443 }
444
read_pmc(int pmc)445 u64 read_pmc(int pmc)
446 {
447 switch (pmc) {
448 case 1: return mfspr(SPRN_PMC1);
449 case 2: return mfspr(SPRN_PMC2);
450 case 3: return mfspr(SPRN_PMC3);
451 case 4: return mfspr(SPRN_PMC4);
452 case 5: return mfspr(SPRN_PMC5);
453 case 6: return mfspr(SPRN_PMC6);
454 }
455
456 return 0;
457 }
458
term_handler(int signal)459 static void term_handler(int signal)
460 {
461 dump_summary_ebb_state();
462 dump_ebb_hw_state();
463 abort();
464 }
465
466 struct sigaction term_action = {
467 .sa_handler = term_handler,
468 };
469
ebb_init(void)470 static void __attribute__((constructor)) ebb_init(void)
471 {
472 clear_ebb_stats();
473
474 if (sigaction(SIGTERM, &term_action, NULL))
475 perror("sigaction");
476
477 ebb_state.trace = trace_buffer_allocate(1 * 1024 * 1024);
478 }
479