perf_counter: powerpc: set sample enable bit for marked instruction events

Impact: enable access to hardware feature

POWER processors have the ability to "mark" a subset of the instructions
and provide more detailed information on what happens to the marked
instructions as they flow through the pipeline.  This marking is
enabled by the "sample enable" bit in MMCRA, and there are
synchronization requirements around setting and clearing the bit.

This adds logic to the processor-specific back-ends so that they know
which events relate to marked instructions and set the sampling enable
bit if any event that we want to put on the PMU is a marked instruction
event.  It also adds logic to the generic powerpc code to do the
necessary synchronization if that bit is set.

Signed-off-by: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <18908.31930.1024.228867@cargo.ozlabs.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 101 insertions, 2 deletions

diff --git a/arch/powerpc/kernel/power5+-pmu.c b/arch/powerpc/kernel/power5+-pmu.c
index cec21ea65b0e..1222c8ea3c26 100644
--- a/arch/powerpc/kernel/power5+-pmu.c
+++ b/arch/powerpc/kernel/power5+-pmu.c
@@ -1,5 +1,5 @@
 /*
- * Performance counter support for POWER5 (not POWER5++) processors.
+ * Performance counter support for POWER5+/++ (not POWER5) processors.
  *
  * Copyright 2009 Paul Mackerras, IBM Corporation.
  *
@@ -281,10 +281,107 @@ static int power5p_get_alternatives(unsigned int event, unsigned int alt[])
         return nalt;
 }
 
+/*
+ * Map of which direct events on which PMCs are marked instruction events.
+ * Indexed by PMCSEL value, bit i (LE) set if PMC i is a marked event.
+ * Bit 0 is set if it is marked for all PMCs.
+ * The 0x80 bit indicates a byte decode PMCSEL value.
+ */
+static unsigned char direct_event_is_marked[0x28] = {
+        0,      /* 00 */
+        0x1f,   /* 01 PM_IOPS_CMPL */
+        0x2,    /* 02 PM_MRK_GRP_DISP */
+        0xe,    /* 03 PM_MRK_ST_CMPL, PM_MRK_ST_GPS, PM_MRK_ST_CMPL_INT */
+        0,      /* 04 */
+        0x1c,   /* 05 PM_MRK_BRU_FIN, PM_MRK_INST_FIN, PM_MRK_CRU_FIN */
+        0x80,   /* 06 */
+        0x80,   /* 07 */
+        0, 0, 0,/* 08 - 0a */
+        0x18,   /* 0b PM_THRESH_TIMEO, PM_MRK_GRP_TIMEO */
+        0,      /* 0c */
+        0x80,   /* 0d */
+        0x80,   /* 0e */
+        0,      /* 0f */
+        0,      /* 10 */
+        0x14,   /* 11 PM_MRK_GRP_BR_REDIR, PM_MRK_GRP_IC_MISS */
+        0,      /* 12 */
+        0x10,   /* 13 PM_MRK_GRP_CMPL */
+        0x1f,   /* 14 PM_GRP_MRK, PM_MRK_{FXU,FPU,LSU}_FIN */
+        0x2,    /* 15 PM_MRK_GRP_ISSUED */
+        0x80,   /* 16 */
+        0x80,   /* 17 */
+        0, 0, 0, 0, 0,
+        0x80,   /* 1d */
+        0x80,   /* 1e */
+        0,      /* 1f */
+        0x80,   /* 20 */
+        0x80,   /* 21 */
+        0x80,   /* 22 */
+        0x80,   /* 23 */
+        0x80,   /* 24 */
+        0x80,   /* 25 */
+        0x80,   /* 26 */
+        0x80,   /* 27 */
+};
+
+/*
+ * Returns 1 if event counts things relating to marked instructions
+ * and thus needs the MMCRA_SAMPLE_ENABLE bit set, or 0 if not.
+ */
+static int power5p_marked_instr_event(unsigned int event)
+{
+        int pmc, psel;
+        int bit, byte, unit;
+        u32 mask;
+
+        pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;
+        psel = event & PM_PMCSEL_MSK;
+        if (pmc >= 5)
+                return 0;
+
+        bit = -1;
+        if (psel < sizeof(direct_event_is_marked)) {
+                if (direct_event_is_marked[psel] & (1 << pmc))
+                        return 1;
+                if (direct_event_is_marked[psel] & 0x80)
+                        bit = 4;
+                else if (psel == 0x08)
+                        bit = pmc - 1;
+                else if (psel == 0x10)
+                        bit = 4 - pmc;
+                else if (psel == 0x1b && (pmc == 1 || pmc == 3))
+                        bit = 4;
+        } else if ((psel & 0x48) == 0x40) {
+                bit = psel & 7;
+        } else if (psel == 0x28) {
+                bit = pmc - 1;
+        } else if (pmc == 3 && (psel == 0x2e || psel == 0x2f)) {
+                bit = 4;
+        }
+
+        if (!(event & PM_BUSEVENT_MSK) || bit == -1)
+                return 0;
+
+        byte = (event >> PM_BYTE_SH) & PM_BYTE_MSK;
+        unit = (event >> PM_UNIT_SH) & PM_UNIT_MSK;
+        if (unit == PM_LSU0) {
+                /* byte 1 bits 0-7, byte 2 bits 0,2-4,6 */
+                mask = 0x5dff00;
+        } else if (unit == PM_LSU1 && byte >= 4) {
+                byte -= 4;
+                /* byte 5 bits 6-7, byte 6 bits 0,4, byte 7 bits 0-4,6 */
+                mask = 0x5f11c000;
+        } else
+                return 0;
+
+        return (mask >> (byte * 8 + bit)) & 1;
+}
+
 static int power5p_compute_mmcr(unsigned int event[], int n_ev,
                                 unsigned int hwc[], u64 mmcr[])
 {
         u64 mmcr1 = 0;
+        u64 mmcra = 0;
         unsigned int pmc, unit, byte, psel;
         unsigned int ttm;
         int i, isbus, bit, grsel;
@@ -404,6 +501,8 @@ static int power5p_compute_mmcr(unsigned int event[], int n_ev,
                         grsel = (event[i] >> PM_GRS_SH) & PM_GRS_MSK;
                         mmcr1 |= (u64)grsel << grsel_shift[bit];
                 }
+                if (power5p_marked_instr_event(event[i]))
+                        mmcra |= MMCRA_SAMPLE_ENABLE;
                 if ((psel & 0x58) == 0x40 && (byte & 1) != ((pmc >> 1) & 1))
                         /* select alternate byte lane */
                         psel |= 0x10;
@@ -419,7 +518,7 @@ static int power5p_compute_mmcr(unsigned int event[], int n_ev,
         if (pmc_inuse & 0x3e)
                 mmcr[0] |= MMCR0_PMCjCE;
         mmcr[1] = mmcr1;
-        mmcr[2] = 0;
+        mmcr[2] = mmcra;
         return 0;
 }