arch/x86/kernel/cpu/perf_event_amd.c

   1 #ifdef CONFIG_CPU_SUP_AMD
   2
   3 static DEFINE_RAW_SPINLOCK(amd_nb_lock);
   4
   5 static __initconst u64 amd_hw_cache_event_ids
   6                                 [PERF_COUNT_HW_CACHE_MAX]
   7                                 [PERF_COUNT_HW_CACHE_OP_MAX]
   8                                 [PERF_COUNT_HW_CACHE_RESULT_MAX] =
   9 {
  10  [ C(L1D) ] = {
  11         [ C(OP_READ) ] = {
  12                 [ C(RESULT_ACCESS) ] = 0x0040, /* Data Cache Accesses        */
  13                 [ C(RESULT_MISS)   ] = 0x0041, /* Data Cache Misses          */
  14         },
  15         [ C(OP_WRITE) ] = {
  16                 [ C(RESULT_ACCESS) ] = 0x0142, /* Data Cache Refills :system */
  17                 [ C(RESULT_MISS)   ] = 0,
  18         },
  19         [ C(OP_PREFETCH) ] = {
  20                 [ C(RESULT_ACCESS) ] = 0x0267, /* Data Prefetcher :attempts  */
  21                 [ C(RESULT_MISS)   ] = 0x0167, /* Data Prefetcher :cancelled */
  22         },
  23  },
  24  [ C(L1I ) ] = {
  25         [ C(OP_READ) ] = {
  26                 [ C(RESULT_ACCESS) ] = 0x0080, /* Instruction cache fetches  */
  27                 [ C(RESULT_MISS)   ] = 0x0081, /* Instruction cache misses   */
  28         },
  29         [ C(OP_WRITE) ] = {
  30                 [ C(RESULT_ACCESS) ] = -1,
  31                 [ C(RESULT_MISS)   ] = -1,
  32         },
  33         [ C(OP_PREFETCH) ] = {
  34                 [ C(RESULT_ACCESS) ] = 0x014B, /* Prefetch Instructions :Load */
  35                 [ C(RESULT_MISS)   ] = 0,
  36         },
  37  },
  38  [ C(LL  ) ] = {
  39         [ C(OP_READ) ] = {
  40                 [ C(RESULT_ACCESS) ] = 0x037D, /* Requests to L2 Cache :IC+DC */
  41                 [ C(RESULT_MISS)   ] = 0x037E, /* L2 Cache Misses : IC+DC     */
  42         },
  43         [ C(OP_WRITE) ] = {
  44                 [ C(RESULT_ACCESS) ] = 0x017F, /* L2 Fill/Writeback           */
  45                 [ C(RESULT_MISS)   ] = 0,
  46         },
  47         [ C(OP_PREFETCH) ] = {
  48                 [ C(RESULT_ACCESS) ] = 0,
  49                 [ C(RESULT_MISS)   ] = 0,
  50         },
  51  },
  52  [ C(DTLB) ] = {
  53         [ C(OP_READ) ] = {
  54                 [ C(RESULT_ACCESS) ] = 0x0040, /* Data Cache Accesses        */
  55                 [ C(RESULT_MISS)   ] = 0x0046, /* L1 DTLB and L2 DLTB Miss   */
  56         },
  57         [ C(OP_WRITE) ] = {
  58                 [ C(RESULT_ACCESS) ] = 0,
  59                 [ C(RESULT_MISS)   ] = 0,
  60         },
  61         [ C(OP_PREFETCH) ] = {
  62                 [ C(RESULT_ACCESS) ] = 0,
  63                 [ C(RESULT_MISS)   ] = 0,
  64         },
  65  },
  66  [ C(ITLB) ] = {
  67         [ C(OP_READ) ] = {
  68                 [ C(RESULT_ACCESS) ] = 0x0080, /* Instruction fecthes        */
  69                 [ C(RESULT_MISS)   ] = 0x0085, /* Instr. fetch ITLB misses   */
  70         },
  71         [ C(OP_WRITE) ] = {
  72                 [ C(RESULT_ACCESS) ] = -1,
  73                 [ C(RESULT_MISS)   ] = -1,
  74         },
  75         [ C(OP_PREFETCH) ] = {
  76                 [ C(RESULT_ACCESS) ] = -1,
  77                 [ C(RESULT_MISS)   ] = -1,
  78         },
  79  },
  80  [ C(BPU ) ] = {
  81         [ C(OP_READ) ] = {
  82                 [ C(RESULT_ACCESS) ] = 0x00c2, /* Retired Branch Instr.      */
  83                 [ C(RESULT_MISS)   ] = 0x00c3, /* Retired Mispredicted BI    */
  84         },
  85         [ C(OP_WRITE) ] = {
  86                 [ C(RESULT_ACCESS) ] = -1,
  87                 [ C(RESULT_MISS)   ] = -1,
  88         },
  89         [ C(OP_PREFETCH) ] = {
  90                 [ C(RESULT_ACCESS) ] = -1,
  91                 [ C(RESULT_MISS)   ] = -1,
  92         },
  93  },
  94 };
  95
  96 /*
  97  * AMD Performance Monitor K7 and later.
  98  */
  99 static const u64 amd_perfmon_event_map[] =
 100 {
 101   [PERF_COUNT_HW_CPU_CYCLES]            = 0x0076,
 102   [PERF_COUNT_HW_INSTRUCTIONS]          = 0x00c0,
 103   [PERF_COUNT_HW_CACHE_REFERENCES]      = 0x0080,
 104   [PERF_COUNT_HW_CACHE_MISSES]          = 0x0081,
 105   [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]   = 0x00c4,
 106   [PERF_COUNT_HW_BRANCH_MISSES]         = 0x00c5,
 107 };
 108
 109 static u64 amd_pmu_event_map(int hw_event)
 110 {
 111         return amd_perfmon_event_map[hw_event];
 112 }
 113
 114 static u64 amd_pmu_raw_event(u64 hw_event)
 115 {
 116 #define K7_EVNTSEL_EVENT_MASK   0xF000000FFULL
 117 #define K7_EVNTSEL_UNIT_MASK    0x00000FF00ULL
 118 #define K7_EVNTSEL_EDGE_MASK    0x000040000ULL
 119 #define K7_EVNTSEL_INV_MASK     0x000800000ULL
 120 #define K7_EVNTSEL_REG_MASK     0x0FF000000ULL
 121
 122 #define K7_EVNTSEL_MASK                 \
 123         (K7_EVNTSEL_EVENT_MASK |        \
 124          K7_EVNTSEL_UNIT_MASK  |        \
 125          K7_EVNTSEL_EDGE_MASK  |        \
 126          K7_EVNTSEL_INV_MASK   |        \
 127          K7_EVNTSEL_REG_MASK)
 128
 129         return hw_event & K7_EVNTSEL_MASK;
 130 }
 131
 132 /*
 133  * AMD64 events are detected based on their event codes.
 134  */
 135 static inline int amd_is_nb_event(struct hw_perf_event *hwc)
 136 {
 137         return (hwc->config & 0xe0) == 0xe0;
 138 }
 139
 140 static inline int amd_has_nb(struct cpu_hw_events *cpuc)
 141 {
 142         struct amd_nb *nb = cpuc->amd_nb;
 143
 144         return nb && nb->nb_id != -1;
 145 }
 146
 147 static void amd_put_event_constraints(struct cpu_hw_events *cpuc,
 148                                       struct perf_event *event)
 149 {
 150         struct hw_perf_event *hwc = &event->hw;
 151         struct amd_nb *nb = cpuc->amd_nb;
 152         int i;
 153
 154         /*
 155          * only care about NB events
 156          */
 157         if (!(amd_has_nb(cpuc) && amd_is_nb_event(hwc)))
 158                 return;
 159
 160         /*
 161          * need to scan whole list because event may not have
 162          * been assigned during scheduling
 163          *
 164          * no race condition possible because event can only
 165          * be removed on one CPU at a time AND PMU is disabled
 166          * when we come here
 167          */
 168         for (i = 0; i < x86_pmu.num_events; i++) {
 169                 if (nb->owners[i] == event) {
 170                         cmpxchg(nb->owners+i, event, NULL);
 171                         break;
 172                 }
 173         }
 174 }
 175
 176  /*
 177   * AMD64 NorthBridge events need special treatment because
 178   * counter access needs to be synchronized across all cores
 179   * of a package. Refer to BKDG section 3.12
 180   *
 181   * NB events are events measuring L3 cache, Hypertransport
 182   * traffic. They are identified by an event code >= 0xe00.
 183   * They measure events on the NorthBride which is shared
 184   * by all cores on a package. NB events are counted on a
 185   * shared set of counters. When a NB event is programmed
 186   * in a counter, the data actually comes from a shared
 187   * counter. Thus, access to those counters needs to be
 188   * synchronized.
 189   *
 190   * We implement the synchronization such that no two cores
 191   * can be measuring NB events using the same counters. Thus,
 192   * we maintain a per-NB allocation table. The available slot
 193   * is propagated using the event_constraint structure.
 194   *
 195   * We provide only one choice for each NB event based on
 196   * the fact that only NB events have restrictions. Consequently,
 197   * if a counter is available, there is a guarantee the NB event
 198   * will be assigned to it. If no slot is available, an empty
 199   * constraint is returned and scheduling will eventually fail
 200   * for this event.
 201   *
 202   * Note that all cores attached the same NB compete for the same
 203   * counters to host NB events, this is why we use atomic ops. Some
 204   * multi-chip CPUs may have more than one NB.
 205   *
 206   * Given that resources are allocated (cmpxchg), they must be
 207   * eventually freed for others to use. This is accomplished by
 208   * calling amd_put_event_constraints().
 209   *
 210   * Non NB events are not impacted by this restriction.
 211   */
 212 static struct event_constraint *
 213 amd_get_event_constraints(struct cpu_hw_events *cpuc, struct perf_event *event)
 214 {
 215         struct hw_perf_event *hwc = &event->hw;
 216         struct amd_nb *nb = cpuc->amd_nb;
 217         struct perf_event *old = NULL;
 218         int max = x86_pmu.num_events;
 219         int i, j, k = -1;
 220
 221         /*
 222          * if not NB event or no NB, then no constraints
 223          */
 224         if (!(amd_has_nb(cpuc) && amd_is_nb_event(hwc)))
 225                 return &unconstrained;
 226
 227         /*
 228          * detect if already present, if so reuse
 229          *
 230          * cannot merge with actual allocation
 231          * because of possible holes
 232          *
 233          * event can already be present yet not assigned (in hwc->idx)
 234          * because of successive calls to x86_schedule_events() from
 235          * hw_perf_group_sched_in() without hw_perf_enable()
 236          */
 237         for (i = 0; i < max; i++) {
 238                 /*
 239                  * keep track of first free slot
 240                  */
 241                 if (k == -1 && !nb->owners[i])
 242                         k = i;
 243
 244                 /* already present, reuse */
 245                 if (nb->owners[i] == event)
 246                         goto done;
 247         }
 248         /*
 249          * not present, so grab a new slot
 250          * starting either at:
 251          */
 252         if (hwc->idx != -1) {
 253                 /* previous assignment */
 254                 i = hwc->idx;
 255         } else if (k != -1) {
 256                 /* start from free slot found */
 257                 i = k;
 258         } else {
 259                 /*
 260                  * event not found, no slot found in
 261                  * first pass, try again from the
 262                  * beginning
 263                  */
 264                 i = 0;
 265         }
 266         j = i;
 267         do {
 268                 old = cmpxchg(nb->owners+i, NULL, event);
 269                 if (!old)
 270                         break;
 271                 if (++i == max)
 272                         i = 0;
 273         } while (i != j);
 274 done:
 275         if (!old)
 276                 return &nb->event_constraints[i];
 277
 278         return &emptyconstraint;
 279 }
 280
 281 static struct amd_nb *amd_alloc_nb(int cpu, int nb_id)
 282 {
 283         struct amd_nb *nb;
 284         int i;
 285
 286         nb = kmalloc(sizeof(struct amd_nb), GFP_KERNEL);
 287         if (!nb)
 288                 return NULL;
 289
 290         memset(nb, 0, sizeof(*nb));
 291         nb->nb_id = nb_id;
 292
 293         /*
 294          * initialize all possible NB constraints
 295          */
 296         for (i = 0; i < x86_pmu.num_events; i++) {
 297                 __set_bit(i, nb->event_constraints[i].idxmsk);
 298                 nb->event_constraints[i].weight = 1;
 299         }
 300         return nb;
 301 }
 302
 303 static int amd_pmu_cpu_prepare(int cpu)
 304 {
 305         struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
 306
 307         WARN_ON_ONCE(cpuc->amd_nb);
 308
 309         if (boot_cpu_data.x86_max_cores < 2)
 310                 return NOTIFY_OK;
 311
 312         cpuc->amd_nb = amd_alloc_nb(cpu, -1);
 313         if (!cpuc->amd_nb)
 314                 return NOTIFY_BAD;
 315
 316         return NOTIFY_OK;
 317 }
 318
 319 static void amd_pmu_cpu_starting(int cpu)
 320 {
 321         struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
 322         struct amd_nb *nb;
 323         int i, nb_id;
 324
 325         if (boot_cpu_data.x86_max_cores < 2)
 326                 return;
 327
 328         nb_id = amd_get_nb_id(cpu);
 329         WARN_ON_ONCE(nb_id == BAD_APICID);
 330
 331         raw_spin_lock(&amd_nb_lock);
 332
 333         for_each_online_cpu(i) {
 334                 nb = per_cpu(cpu_hw_events, i).amd_nb;
 335                 if (WARN_ON_ONCE(!nb))
 336                         continue;
 337
 338                 if (nb->nb_id == nb_id) {
 339                         kfree(cpuc->amd_nb);
 340                         cpuc->amd_nb = nb;
 341                         break;
 342                 }
 343         }
 344
 345         cpuc->amd_nb->nb_id = nb_id;
 346         cpuc->amd_nb->refcnt++;
 347
 348         raw_spin_unlock(&amd_nb_lock);
 349 }
 350
 351 static void amd_pmu_cpu_dead(int cpu)
 352 {
 353         struct cpu_hw_events *cpuhw;
 354
 355         if (boot_cpu_data.x86_max_cores < 2)
 356                 return;
 357
 358         cpuhw = &per_cpu(cpu_hw_events, cpu);
 359
 360         raw_spin_lock(&amd_nb_lock);
 361
 362         if (cpuhw->amd_nb) {
 363                 struct amd_nb *nb = cpuhw->amd_nb;
 364
 365                 if (nb->nb_id == -1 || --nb->refcnt == 0)
 366                         kfree(nb);
 367
 368                 cpuhw->amd_nb = NULL;
 369         }
 370
 371         raw_spin_unlock(&amd_nb_lock);
 372 }
 373
 374 static __initconst struct x86_pmu amd_pmu = {
 375         .name                   = "AMD",
 376         .handle_irq             = x86_pmu_handle_irq,
 377         .disable_all            = x86_pmu_disable_all,
 378         .enable_all             = x86_pmu_enable_all,
 379         .enable                 = x86_pmu_enable_event,
 380         .disable                = x86_pmu_disable_event,
 381         .eventsel               = MSR_K7_EVNTSEL0,
 382         .perfctr                = MSR_K7_PERFCTR0,
 383         .event_map              = amd_pmu_event_map,
 384         .raw_event              = amd_pmu_raw_event,
 385         .max_events             = ARRAY_SIZE(amd_perfmon_event_map),
 386         .num_events             = 4,
 387         .event_bits             = 48,
 388         .event_mask             = (1ULL << 48) - 1,
 389         .apic                   = 1,
 390         /* use highest bit to detect overflow */
 391         .max_period             = (1ULL << 47) - 1,
 392         .get_event_constraints  = amd_get_event_constraints,
 393         .put_event_constraints  = amd_put_event_constraints,
 394
 395         .cpu_prepare            = amd_pmu_cpu_prepare,
 396         .cpu_starting           = amd_pmu_cpu_starting,
 397         .cpu_dead               = amd_pmu_cpu_dead,
 398 };
 399
 400 static __init int amd_pmu_init(void)
 401 {
 402         /* Performance-monitoring supported from K7 and later: */
 403         if (boot_cpu_data.x86 < 6)
 404                 return -ENODEV;
 405
 406         x86_pmu = amd_pmu;
 407
 408         /* Events are common for all AMDs */
 409         memcpy(hw_cache_event_ids, amd_hw_cache_event_ids,
 410                sizeof(hw_cache_event_ids));
 411
 412         return 0;
 413 }
 414
 415 #else /* CONFIG_CPU_SUP_AMD */
 416
 417 static int amd_pmu_init(void)
 418 {
 419         return 0;
 420 }
 421
 422 #endif