2 * Copyright 2014, Michael Ellerman, IBM Corp.
3 * Licensed under GPLv2.
6 #define _GNU_SOURCE /* For CPU_ZERO etc. */
15 #include <sys/ioctl.h>
16 #include <linux/auxvec.h>
23 void (*ebb_user_func)(void);
31 struct ebb_state ebb_state;
33 u64 sample_period = 0x40000000ull;
35 void reset_ebb_with_clear_mask(unsigned long mmcr0_clear_mask)
39 /* 2) clear MMCR0[PMAO] - docs say BESCR[PMEO] should do this */
40 /* 3) set MMCR0[PMAE] - docs say BESCR[PME] should do this */
41 val = mfspr(SPRN_MMCR0);
42 mtspr(SPRN_MMCR0, (val & ~mmcr0_clear_mask) | MMCR0_PMAE);
44 /* 4) clear BESCR[PMEO] */
45 mtspr(SPRN_BESCRR, BESCR_PMEO);
47 /* 5) set BESCR[PME] */
48 mtspr(SPRN_BESCRS, BESCR_PME);
50 /* 6) rfebb 1 - done in our caller */
55 reset_ebb_with_clear_mask(MMCR0_PMAO | MMCR0_FC);
58 /* Called outside of the EBB handler to check MMCR0 is sane */
59 int ebb_check_mmcr0(void)
63 val = mfspr(SPRN_MMCR0);
64 if ((val & (MMCR0_FC | MMCR0_PMAO)) == MMCR0_FC) {
65 /* It's OK if we see FC & PMAO, but not FC by itself */
66 printf("Outside of loop, only FC set 0x%llx\n", val);
73 bool ebb_check_count(int pmc, u64 sample_period, int fudge)
75 u64 count, upper, lower;
77 count = ebb_state.stats.pmc_count[PMC_INDEX(pmc)];
79 lower = ebb_state.stats.ebb_count * (sample_period - fudge);
82 printf("PMC%d count (0x%llx) below lower limit 0x%llx (-0x%llx)\n",
83 pmc, count, lower, lower - count);
87 upper = ebb_state.stats.ebb_count * (sample_period + fudge);
90 printf("PMC%d count (0x%llx) above upper limit 0x%llx (+0x%llx)\n",
91 pmc, count, upper, count - upper);
95 printf("PMC%d count (0x%llx) is between 0x%llx and 0x%llx delta +0x%llx/-0x%llx\n",
96 pmc, count, lower, upper, count - lower, upper - count);
101 void standard_ebb_callee(void)
106 val = mfspr(SPRN_BESCR);
107 if (!(val & BESCR_PMEO)) {
108 ebb_state.stats.spurious++;
112 ebb_state.stats.ebb_count++;
113 trace_log_counter(ebb_state.trace, ebb_state.stats.ebb_count);
115 val = mfspr(SPRN_MMCR0);
116 trace_log_reg(ebb_state.trace, SPRN_MMCR0, val);
119 for (i = 1; i <= 6; i++) {
120 if (ebb_state.pmc_enable[PMC_INDEX(i)])
121 found += count_pmc(i, sample_period);
125 ebb_state.stats.no_overflow++;
131 extern void ebb_handler(void);
133 void setup_ebb_handler(void (*callee)(void))
137 #if defined(_CALL_ELF) && _CALL_ELF == 2
138 entry = (u64)ebb_handler;
146 opd = (struct opd *)ebb_handler;
149 printf("EBB Handler is at %#llx\n", entry);
151 ebb_user_func = callee;
153 /* Ensure ebb_user_func is set before we set the handler */
155 mtspr(SPRN_EBBHR, entry);
157 /* Make sure the handler is set before we return */
161 void clear_ebb_stats(void)
163 memset(&ebb_state.stats, 0, sizeof(ebb_state.stats));
166 void dump_summary_ebb_state(void)
168 printf("ebb_state:\n" \
169 " ebb_count = %d\n" \
172 " no_overflow = %d\n" \
173 " pmc[1] count = 0x%llx\n" \
174 " pmc[2] count = 0x%llx\n" \
175 " pmc[3] count = 0x%llx\n" \
176 " pmc[4] count = 0x%llx\n" \
177 " pmc[5] count = 0x%llx\n" \
178 " pmc[6] count = 0x%llx\n",
179 ebb_state.stats.ebb_count, ebb_state.stats.spurious,
180 ebb_state.stats.negative, ebb_state.stats.no_overflow,
181 ebb_state.stats.pmc_count[0], ebb_state.stats.pmc_count[1],
182 ebb_state.stats.pmc_count[2], ebb_state.stats.pmc_count[3],
183 ebb_state.stats.pmc_count[4], ebb_state.stats.pmc_count[5]);
186 static char *decode_mmcr0(u32 value)
192 if (value & (1 << 31))
194 if (value & (1 << 26))
195 strcat(buf, "PMAE ");
196 if (value & (1 << 7))
197 strcat(buf, "PMAO ");
202 static char *decode_bescr(u64 value)
208 if (value & (1ull << 63))
210 if (value & (1ull << 32))
211 strcat(buf, "PMAE ");
213 strcat(buf, "PMAO ");
218 void dump_ebb_hw_state(void)
223 mmcr0 = mfspr(SPRN_MMCR0);
224 bescr = mfspr(SPRN_BESCR);
226 printf("HW state:\n" \
227 "MMCR0 0x%016x %s\n" \
230 "BESCR 0x%016llx %s\n" \
238 mmcr0, decode_mmcr0(mmcr0), mfspr(SPRN_MMCR2),
239 mfspr(SPRN_EBBHR), bescr, decode_bescr(bescr),
240 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2), mfspr(SPRN_PMC3),
241 mfspr(SPRN_PMC4), mfspr(SPRN_PMC5), mfspr(SPRN_PMC6),
245 void dump_ebb_state(void)
247 dump_summary_ebb_state();
251 trace_buffer_print(ebb_state.trace);
254 int count_pmc(int pmc, uint32_t sample_period)
256 uint32_t start_value;
260 start_value = pmc_sample_period(sample_period);
263 if (val < start_value)
264 ebb_state.stats.negative++;
266 ebb_state.stats.pmc_count[PMC_INDEX(pmc)] += val - start_value;
268 trace_log_reg(ebb_state.trace, SPRN_PMC1 + pmc - 1, val);
271 write_pmc(pmc, start_value);
273 /* Report if we overflowed */
274 return val >= COUNTER_OVERFLOW;
277 int ebb_event_enable(struct event *e)
281 /* Ensure any SPR writes are ordered vs us */
284 rc = ioctl(e->fd, PERF_EVENT_IOC_ENABLE);
296 void ebb_freeze_pmcs(void)
298 mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
302 void ebb_unfreeze_pmcs(void)
304 /* Unfreeze counters */
305 mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_FC);
309 void ebb_global_enable(void)
311 /* Enable EBBs globally and PMU EBBs */
312 mtspr(SPRN_BESCR, 0x8000000100000000ull);
316 void ebb_global_disable(void)
318 /* Disable EBBs & freeze counters, events are still scheduled */
319 mtspr(SPRN_BESCRR, BESCR_PME);
323 bool ebb_is_supported(void)
325 #ifdef PPC_FEATURE2_EBB
326 /* EBB requires at least POWER8 */
327 return ((long)get_auxv_entry(AT_HWCAP2) & PPC_FEATURE2_EBB);
333 void event_ebb_init(struct event *e)
335 e->attr.config |= (1ull << 63);
338 void event_bhrb_init(struct event *e, unsigned ifm)
340 e->attr.config |= (1ull << 62) | ((u64)ifm << 60);
343 void event_leader_ebb_init(struct event *e)
347 e->attr.exclusive = 1;
351 int ebb_child(union pipe read_pipe, union pipe write_pipe)
356 FAIL_IF(wait_for_parent(read_pipe));
358 event_init_named(&event, 0x1001e, "cycles");
359 event_leader_ebb_init(&event);
361 event.attr.exclude_kernel = 1;
362 event.attr.exclude_hv = 1;
363 event.attr.exclude_idle = 1;
365 FAIL_IF(event_open(&event));
367 ebb_enable_pmc_counting(1);
368 setup_ebb_handler(standard_ebb_callee);
371 FAIL_IF(event_enable(&event));
373 if (event_read(&event)) {
375 * Some tests expect to fail here, so don't report an error on
376 * this line, and return a distinguisable error code. Tell the
377 * parent an error happened.
379 notify_parent_of_error(write_pipe);
383 mtspr(SPRN_PMC1, pmc_sample_period(sample_period));
385 FAIL_IF(notify_parent(write_pipe));
386 FAIL_IF(wait_for_parent(read_pipe));
387 FAIL_IF(notify_parent(write_pipe));
389 while (ebb_state.stats.ebb_count < 20) {
390 FAIL_IF(core_busy_loop());
392 /* To try and hit SIGILL case */
393 val = mfspr(SPRN_MMCRA);
394 val |= mfspr(SPRN_MMCR2);
395 val |= mfspr(SPRN_MMCR0);
398 ebb_global_disable();
401 count_pmc(1, sample_period);
407 FAIL_IF(ebb_state.stats.ebb_count == 0);
412 static jmp_buf setjmp_env;
414 static void sigill_handler(int signal)
416 printf("Took sigill\n");
417 longjmp(setjmp_env, 1);
420 static struct sigaction sigill_action = {
421 .sa_handler = sigill_handler,
424 int catch_sigill(void (*func)(void))
426 if (sigaction(SIGILL, &sigill_action, NULL)) {
431 if (setjmp(setjmp_env) == 0) {
439 void write_pmc1(void)
444 void write_pmc(int pmc, u64 value)
447 case 1: mtspr(SPRN_PMC1, value); break;
448 case 2: mtspr(SPRN_PMC2, value); break;
449 case 3: mtspr(SPRN_PMC3, value); break;
450 case 4: mtspr(SPRN_PMC4, value); break;
451 case 5: mtspr(SPRN_PMC5, value); break;
452 case 6: mtspr(SPRN_PMC6, value); break;
456 u64 read_pmc(int pmc)
459 case 1: return mfspr(SPRN_PMC1);
460 case 2: return mfspr(SPRN_PMC2);
461 case 3: return mfspr(SPRN_PMC3);
462 case 4: return mfspr(SPRN_PMC4);
463 case 5: return mfspr(SPRN_PMC5);
464 case 6: return mfspr(SPRN_PMC6);
470 static void term_handler(int signal)
472 dump_summary_ebb_state();
477 struct sigaction term_action = {
478 .sa_handler = term_handler,
481 static void __attribute__((constructor)) ebb_init(void)
485 if (sigaction(SIGTERM, &term_action, NULL))
488 ebb_state.trace = trace_buffer_allocate(1 * 1024 * 1024);