arch/powerpc/perf/core-book3s.c

   1 /*
   2  * Performance event support - powerpc architecture code
   3  *
   4  * Copyright 2008-2009 Paul Mackerras, IBM Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11 #include <linux/kernel.h>
  12 #include <linux/sched.h>
  13 #include <linux/perf_event.h>
  14 #include <linux/percpu.h>
  15 #include <linux/hardirq.h>
  16 #include <linux/uaccess.h>
  17 #include <asm/reg.h>
  18 #include <asm/pmc.h>
  19 #include <asm/machdep.h>
  20 #include <asm/firmware.h>
  21 #include <asm/ptrace.h>
  22 #include <asm/code-patching.h>
  23
  24 #define BHRB_MAX_ENTRIES        32
  25 #define BHRB_TARGET             0x0000000000000002
  26 #define BHRB_PREDICTION         0x0000000000000001
  27 #define BHRB_EA                 0xFFFFFFFFFFFFFFFC
  28
  29 struct cpu_hw_events {
  30         int n_events;
  31         int n_percpu;
  32         int disabled;
  33         int n_added;
  34         int n_limited;
  35         u8  pmcs_enabled;
  36         struct perf_event *event[MAX_HWEVENTS];
  37         u64 events[MAX_HWEVENTS];
  38         unsigned int flags[MAX_HWEVENTS];
  39         unsigned long mmcr[3];
  40         struct perf_event *limited_counter[MAX_LIMITED_HWCOUNTERS];
  41         u8  limited_hwidx[MAX_LIMITED_HWCOUNTERS];
  42         u64 alternatives[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  43         unsigned long amasks[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  44         unsigned long avalues[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  45
  46         unsigned int group_flag;
  47         int n_txn_start;
  48
  49         /* BHRB bits */
  50         u64                             bhrb_filter;    /* BHRB HW branch filter */
  51         int                             bhrb_users;
  52         void                            *bhrb_context;
  53         struct  perf_branch_stack       bhrb_stack;
  54         struct  perf_branch_entry       bhrb_entries[BHRB_MAX_ENTRIES];
  55 };
  56
  57 DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
  58
  59 struct power_pmu *ppmu;
  60
  61 /*
  62  * Normally, to ignore kernel events we set the FCS (freeze counters
  63  * in supervisor mode) bit in MMCR0, but if the kernel runs with the
  64  * hypervisor bit set in the MSR, or if we are running on a processor
  65  * where the hypervisor bit is forced to 1 (as on Apple G5 processors),
  66  * then we need to use the FCHV bit to ignore kernel events.
  67  */
  68 static unsigned int freeze_events_kernel = MMCR0_FCS;
  69
  70 /*
  71  * 32-bit doesn't have MMCRA but does have an MMCR2,
  72  * and a few other names are different.
  73  */
  74 #ifdef CONFIG_PPC32
  75
  76 #define MMCR0_FCHV              0
  77 #define MMCR0_PMCjCE            MMCR0_PMCnCE
  78
  79 #define SPRN_MMCRA              SPRN_MMCR2
  80 #define MMCRA_SAMPLE_ENABLE     0
  81
  82 static inline unsigned long perf_ip_adjust(struct pt_regs *regs)
  83 {
  84         return 0;
  85 }
  86 static inline void perf_get_data_addr(struct pt_regs *regs, u64 *addrp) { }
  87 static inline u32 perf_get_misc_flags(struct pt_regs *regs)
  88 {
  89         return 0;
  90 }
  91 static inline void perf_read_regs(struct pt_regs *regs)
  92 {
  93         regs->result = 0;
  94 }
  95 static inline int perf_intr_is_nmi(struct pt_regs *regs)
  96 {
  97         return 0;
  98 }
  99
 100 static inline int siar_valid(struct pt_regs *regs)
 101 {
 102         return 1;
 103 }
 104
 105 static inline void power_pmu_bhrb_enable(struct perf_event *event) {}
 106 static inline void power_pmu_bhrb_disable(struct perf_event *event) {}
 107 void power_pmu_flush_branch_stack(void) {}
 108 static inline void power_pmu_bhrb_read(struct cpu_hw_events *cpuhw) {}
 109 #endif /* CONFIG_PPC32 */
 110
 111 static bool regs_use_siar(struct pt_regs *regs)
 112 {
 113         return !!(regs->result & 1);
 114 }
 115
 116 /*
 117  * Things that are specific to 64-bit implementations.
 118  */
 119 #ifdef CONFIG_PPC64
 120
 121 static inline unsigned long perf_ip_adjust(struct pt_regs *regs)
 122 {
 123         unsigned long mmcra = regs->dsisr;
 124
 125         if ((ppmu->flags & PPMU_HAS_SSLOT) && (mmcra & MMCRA_SAMPLE_ENABLE)) {
 126                 unsigned long slot = (mmcra & MMCRA_SLOT) >> MMCRA_SLOT_SHIFT;
 127                 if (slot > 1)
 128                         return 4 * (slot - 1);
 129         }
 130
 131         return 0;
 132 }
 133
 134 /*
 135  * The user wants a data address recorded.
 136  * If we're not doing instruction sampling, give them the SDAR
 137  * (sampled data address).  If we are doing instruction sampling, then
 138  * only give them the SDAR if it corresponds to the instruction
 139  * pointed to by SIAR; this is indicated by the [POWER6_]MMCRA_SDSYNC or
 140  * the [POWER7P_]MMCRA_SDAR_VALID bit in MMCRA.
 141  */
 142 static inline void perf_get_data_addr(struct pt_regs *regs, u64 *addrp)
 143 {
 144         unsigned long mmcra = regs->dsisr;
 145         unsigned long sdsync;
 146
 147         if (ppmu->flags & PPMU_SIAR_VALID)
 148                 sdsync = POWER7P_MMCRA_SDAR_VALID;
 149         else if (ppmu->flags & PPMU_ALT_SIPR)
 150                 sdsync = POWER6_MMCRA_SDSYNC;
 151         else
 152                 sdsync = MMCRA_SDSYNC;
 153
 154         if (!(mmcra & MMCRA_SAMPLE_ENABLE) || (mmcra & sdsync))
 155                 *addrp = mfspr(SPRN_SDAR);
 156 }
 157
 158 static bool regs_sihv(struct pt_regs *regs)
 159 {
 160         unsigned long sihv = MMCRA_SIHV;
 161
 162         if (ppmu->flags & PPMU_HAS_SIER)
 163                 return !!(regs->dar & SIER_SIHV);
 164
 165         if (ppmu->flags & PPMU_ALT_SIPR)
 166                 sihv = POWER6_MMCRA_SIHV;
 167
 168         return !!(regs->dsisr & sihv);
 169 }
 170
 171 static bool regs_sipr(struct pt_regs *regs)
 172 {
 173         unsigned long sipr = MMCRA_SIPR;
 174
 175         if (ppmu->flags & PPMU_HAS_SIER)
 176                 return !!(regs->dar & SIER_SIPR);
 177
 178         if (ppmu->flags & PPMU_ALT_SIPR)
 179                 sipr = POWER6_MMCRA_SIPR;
 180
 181         return !!(regs->dsisr & sipr);
 182 }
 183
 184 static bool regs_no_sipr(struct pt_regs *regs)
 185 {
 186         return !!(regs->result & 2);
 187 }
 188
 189 static inline u32 perf_flags_from_msr(struct pt_regs *regs)
 190 {
 191         if (regs->msr & MSR_PR)
 192                 return PERF_RECORD_MISC_USER;
 193         if ((regs->msr & MSR_HV) && freeze_events_kernel != MMCR0_FCHV)
 194                 return PERF_RECORD_MISC_HYPERVISOR;
 195         return PERF_RECORD_MISC_KERNEL;
 196 }
 197
 198 static inline u32 perf_get_misc_flags(struct pt_regs *regs)
 199 {
 200         bool use_siar = regs_use_siar(regs);
 201
 202         if (!use_siar)
 203                 return perf_flags_from_msr(regs);
 204
 205         /*
 206          * If we don't have flags in MMCRA, rather than using
 207          * the MSR, we intuit the flags from the address in
 208          * SIAR which should give slightly more reliable
 209          * results
 210          */
 211         if (regs_no_sipr(regs)) {
 212                 unsigned long siar = mfspr(SPRN_SIAR);
 213                 if (siar >= PAGE_OFFSET)
 214                         return PERF_RECORD_MISC_KERNEL;
 215                 return PERF_RECORD_MISC_USER;
 216         }
 217
 218         /* PR has priority over HV, so order below is important */
 219         if (regs_sipr(regs))
 220                 return PERF_RECORD_MISC_USER;
 221
 222         if (regs_sihv(regs) && (freeze_events_kernel != MMCR0_FCHV))
 223                 return PERF_RECORD_MISC_HYPERVISOR;
 224
 225         return PERF_RECORD_MISC_KERNEL;
 226 }
 227
 228 /*
 229  * Overload regs->dsisr to store MMCRA so we only need to read it once
 230  * on each interrupt.
 231  * Overload regs->dar to store SIER if we have it.
 232  * Overload regs->result to specify whether we should use the MSR (result
 233  * is zero) or the SIAR (result is non zero).
 234  */
 235 static inline void perf_read_regs(struct pt_regs *regs)
 236 {
 237         unsigned long mmcra = mfspr(SPRN_MMCRA);
 238         int marked = mmcra & MMCRA_SAMPLE_ENABLE;
 239         int use_siar;
 240
 241         regs->dsisr = mmcra;
 242         regs->result = 0;
 243
 244         if (ppmu->flags & PPMU_NO_SIPR)
 245                 regs->result |= 2;
 246
 247         /*
 248          * On power8 if we're in random sampling mode, the SIER is updated.
 249          * If we're in continuous sampling mode, we don't have SIPR.
 250          */
 251         if (ppmu->flags & PPMU_HAS_SIER) {
 252                 if (marked)
 253                         regs->dar = mfspr(SPRN_SIER);
 254                 else
 255                         regs->result |= 2;
 256         }
 257
 258
 259         /*
 260          * If this isn't a PMU exception (eg a software event) the SIAR is
 261          * not valid. Use pt_regs.
 262          *
 263          * If it is a marked event use the SIAR.
 264          *
 265          * If the PMU doesn't update the SIAR for non marked events use
 266          * pt_regs.
 267          *
 268          * If the PMU has HV/PR flags then check to see if they
 269          * place the exception in userspace. If so, use pt_regs. In
 270          * continuous sampling mode the SIAR and the PMU exception are
 271          * not synchronised, so they may be many instructions apart.
 272          * This can result in confusing backtraces. We still want
 273          * hypervisor samples as well as samples in the kernel with
 274          * interrupts off hence the userspace check.
 275          */
 276         if (TRAP(regs) != 0xf00)
 277                 use_siar = 0;
 278         else if (marked)
 279                 use_siar = 1;
 280         else if ((ppmu->flags & PPMU_NO_CONT_SAMPLING))
 281                 use_siar = 0;
 282         else if (!regs_no_sipr(regs) && regs_sipr(regs))
 283                 use_siar = 0;
 284         else
 285                 use_siar = 1;
 286
 287         regs->result |= use_siar;
 288 }
 289
 290 /*
 291  * If interrupts were soft-disabled when a PMU interrupt occurs, treat
 292  * it as an NMI.
 293  */
 294 static inline int perf_intr_is_nmi(struct pt_regs *regs)
 295 {
 296         return !regs->softe;
 297 }
 298
 299 /*
 300  * On processors like P7+ that have the SIAR-Valid bit, marked instructions
 301  * must be sampled only if the SIAR-valid bit is set.
 302  *
 303  * For unmarked instructions and for processors that don't have the SIAR-Valid
 304  * bit, assume that SIAR is valid.
 305  */
 306 static inline int siar_valid(struct pt_regs *regs)
 307 {
 308         unsigned long mmcra = regs->dsisr;
 309         int marked = mmcra & MMCRA_SAMPLE_ENABLE;
 310
 311         if ((ppmu->flags & PPMU_SIAR_VALID) && marked)
 312                 return mmcra & POWER7P_MMCRA_SIAR_VALID;
 313
 314         return 1;
 315 }
 316
 317
 318 /* Reset all possible BHRB entries */
 319 static void power_pmu_bhrb_reset(void)
 320 {
 321         asm volatile(PPC_CLRBHRB);
 322 }
 323
 324 static void power_pmu_bhrb_enable(struct perf_event *event)
 325 {
 326         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 327
 328         if (!ppmu->bhrb_nr)
 329                 return;
 330
 331         /* Clear BHRB if we changed task context to avoid data leaks */
 332         if (event->ctx->task && cpuhw->bhrb_context != event->ctx) {
 333                 power_pmu_bhrb_reset();
 334                 cpuhw->bhrb_context = event->ctx;
 335         }
 336         cpuhw->bhrb_users++;
 337 }
 338
 339 static void power_pmu_bhrb_disable(struct perf_event *event)
 340 {
 341         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 342
 343         if (!ppmu->bhrb_nr)
 344                 return;
 345
 346         cpuhw->bhrb_users--;
 347         WARN_ON_ONCE(cpuhw->bhrb_users < 0);
 348
 349         if (!cpuhw->disabled && !cpuhw->bhrb_users) {
 350                 /* BHRB cannot be turned off when other
 351                  * events are active on the PMU.
 352                  */
 353
 354                 /* avoid stale pointer */
 355                 cpuhw->bhrb_context = NULL;
 356         }
 357 }
 358
 359 /* Called from ctxsw to prevent one process's branch entries to
 360  * mingle with the other process's entries during context switch.
 361  */
 362 void power_pmu_flush_branch_stack(void)
 363 {
 364         if (ppmu->bhrb_nr)
 365                 power_pmu_bhrb_reset();
 366 }
 367 /* Calculate the to address for a branch */
 368 static __u64 power_pmu_bhrb_to(u64 addr)
 369 {
 370         unsigned int instr;
 371         int ret;
 372         __u64 target;
 373
 374         if (is_kernel_addr(addr))
 375                 return branch_target((unsigned int *)addr);
 376
 377         /* Userspace: need copy instruction here then translate it */
 378         pagefault_disable();
 379         ret = __get_user_inatomic(instr, (unsigned int __user *)addr);
 380         if (ret) {
 381                 pagefault_enable();
 382                 return 0;
 383         }
 384         pagefault_enable();
 385
 386         target = branch_target(&instr);
 387         if ((!target) || (instr & BRANCH_ABSOLUTE))
 388                 return target;
 389
 390         /* Translate relative branch target from kernel to user address */
 391         return target - (unsigned long)&instr + addr;
 392 }
 393
 394 /* Processing BHRB entries */
 395 void power_pmu_bhrb_read(struct cpu_hw_events *cpuhw)
 396 {
 397         u64 val;
 398         u64 addr;
 399         int r_index, u_index, pred;
 400
 401         r_index = 0;
 402         u_index = 0;
 403         while (r_index < ppmu->bhrb_nr) {
 404                 /* Assembly read function */
 405                 val = read_bhrb(r_index++);
 406                 if (!val)
 407                         /* Terminal marker: End of valid BHRB entries */
 408                         break;
 409                 else {
 410                         addr = val & BHRB_EA;
 411                         pred = val & BHRB_PREDICTION;
 412
 413                         if (!addr)
 414                                 /* invalid entry */
 415                                 continue;
 416
 417                         /* Branches are read most recent first (ie. mfbhrb 0 is
 418                          * the most recent branch).
 419                          * There are two types of valid entries:
 420                          * 1) a target entry which is the to address of a
 421                          *    computed goto like a blr,bctr,btar.  The next
 422                          *    entry read from the bhrb will be branch
 423                          *    corresponding to this target (ie. the actual
 424                          *    blr/bctr/btar instruction).
 425                          * 2) a from address which is an actual branch.  If a
 426                          *    target entry proceeds this, then this is the
 427                          *    matching branch for that target.  If this is not
 428                          *    following a target entry, then this is a branch
 429                          *    where the target is given as an immediate field
 430                          *    in the instruction (ie. an i or b form branch).
 431                          *    In this case we need to read the instruction from
 432                          *    memory to determine the target/to address.
 433                          */
 434
 435                         if (val & BHRB_TARGET) {
 436                                 /* Target branches use two entries
 437                                  * (ie. computed gotos/XL form)
 438                                  */
 439                                 cpuhw->bhrb_entries[u_index].to = addr;
 440                                 cpuhw->bhrb_entries[u_index].mispred = pred;
 441                                 cpuhw->bhrb_entries[u_index].predicted = ~pred;
 442
 443                                 /* Get from address in next entry */
 444                                 val = read_bhrb(r_index++);
 445                                 addr = val & BHRB_EA;
 446                                 if (val & BHRB_TARGET) {
 447                                         /* Shouldn't have two targets in a
 448                                            row.. Reset index and try again */
 449                                         r_index--;
 450                                         addr = 0;
 451                                 }
 452                                 cpuhw->bhrb_entries[u_index].from = addr;
 453                         } else {
 454                                 /* Branches to immediate field
 455                                    (ie I or B form) */
 456                                 cpuhw->bhrb_entries[u_index].from = addr;
 457                                 cpuhw->bhrb_entries[u_index].to =
 458                                         power_pmu_bhrb_to(addr);
 459                                 cpuhw->bhrb_entries[u_index].mispred = pred;
 460                                 cpuhw->bhrb_entries[u_index].predicted = ~pred;
 461                         }
 462                         u_index++;
 463
 464                 }
 465         }
 466         cpuhw->bhrb_stack.nr = u_index;
 467         return;
 468 }
 469
 470 #endif /* CONFIG_PPC64 */
 471
 472 static void perf_event_interrupt(struct pt_regs *regs);
 473
 474 void perf_event_print_debug(void)
 475 {
 476 }
 477
 478 /*
 479  * Read one performance monitor counter (PMC).
 480  */
 481 static unsigned long read_pmc(int idx)
 482 {
 483         unsigned long val;
 484
 485         switch (idx) {
 486         case 1:
 487                 val = mfspr(SPRN_PMC1);
 488                 break;
 489         case 2:
 490                 val = mfspr(SPRN_PMC2);
 491                 break;
 492         case 3:
 493                 val = mfspr(SPRN_PMC3);
 494                 break;
 495         case 4:
 496                 val = mfspr(SPRN_PMC4);
 497                 break;
 498         case 5:
 499                 val = mfspr(SPRN_PMC5);
 500                 break;
 501         case 6:
 502                 val = mfspr(SPRN_PMC6);
 503                 break;
 504 #ifdef CONFIG_PPC64
 505         case 7:
 506                 val = mfspr(SPRN_PMC7);
 507                 break;
 508         case 8:
 509                 val = mfspr(SPRN_PMC8);
 510                 break;
 511 #endif /* CONFIG_PPC64 */
 512         default:
 513                 printk(KERN_ERR "oops trying to read PMC%d\n", idx);
 514                 val = 0;
 515         }
 516         return val;
 517 }
 518
 519 /*
 520  * Write one PMC.
 521  */
 522 static void write_pmc(int idx, unsigned long val)
 523 {
 524         switch (idx) {
 525         case 1:
 526                 mtspr(SPRN_PMC1, val);
 527                 break;
 528         case 2:
 529                 mtspr(SPRN_PMC2, val);
 530                 break;
 531         case 3:
 532                 mtspr(SPRN_PMC3, val);
 533                 break;
 534         case 4:
 535                 mtspr(SPRN_PMC4, val);
 536                 break;
 537         case 5:
 538                 mtspr(SPRN_PMC5, val);
 539                 break;
 540         case 6:
 541                 mtspr(SPRN_PMC6, val);
 542                 break;
 543 #ifdef CONFIG_PPC64
 544         case 7:
 545                 mtspr(SPRN_PMC7, val);
 546                 break;
 547         case 8:
 548                 mtspr(SPRN_PMC8, val);
 549                 break;
 550 #endif /* CONFIG_PPC64 */
 551         default:
 552                 printk(KERN_ERR "oops trying to write PMC%d\n", idx);
 553         }
 554 }
 555
 556 /*
 557  * Check if a set of events can all go on the PMU at once.
 558  * If they can't, this will look at alternative codes for the events
 559  * and see if any combination of alternative codes is feasible.
 560  * The feasible set is returned in event_id[].
 561  */
 562 static int power_check_constraints(struct cpu_hw_events *cpuhw,
 563                                    u64 event_id[], unsigned int cflags[],
 564                                    int n_ev)
 565 {
 566         unsigned long mask, value, nv;
 567         unsigned long smasks[MAX_HWEVENTS], svalues[MAX_HWEVENTS];
 568         int n_alt[MAX_HWEVENTS], choice[MAX_HWEVENTS];
 569         int i, j;
 570         unsigned long addf = ppmu->add_fields;
 571         unsigned long tadd = ppmu->test_adder;
 572
 573         if (n_ev > ppmu->n_counter)
 574                 return -1;
 575
 576         /* First see if the events will go on as-is */
 577         for (i = 0; i < n_ev; ++i) {
 578                 if ((cflags[i] & PPMU_LIMITED_PMC_REQD)
 579                     && !ppmu->limited_pmc_event(event_id[i])) {
 580                         ppmu->get_alternatives(event_id[i], cflags[i],
 581                                                cpuhw->alternatives[i]);
 582                         event_id[i] = cpuhw->alternatives[i][0];
 583                 }
 584                 if (ppmu->get_constraint(event_id[i], &cpuhw->amasks[i][0],
 585                                          &cpuhw->avalues[i][0]))
 586                         return -1;
 587         }
 588         value = mask = 0;
 589         for (i = 0; i < n_ev; ++i) {
 590                 nv = (value | cpuhw->avalues[i][0]) +
 591                         (value & cpuhw->avalues[i][0] & addf);
 592                 if ((((nv + tadd) ^ value) & mask) != 0 ||
 593                     (((nv + tadd) ^ cpuhw->avalues[i][0]) &
 594                      cpuhw->amasks[i][0]) != 0)
 595                         break;
 596                 value = nv;
 597                 mask |= cpuhw->amasks[i][0];
 598         }
 599         if (i == n_ev)
 600                 return 0;       /* all OK */
 601
 602         /* doesn't work, gather alternatives... */
 603         if (!ppmu->get_alternatives)
 604                 return -1;
 605         for (i = 0; i < n_ev; ++i) {
 606                 choice[i] = 0;
 607                 n_alt[i] = ppmu->get_alternatives(event_id[i], cflags[i],
 608                                                   cpuhw->alternatives[i]);
 609                 for (j = 1; j < n_alt[i]; ++j)
 610                         ppmu->get_constraint(cpuhw->alternatives[i][j],
 611                                              &cpuhw->amasks[i][j],
 612                                              &cpuhw->avalues[i][j]);
 613         }
 614
 615         /* enumerate all possibilities and see if any will work */
 616         i = 0;
 617         j = -1;
 618         value = mask = nv = 0;
 619         while (i < n_ev) {
 620                 if (j >= 0) {
 621                         /* we're backtracking, restore context */
 622                         value = svalues[i];
 623                         mask = smasks[i];
 624                         j = choice[i];
 625                 }
 626                 /*
 627                  * See if any alternative k for event_id i,
 628                  * where k > j, will satisfy the constraints.
 629                  */
 630                 while (++j < n_alt[i]) {
 631                         nv = (value | cpuhw->avalues[i][j]) +
 632                                 (value & cpuhw->avalues[i][j] & addf);
 633                         if ((((nv + tadd) ^ value) & mask) == 0 &&
 634                             (((nv + tadd) ^ cpuhw->avalues[i][j])
 635                              & cpuhw->amasks[i][j]) == 0)
 636                                 break;
 637                 }
 638                 if (j >= n_alt[i]) {
 639                         /*
 640                          * No feasible alternative, backtrack
 641                          * to event_id i-1 and continue enumerating its
 642                          * alternatives from where we got up to.
 643                          */
 644                         if (--i < 0)
 645                                 return -1;
 646                 } else {
 647                         /*
 648                          * Found a feasible alternative for event_id i,
 649                          * remember where we got up to with this event_id,
 650                          * go on to the next event_id, and start with
 651                          * the first alternative for it.
 652                          */
 653                         choice[i] = j;
 654                         svalues[i] = value;
 655                         smasks[i] = mask;
 656                         value = nv;
 657                         mask |= cpuhw->amasks[i][j];
 658                         ++i;
 659                         j = -1;
 660                 }
 661         }
 662
 663         /* OK, we have a feasible combination, tell the caller the solution */
 664         for (i = 0; i < n_ev; ++i)
 665                 event_id[i] = cpuhw->alternatives[i][choice[i]];
 666         return 0;
 667 }
 668
 669 /*
 670  * Check if newly-added events have consistent settings for
 671  * exclude_{user,kernel,hv} with each other and any previously
 672  * added events.
 673  */
 674 static int check_excludes(struct perf_event **ctrs, unsigned int cflags[],
 675                           int n_prev, int n_new)
 676 {
 677         int eu = 0, ek = 0, eh = 0;
 678         int i, n, first;
 679         struct perf_event *event;
 680
 681         n = n_prev + n_new;
 682         if (n <= 1)
 683                 return 0;
 684
 685         first = 1;
 686         for (i = 0; i < n; ++i) {
 687                 if (cflags[i] & PPMU_LIMITED_PMC_OK) {
 688                         cflags[i] &= ~PPMU_LIMITED_PMC_REQD;
 689                         continue;
 690                 }
 691                 event = ctrs[i];
 692                 if (first) {
 693                         eu = event->attr.exclude_user;
 694                         ek = event->attr.exclude_kernel;
 695                         eh = event->attr.exclude_hv;
 696                         first = 0;
 697                 } else if (event->attr.exclude_user != eu ||
 698                            event->attr.exclude_kernel != ek ||
 699                            event->attr.exclude_hv != eh) {
 700                         return -EAGAIN;
 701                 }
 702         }
 703
 704         if (eu || ek || eh)
 705                 for (i = 0; i < n; ++i)
 706                         if (cflags[i] & PPMU_LIMITED_PMC_OK)
 707                                 cflags[i] |= PPMU_LIMITED_PMC_REQD;
 708
 709         return 0;
 710 }
 711
 712 static u64 check_and_compute_delta(u64 prev, u64 val)
 713 {
 714         u64 delta = (val - prev) & 0xfffffffful;
 715
 716         /*
 717          * POWER7 can roll back counter values, if the new value is smaller
 718          * than the previous value it will cause the delta and the counter to
 719          * have bogus values unless we rolled a counter over.  If a coutner is
 720          * rolled back, it will be smaller, but within 256, which is the maximum
 721          * number of events to rollback at once.  If we dectect a rollback
 722          * return 0.  This can lead to a small lack of precision in the
 723          * counters.
 724          */
 725         if (prev > val && (prev - val) < 256)
 726                 delta = 0;
 727
 728         return delta;
 729 }
 730
 731 static void power_pmu_read(struct perf_event *event)
 732 {
 733         s64 val, delta, prev;
 734
 735         if (event->hw.state & PERF_HES_STOPPED)
 736                 return;
 737
 738         if (!event->hw.idx)
 739                 return;
 740         /*
 741          * Performance monitor interrupts come even when interrupts
 742          * are soft-disabled, as long as interrupts are hard-enabled.
 743          * Therefore we treat them like NMIs.
 744          */
 745         do {
 746                 prev = local64_read(&event->hw.prev_count);
 747                 barrier();
 748                 val = read_pmc(event->hw.idx);
 749                 delta = check_and_compute_delta(prev, val);
 750                 if (!delta)
 751                         return;
 752         } while (local64_cmpxchg(&event->hw.prev_count, prev, val) != prev);
 753
 754         local64_add(delta, &event->count);
 755         local64_sub(delta, &event->hw.period_left);
 756 }
 757
 758 /*
 759  * On some machines, PMC5 and PMC6 can't be written, don't respect
 760  * the freeze conditions, and don't generate interrupts.  This tells
 761  * us if `event' is using such a PMC.
 762  */
 763 static int is_limited_pmc(int pmcnum)
 764 {
 765         return (ppmu->flags & PPMU_LIMITED_PMC5_6)
 766                 && (pmcnum == 5 || pmcnum == 6);
 767 }
 768
 769 static void freeze_limited_counters(struct cpu_hw_events *cpuhw,
 770                                     unsigned long pmc5, unsigned long pmc6)
 771 {
 772         struct perf_event *event;
 773         u64 val, prev, delta;
 774         int i;
 775
 776         for (i = 0; i < cpuhw->n_limited; ++i) {
 777                 event = cpuhw->limited_counter[i];
 778                 if (!event->hw.idx)
 779                         continue;
 780                 val = (event->hw.idx == 5) ? pmc5 : pmc6;
 781                 prev = local64_read(&event->hw.prev_count);
 782                 event->hw.idx = 0;
 783                 delta = check_and_compute_delta(prev, val);
 784                 if (delta)
 785                         local64_add(delta, &event->count);
 786         }
 787 }
 788
 789 static void thaw_limited_counters(struct cpu_hw_events *cpuhw,
 790                                   unsigned long pmc5, unsigned long pmc6)
 791 {
 792         struct perf_event *event;
 793         u64 val, prev;
 794         int i;
 795
 796         for (i = 0; i < cpuhw->n_limited; ++i) {
 797                 event = cpuhw->limited_counter[i];
 798                 event->hw.idx = cpuhw->limited_hwidx[i];
 799                 val = (event->hw.idx == 5) ? pmc5 : pmc6;
 800                 prev = local64_read(&event->hw.prev_count);
 801                 if (check_and_compute_delta(prev, val))
 802                         local64_set(&event->hw.prev_count, val);
 803                 perf_event_update_userpage(event);
 804         }
 805 }
 806
 807 /*
 808  * Since limited events don't respect the freeze conditions, we
 809  * have to read them immediately after freezing or unfreezing the
 810  * other events.  We try to keep the values from the limited
 811  * events as consistent as possible by keeping the delay (in
 812  * cycles and instructions) between freezing/unfreezing and reading
 813  * the limited events as small and consistent as possible.
 814  * Therefore, if any limited events are in use, we read them
 815  * both, and always in the same order, to minimize variability,
 816  * and do it inside the same asm that writes MMCR0.
 817  */
 818 static void write_mmcr0(struct cpu_hw_events *cpuhw, unsigned long mmcr0)
 819 {
 820         unsigned long pmc5, pmc6;
 821
 822         if (!cpuhw->n_limited) {
 823                 mtspr(SPRN_MMCR0, mmcr0);
 824                 return;
 825         }
 826
 827         /*
 828          * Write MMCR0, then read PMC5 and PMC6 immediately.
 829          * To ensure we don't get a performance monitor interrupt
 830          * between writing MMCR0 and freezing/thawing the limited
 831          * events, we first write MMCR0 with the event overflow
 832          * interrupt enable bits turned off.
 833          */
 834         asm volatile("mtspr %3,%2; mfspr %0,%4; mfspr %1,%5"
 835                      : "=&r" (pmc5), "=&r" (pmc6)
 836                      : "r" (mmcr0 & ~(MMCR0_PMC1CE | MMCR0_PMCjCE)),
 837                        "i" (SPRN_MMCR0),
 838                        "i" (SPRN_PMC5), "i" (SPRN_PMC6));
 839
 840         if (mmcr0 & MMCR0_FC)
 841                 freeze_limited_counters(cpuhw, pmc5, pmc6);
 842         else
 843                 thaw_limited_counters(cpuhw, pmc5, pmc6);
 844
 845         /*
 846          * Write the full MMCR0 including the event overflow interrupt
 847          * enable bits, if necessary.
 848          */
 849         if (mmcr0 & (MMCR0_PMC1CE | MMCR0_PMCjCE))
 850                 mtspr(SPRN_MMCR0, mmcr0);
 851 }
 852
 853 /*
 854  * Disable all events to prevent PMU interrupts and to allow
 855  * events to be added or removed.
 856  */
 857 static void power_pmu_disable(struct pmu *pmu)
 858 {
 859         struct cpu_hw_events *cpuhw;
 860         unsigned long flags;
 861
 862         if (!ppmu)
 863                 return;
 864         local_irq_save(flags);
 865         cpuhw = &__get_cpu_var(cpu_hw_events);
 866
 867         if (!cpuhw->disabled) {
 868                 cpuhw->disabled = 1;
 869                 cpuhw->n_added = 0;
 870
 871                 /*
 872                  * Check if we ever enabled the PMU on this cpu.
 873                  */
 874                 if (!cpuhw->pmcs_enabled) {
 875                         ppc_enable_pmcs();
 876                         cpuhw->pmcs_enabled = 1;
 877                 }
 878
 879                 /*
 880                  * Disable instruction sampling if it was enabled
 881                  */
 882                 if (cpuhw->mmcr[2] & MMCRA_SAMPLE_ENABLE) {
 883                         mtspr(SPRN_MMCRA,
 884                               cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 885                         mb();
 886                 }
 887
 888                 /*
 889                  * Set the 'freeze counters' bit.
 890                  * The barrier is to make sure the mtspr has been
 891                  * executed and the PMU has frozen the events
 892                  * before we return.
 893                  */
 894                 write_mmcr0(cpuhw, mfspr(SPRN_MMCR0) | MMCR0_FC);
 895                 mb();
 896         }
 897         local_irq_restore(flags);
 898 }
 899
 900 /*
 901  * Re-enable all events if disable == 0.
 902  * If we were previously disabled and events were added, then
 903  * put the new config on the PMU.
 904  */
 905 static void power_pmu_enable(struct pmu *pmu)
 906 {
 907         struct perf_event *event;
 908         struct cpu_hw_events *cpuhw;
 909         unsigned long flags;
 910         long i;
 911         unsigned long val;
 912         s64 left;
 913         unsigned int hwc_index[MAX_HWEVENTS];
 914         int n_lim;
 915         int idx;
 916
 917         if (!ppmu)
 918                 return;
 919         local_irq_save(flags);
 920         cpuhw = &__get_cpu_var(cpu_hw_events);
 921         if (!cpuhw->disabled) {
 922                 local_irq_restore(flags);
 923                 return;
 924         }
 925         cpuhw->disabled = 0;
 926
 927         /*
 928          * If we didn't change anything, or only removed events,
 929          * no need to recalculate MMCR* settings and reset the PMCs.
 930          * Just reenable the PMU with the current MMCR* settings
 931          * (possibly updated for removal of events).
 932          */
 933         if (!cpuhw->n_added) {
 934                 mtspr(SPRN_MMCRA, cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 935                 mtspr(SPRN_MMCR1, cpuhw->mmcr[1]);
 936                 if (cpuhw->n_events == 0)
 937                         ppc_set_pmu_inuse(0);
 938                 goto out_enable;
 939         }
 940
 941         /*
 942          * Compute MMCR* values for the new set of events
 943          */
 944         if (ppmu->compute_mmcr(cpuhw->events, cpuhw->n_events, hwc_index,
 945                                cpuhw->mmcr)) {
 946                 /* shouldn't ever get here */
 947                 printk(KERN_ERR "oops compute_mmcr failed\n");
 948                 goto out;
 949         }
 950
 951         /*
 952          * Add in MMCR0 freeze bits corresponding to the
 953          * attr.exclude_* bits for the first event.
 954          * We have already checked that all events have the
 955          * same values for these bits as the first event.
 956          */
 957         event = cpuhw->event[0];
 958         if (event->attr.exclude_user)
 959                 cpuhw->mmcr[0] |= MMCR0_FCP;
 960         if (event->attr.exclude_kernel)
 961                 cpuhw->mmcr[0] |= freeze_events_kernel;
 962         if (event->attr.exclude_hv)
 963                 cpuhw->mmcr[0] |= MMCR0_FCHV;
 964
 965         /*
 966          * Write the new configuration to MMCR* with the freeze
 967          * bit set and set the hardware events to their initial values.
 968          * Then unfreeze the events.
 969          */
 970         ppc_set_pmu_inuse(1);
 971         mtspr(SPRN_MMCRA, cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 972         mtspr(SPRN_MMCR1, cpuhw->mmcr[1]);
 973         mtspr(SPRN_MMCR0, (cpuhw->mmcr[0] & ~(MMCR0_PMC1CE | MMCR0_PMCjCE))
 974                                 | MMCR0_FC);
 975
 976         /*
 977          * Read off any pre-existing events that need to move
 978          * to another PMC.
 979          */
 980         for (i = 0; i < cpuhw->n_events; ++i) {
 981                 event = cpuhw->event[i];
 982                 if (event->hw.idx && event->hw.idx != hwc_index[i] + 1) {
 983                         power_pmu_read(event);
 984                         write_pmc(event->hw.idx, 0);
 985                         event->hw.idx = 0;
 986                 }
 987         }
 988
 989         /*
 990          * Initialize the PMCs for all the new and moved events.
 991          */
 992         cpuhw->n_limited = n_lim = 0;
 993         for (i = 0; i < cpuhw->n_events; ++i) {
 994                 event = cpuhw->event[i];
 995                 if (event->hw.idx)
 996                         continue;
 997                 idx = hwc_index[i] + 1;
 998                 if (is_limited_pmc(idx)) {
 999                         cpuhw->limited_counter[n_lim] = event;
1000                         cpuhw->limited_hwidx[n_lim] = idx;
1001                         ++n_lim;
1002                         continue;
1003                 }
1004                 val = 0;
1005                 if (event->hw.sample_period) {
1006                         left = local64_read(&event->hw.period_left);
1007                         if (left < 0x80000000L)
1008                                 val = 0x80000000L - left;
1009                 }
1010                 local64_set(&event->hw.prev_count, val);
1011                 event->hw.idx = idx;
1012                 if (event->hw.state & PERF_HES_STOPPED)
1013                         val = 0;
1014                 write_pmc(idx, val);
1015                 perf_event_update_userpage(event);
1016         }
1017         cpuhw->n_limited = n_lim;
1018         cpuhw->mmcr[0] |= MMCR0_PMXE | MMCR0_FCECE;
1019
1020  out_enable:
1021         mb();
1022         write_mmcr0(cpuhw, cpuhw->mmcr[0]);
1023
1024         /*
1025          * Enable instruction sampling if necessary
1026          */
1027         if (cpuhw->mmcr[2] & MMCRA_SAMPLE_ENABLE) {
1028                 mb();
1029                 mtspr(SPRN_MMCRA, cpuhw->mmcr[2]);
1030         }
1031
1032  out:
1033         if (cpuhw->bhrb_users)
1034                 ppmu->config_bhrb(cpuhw->bhrb_filter);
1035
1036         local_irq_restore(flags);
1037 }
1038
1039 static int collect_events(struct perf_event *group, int max_count,
1040                           struct perf_event *ctrs[], u64 *events,
1041                           unsigned int *flags)
1042 {
1043         int n = 0;
1044         struct perf_event *event;
1045
1046         if (!is_software_event(group)) {
1047                 if (n >= max_count)
1048                         return -1;
1049                 ctrs[n] = group;
1050                 flags[n] = group->hw.event_base;
1051                 events[n++] = group->hw.config;
1052         }
1053         list_for_each_entry(event, &group->sibling_list, group_entry) {
1054                 if (!is_software_event(event) &&
1055                     event->state != PERF_EVENT_STATE_OFF) {
1056                         if (n >= max_count)
1057                                 return -1;
1058                         ctrs[n] = event;
1059                         flags[n] = event->hw.event_base;
1060                         events[n++] = event->hw.config;
1061                 }
1062         }
1063         return n;
1064 }
1065
1066 /*
1067  * Add a event to the PMU.
1068  * If all events are not already frozen, then we disable and
1069  * re-enable the PMU in order to get hw_perf_enable to do the
1070  * actual work of reconfiguring the PMU.
1071  */
1072 static int power_pmu_add(struct perf_event *event, int ef_flags)
1073 {
1074         struct cpu_hw_events *cpuhw;
1075         unsigned long flags;
1076         int n0;
1077         int ret = -EAGAIN;
1078
1079         local_irq_save(flags);
1080         perf_pmu_disable(event->pmu);
1081
1082         /*
1083          * Add the event to the list (if there is room)
1084          * and check whether the total set is still feasible.
1085          */
1086         cpuhw = &__get_cpu_var(cpu_hw_events);
1087         n0 = cpuhw->n_events;
1088         if (n0 >= ppmu->n_counter)
1089                 goto out;
1090         cpuhw->event[n0] = event;
1091         cpuhw->events[n0] = event->hw.config;
1092         cpuhw->flags[n0] = event->hw.event_base;
1093
1094         /*
1095          * This event may have been disabled/stopped in record_and_restart()
1096          * because we exceeded the ->event_limit. If re-starting the event,
1097          * clear the ->hw.state (STOPPED and UPTODATE flags), so the user
1098          * notification is re-enabled.
1099          */
1100         if (!(ef_flags & PERF_EF_START))
1101                 event->hw.state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
1102         else
1103                 event->hw.state = 0;
1104
1105         /*
1106          * If group events scheduling transaction was started,
1107          * skip the schedulability test here, it will be performed
1108          * at commit time(->commit_txn) as a whole
1109          */
1110         if (cpuhw->group_flag & PERF_EVENT_TXN)
1111                 goto nocheck;
1112
1113         if (check_excludes(cpuhw->event, cpuhw->flags, n0, 1))
1114                 goto out;
1115         if (power_check_constraints(cpuhw, cpuhw->events, cpuhw->flags, n0 + 1))
1116                 goto out;
1117         event->hw.config = cpuhw->events[n0];
1118
1119 nocheck:
1120         ++cpuhw->n_events;
1121         ++cpuhw->n_added;
1122
1123         ret = 0;
1124  out:
1125         if (has_branch_stack(event))
1126                 power_pmu_bhrb_enable(event);
1127
1128         perf_pmu_enable(event->pmu);
1129         local_irq_restore(flags);
1130         return ret;
1131 }
1132
1133 /*
1134  * Remove a event from the PMU.
1135  */
1136 static void power_pmu_del(struct perf_event *event, int ef_flags)
1137 {
1138         struct cpu_hw_events *cpuhw;
1139         long i;
1140         unsigned long flags;
1141
1142         local_irq_save(flags);
1143         perf_pmu_disable(event->pmu);
1144
1145         power_pmu_read(event);
1146
1147         cpuhw = &__get_cpu_var(cpu_hw_events);
1148         for (i = 0; i < cpuhw->n_events; ++i) {
1149                 if (event == cpuhw->event[i]) {
1150                         while (++i < cpuhw->n_events) {
1151                                 cpuhw->event[i-1] = cpuhw->event[i];
1152                                 cpuhw->events[i-1] = cpuhw->events[i];
1153                                 cpuhw->flags[i-1] = cpuhw->flags[i];
1154                         }
1155                         --cpuhw->n_events;
1156                         ppmu->disable_pmc(event->hw.idx - 1, cpuhw->mmcr);
1157                         if (event->hw.idx) {
1158                                 write_pmc(event->hw.idx, 0);
1159                                 event->hw.idx = 0;
1160                         }
1161                         perf_event_update_userpage(event);
1162                         break;
1163                 }
1164         }
1165         for (i = 0; i < cpuhw->n_limited; ++i)
1166                 if (event == cpuhw->limited_counter[i])
1167                         break;
1168         if (i < cpuhw->n_limited) {
1169                 while (++i < cpuhw->n_limited) {
1170                         cpuhw->limited_counter[i-1] = cpuhw->limited_counter[i];
1171                         cpuhw->limited_hwidx[i-1] = cpuhw->limited_hwidx[i];
1172                 }
1173                 --cpuhw->n_limited;
1174         }
1175         if (cpuhw->n_events == 0) {
1176                 /* disable exceptions if no events are running */
1177                 cpuhw->mmcr[0] &= ~(MMCR0_PMXE | MMCR0_FCECE);
1178         }
1179
1180         if (has_branch_stack(event))
1181                 power_pmu_bhrb_disable(event);
1182
1183         perf_pmu_enable(event->pmu);
1184         local_irq_restore(flags);
1185 }
1186
1187 /*
1188  * POWER-PMU does not support disabling individual counters, hence
1189  * program their cycle counter to their max value and ignore the interrupts.
1190  */
1191
1192 static void power_pmu_start(struct perf_event *event, int ef_flags)
1193 {
1194         unsigned long flags;
1195         s64 left;
1196         unsigned long val;
1197
1198         if (!event->hw.idx || !event->hw.sample_period)
1199                 return;
1200
1201         if (!(event->hw.state & PERF_HES_STOPPED))
1202                 return;
1203
1204         if (ef_flags & PERF_EF_RELOAD)
1205                 WARN_ON_ONCE(!(event->hw.state & PERF_HES_UPTODATE));
1206
1207         local_irq_save(flags);
1208         perf_pmu_disable(event->pmu);
1209
1210         event->hw.state = 0;
1211         left = local64_read(&event->hw.period_left);
1212
1213         val = 0;
1214         if (left < 0x80000000L)
1215                 val = 0x80000000L - left;
1216
1217         write_pmc(event->hw.idx, val);
1218
1219         perf_event_update_userpage(event);
1220         perf_pmu_enable(event->pmu);
1221         local_irq_restore(flags);
1222 }
1223
1224 static void power_pmu_stop(struct perf_event *event, int ef_flags)
1225 {
1226         unsigned long flags;
1227
1228         if (!event->hw.idx || !event->hw.sample_period)
1229                 return;
1230
1231         if (event->hw.state & PERF_HES_STOPPED)
1232                 return;
1233
1234         local_irq_save(flags);
1235         perf_pmu_disable(event->pmu);
1236
1237         power_pmu_read(event);
1238         event->hw.state |= PERF_HES_STOPPED | PERF_HES_UPTODATE;
1239         write_pmc(event->hw.idx, 0);
1240
1241         perf_event_update_userpage(event);
1242         perf_pmu_enable(event->pmu);
1243         local_irq_restore(flags);
1244 }
1245
1246 /*
1247  * Start group events scheduling transaction
1248  * Set the flag to make pmu::enable() not perform the
1249  * schedulability test, it will be performed at commit time
1250  */
1251 void power_pmu_start_txn(struct pmu *pmu)
1252 {
1253         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
1254
1255         perf_pmu_disable(pmu);
1256         cpuhw->group_flag |= PERF_EVENT_TXN;
1257         cpuhw->n_txn_start = cpuhw->n_events;
1258 }
1259
1260 /*
1261  * Stop group events scheduling transaction
1262  * Clear the flag and pmu::enable() will perform the
1263  * schedulability test.
1264  */
1265 void power_pmu_cancel_txn(struct pmu *pmu)
1266 {
1267         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
1268
1269         cpuhw->group_flag &= ~PERF_EVENT_TXN;
1270         perf_pmu_enable(pmu);
1271 }
1272
1273 /*
1274  * Commit group events scheduling transaction
1275  * Perform the group schedulability test as a whole
1276  * Return 0 if success
1277  */
1278 int power_pmu_commit_txn(struct pmu *pmu)
1279 {
1280         struct cpu_hw_events *cpuhw;
1281         long i, n;
1282
1283         if (!ppmu)
1284                 return -EAGAIN;
1285         cpuhw = &__get_cpu_var(cpu_hw_events);
1286         n = cpuhw->n_events;
1287         if (check_excludes(cpuhw->event, cpuhw->flags, 0, n))
1288                 return -EAGAIN;
1289         i = power_check_constraints(cpuhw, cpuhw->events, cpuhw->flags, n);
1290         if (i < 0)
1291                 return -EAGAIN;
1292
1293         for (i = cpuhw->n_txn_start; i < n; ++i)
1294                 cpuhw->event[i]->hw.config = cpuhw->events[i];
1295
1296         cpuhw->group_flag &= ~PERF_EVENT_TXN;
1297         perf_pmu_enable(pmu);
1298         return 0;
1299 }
1300
1301 /*
1302  * Return 1 if we might be able to put event on a limited PMC,
1303  * or 0 if not.
1304  * A event can only go on a limited PMC if it counts something
1305  * that a limited PMC can count, doesn't require interrupts, and
1306  * doesn't exclude any processor mode.
1307  */
1308 static int can_go_on_limited_pmc(struct perf_event *event, u64 ev,
1309                                  unsigned int flags)
1310 {
1311         int n;
1312         u64 alt[MAX_EVENT_ALTERNATIVES];
1313
1314         if (event->attr.exclude_user
1315             || event->attr.exclude_kernel
1316             || event->attr.exclude_hv
1317             || event->attr.sample_period)
1318                 return 0;
1319
1320         if (ppmu->limited_pmc_event(ev))
1321                 return 1;
1322
1323         /*
1324          * The requested event_id isn't on a limited PMC already;
1325          * see if any alternative code goes on a limited PMC.
1326          */
1327         if (!ppmu->get_alternatives)
1328                 return 0;
1329
1330         flags |= PPMU_LIMITED_PMC_OK | PPMU_LIMITED_PMC_REQD;
1331         n = ppmu->get_alternatives(ev, flags, alt);
1332
1333         return n > 0;
1334 }
1335
1336 /*
1337  * Find an alternative event_id that goes on a normal PMC, if possible,
1338  * and return the event_id code, or 0 if there is no such alternative.
1339  * (Note: event_id code 0 is "don't count" on all machines.)
1340  */
1341 static u64 normal_pmc_alternative(u64 ev, unsigned long flags)
1342 {
1343         u64 alt[MAX_EVENT_ALTERNATIVES];
1344         int n;
1345
1346         flags &= ~(PPMU_LIMITED_PMC_OK | PPMU_LIMITED_PMC_REQD);
1347         n = ppmu->get_alternatives(ev, flags, alt);
1348         if (!n)
1349                 return 0;
1350         return alt[0];
1351 }
1352
1353 /* Number of perf_events counting hardware events */
1354 static atomic_t num_events;
1355 /* Used to avoid races in calling reserve/release_pmc_hardware */
1356 static DEFINE_MUTEX(pmc_reserve_mutex);
1357
1358 /*
1359  * Release the PMU if this is the last perf_event.
1360  */
1361 static void hw_perf_event_destroy(struct perf_event *event)
1362 {
1363         if (!atomic_add_unless(&num_events, -1, 1)) {
1364                 mutex_lock(&pmc_reserve_mutex);
1365                 if (atomic_dec_return(&num_events) == 0)
1366                         release_pmc_hardware();
1367                 mutex_unlock(&pmc_reserve_mutex);
1368         }
1369 }
1370
1371 /*
1372  * Translate a generic cache event_id config to a raw event_id code.
1373  */
1374 static int hw_perf_cache_event(u64 config, u64 *eventp)
1375 {
1376         unsigned long type, op, result;
1377         int ev;
1378
1379         if (!ppmu->cache_events)
1380                 return -EINVAL;
1381
1382         /* unpack config */
1383         type = config & 0xff;
1384         op = (config >> 8) & 0xff;
1385         result = (config >> 16) & 0xff;
1386
1387         if (type >= PERF_COUNT_HW_CACHE_MAX ||
1388             op >= PERF_COUNT_HW_CACHE_OP_MAX ||
1389             result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
1390                 return -EINVAL;
1391
1392         ev = (*ppmu->cache_events)[type][op][result];
1393         if (ev == 0)
1394                 return -EOPNOTSUPP;
1395         if (ev == -1)
1396                 return -EINVAL;
1397         *eventp = ev;
1398         return 0;
1399 }
1400
1401 static int power_pmu_event_init(struct perf_event *event)
1402 {
1403         u64 ev;
1404         unsigned long flags;
1405         struct perf_event *ctrs[MAX_HWEVENTS];
1406         u64 events[MAX_HWEVENTS];
1407         unsigned int cflags[MAX_HWEVENTS];
1408         int n;
1409         int err;
1410         struct cpu_hw_events *cpuhw;
1411
1412         if (!ppmu)
1413                 return -ENOENT;
1414
1415         if (has_branch_stack(event)) {
1416                 /* PMU has BHRB enabled */
1417                 if (!(ppmu->flags & PPMU_BHRB))
1418                         return -EOPNOTSUPP;
1419         }
1420
1421         switch (event->attr.type) {
1422         case PERF_TYPE_HARDWARE:
1423                 ev = event->attr.config;
1424                 if (ev >= ppmu->n_generic || ppmu->generic_events[ev] == 0)
1425                         return -EOPNOTSUPP;
1426                 ev = ppmu->generic_events[ev];
1427                 break;
1428         case PERF_TYPE_HW_CACHE:
1429                 err = hw_perf_cache_event(event->attr.config, &ev);
1430                 if (err)
1431                         return err;
1432                 break;
1433         case PERF_TYPE_RAW:
1434                 ev = event->attr.config;
1435                 break;
1436         default:
1437                 return -ENOENT;
1438         }
1439
1440         event->hw.config_base = ev;
1441         event->hw.idx = 0;
1442
1443         /*
1444          * If we are not running on a hypervisor, force the
1445          * exclude_hv bit to 0 so that we don't care what
1446          * the user set it to.
1447          */
1448         if (!firmware_has_feature(FW_FEATURE_LPAR))
1449                 event->attr.exclude_hv = 0;
1450
1451         /*
1452          * If this is a per-task event, then we can use
1453          * PM_RUN_* events interchangeably with their non RUN_*
1454          * equivalents, e.g. PM_RUN_CYC instead of PM_CYC.
1455          * XXX we should check if the task is an idle task.
1456          */
1457         flags = 0;
1458         if (event->attach_state & PERF_ATTACH_TASK)
1459                 flags |= PPMU_ONLY_COUNT_RUN;
1460
1461         /*
1462          * If this machine has limited events, check whether this
1463          * event_id could go on a limited event.
1464          */
1465         if (ppmu->flags & PPMU_LIMITED_PMC5_6) {
1466                 if (can_go_on_limited_pmc(event, ev, flags)) {
1467                         flags |= PPMU_LIMITED_PMC_OK;
1468                 } else if (ppmu->limited_pmc_event(ev)) {
1469                         /*
1470                          * The requested event_id is on a limited PMC,
1471                          * but we can't use a limited PMC; see if any
1472                          * alternative goes on a normal PMC.
1473                          */
1474                         ev = normal_pmc_alternative(ev, flags);
1475                         if (!ev)
1476                                 return -EINVAL;
1477                 }
1478         }
1479
1480         /*
1481          * If this is in a group, check if it can go on with all the
1482          * other hardware events in the group.  We assume the event
1483          * hasn't been linked into its leader's sibling list at this point.
1484          */
1485         n = 0;
1486         if (event->group_leader != event) {
1487                 n = collect_events(event->group_leader, ppmu->n_counter - 1,
1488                                    ctrs, events, cflags);
1489                 if (n < 0)
1490                         return -EINVAL;
1491         }
1492         events[n] = ev;
1493         ctrs[n] = event;
1494         cflags[n] = flags;
1495         if (check_excludes(ctrs, cflags, n, 1))
1496                 return -EINVAL;
1497
1498         cpuhw = &get_cpu_var(cpu_hw_events);
1499         err = power_check_constraints(cpuhw, events, cflags, n + 1);
1500
1501         if (has_branch_stack(event)) {
1502                 cpuhw->bhrb_filter = ppmu->bhrb_filter_map(
1503                                         event->attr.branch_sample_type);
1504
1505                 if(cpuhw->bhrb_filter == -1)
1506                         return -EOPNOTSUPP;
1507         }
1508
1509         put_cpu_var(cpu_hw_events);
1510         if (err)
1511                 return -EINVAL;
1512
1513         event->hw.config = events[n];
1514         event->hw.event_base = cflags[n];
1515         event->hw.last_period = event->hw.sample_period;
1516         local64_set(&event->hw.period_left, event->hw.last_period);
1517
1518         /*
1519          * See if we need to reserve the PMU.
1520          * If no events are currently in use, then we have to take a
1521          * mutex to ensure that we don't race with another task doing
1522          * reserve_pmc_hardware or release_pmc_hardware.
1523          */
1524         err = 0;
1525         if (!atomic_inc_not_zero(&num_events)) {
1526                 mutex_lock(&pmc_reserve_mutex);
1527                 if (atomic_read(&num_events) == 0 &&
1528                     reserve_pmc_hardware(perf_event_interrupt))
1529                         err = -EBUSY;
1530                 else
1531                         atomic_inc(&num_events);
1532                 mutex_unlock(&pmc_reserve_mutex);
1533         }
1534         event->destroy = hw_perf_event_destroy;
1535
1536         return err;
1537 }
1538
1539 static int power_pmu_event_idx(struct perf_event *event)
1540 {
1541         return event->hw.idx;
1542 }
1543
1544 ssize_t power_events_sysfs_show(struct device *dev,
1545                                 struct device_attribute *attr, char *page)
1546 {
1547         struct perf_pmu_events_attr *pmu_attr;
1548
1549         pmu_attr = container_of(attr, struct perf_pmu_events_attr, attr);
1550
1551         return sprintf(page, "event=0x%02llx\n", pmu_attr->id);
1552 }
1553
1554 struct pmu power_pmu = {
1555         .pmu_enable     = power_pmu_enable,
1556         .pmu_disable    = power_pmu_disable,
1557         .event_init     = power_pmu_event_init,
1558         .add            = power_pmu_add,
1559         .del            = power_pmu_del,
1560         .start          = power_pmu_start,
1561         .stop           = power_pmu_stop,
1562         .read           = power_pmu_read,
1563         .start_txn      = power_pmu_start_txn,
1564         .cancel_txn     = power_pmu_cancel_txn,
1565         .commit_txn     = power_pmu_commit_txn,
1566         .event_idx      = power_pmu_event_idx,
1567         .flush_branch_stack = power_pmu_flush_branch_stack,
1568 };
1569
1570 /*
1571  * A counter has overflowed; update its count and record
1572  * things if requested.  Note that interrupts are hard-disabled
1573  * here so there is no possibility of being interrupted.
1574  */
1575 static void record_and_restart(struct perf_event *event, unsigned long val,
1576                                struct pt_regs *regs)
1577 {
1578         u64 period = event->hw.sample_period;
1579         s64 prev, delta, left;
1580         int record = 0;
1581
1582         if (event->hw.state & PERF_HES_STOPPED) {
1583                 write_pmc(event->hw.idx, 0);
1584                 return;
1585         }
1586
1587         /* we don't have to worry about interrupts here */
1588         prev = local64_read(&event->hw.prev_count);
1589         delta = check_and_compute_delta(prev, val);
1590         local64_add(delta, &event->count);
1591
1592         /*
1593          * See if the total period for this event has expired,
1594          * and update for the next period.
1595          */
1596         val = 0;
1597         left = local64_read(&event->hw.period_left) - delta;
1598         if (delta == 0)
1599                 left++;
1600         if (period) {
1601                 if (left <= 0) {
1602                         left += period;
1603                         if (left <= 0)
1604                                 left = period;
1605                         record = siar_valid(regs);
1606                         event->hw.last_period = event->hw.sample_period;
1607                 }
1608                 if (left < 0x80000000LL)
1609                         val = 0x80000000LL - left;
1610         }
1611
1612         write_pmc(event->hw.idx, val);
1613         local64_set(&event->hw.prev_count, val);
1614         local64_set(&event->hw.period_left, left);
1615         perf_event_update_userpage(event);
1616
1617         /*
1618          * Finally record data if requested.
1619          */
1620         if (record) {
1621                 struct perf_sample_data data;
1622
1623                 perf_sample_data_init(&data, ~0ULL, event->hw.last_period);
1624
1625                 if (event->attr.sample_type & PERF_SAMPLE_ADDR)
1626                         perf_get_data_addr(regs, &data.addr);
1627
1628                 if (event->attr.sample_type & PERF_SAMPLE_BRANCH_STACK) {
1629                         struct cpu_hw_events *cpuhw;
1630                         cpuhw = &__get_cpu_var(cpu_hw_events);
1631                         power_pmu_bhrb_read(cpuhw);
1632                         data.br_stack = &cpuhw->bhrb_stack;
1633                 }
1634
1635                 if (perf_event_overflow(event, &data, regs))
1636                         power_pmu_stop(event, 0);
1637         }
1638 }
1639
1640 /*
1641  * Called from generic code to get the misc flags (i.e. processor mode)
1642  * for an event_id.
1643  */
1644 unsigned long perf_misc_flags(struct pt_regs *regs)
1645 {
1646         u32 flags = perf_get_misc_flags(regs);
1647
1648         if (flags)
1649                 return flags;
1650         return user_mode(regs) ? PERF_RECORD_MISC_USER :
1651                 PERF_RECORD_MISC_KERNEL;
1652 }
1653
1654 /*
1655  * Called from generic code to get the instruction pointer
1656  * for an event_id.
1657  */
1658 unsigned long perf_instruction_pointer(struct pt_regs *regs)
1659 {
1660         bool use_siar = regs_use_siar(regs);
1661
1662         if (use_siar && siar_valid(regs))
1663                 return mfspr(SPRN_SIAR) + perf_ip_adjust(regs);
1664         else if (use_siar)
1665                 return 0;               // no valid instruction pointer
1666         else
1667                 return regs->nip;
1668 }
1669
1670 static bool pmc_overflow_power7(unsigned long val)
1671 {
1672         /*
1673          * Events on POWER7 can roll back if a speculative event doesn't
1674          * eventually complete. Unfortunately in some rare cases they will
1675          * raise a performance monitor exception. We need to catch this to
1676          * ensure we reset the PMC. In all cases the PMC will be 256 or less
1677          * cycles from overflow.
1678          *
1679          * We only do this if the first pass fails to find any overflowing
1680          * PMCs because a user might set a period of less than 256 and we
1681          * don't want to mistakenly reset them.
1682          */
1683         if ((0x80000000 - val) <= 256)
1684                 return true;
1685
1686         return false;
1687 }
1688
1689 static bool pmc_overflow(unsigned long val)
1690 {
1691         if ((int)val < 0)
1692                 return true;
1693
1694         return false;
1695 }
1696
1697 /*
1698  * Performance monitor interrupt stuff
1699  */
1700 static void perf_event_interrupt(struct pt_regs *regs)
1701 {
1702         int i, j;
1703         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
1704         struct perf_event *event;
1705         unsigned long val[8];
1706         int found, active;
1707         int nmi;
1708
1709         if (cpuhw->n_limited)
1710                 freeze_limited_counters(cpuhw, mfspr(SPRN_PMC5),
1711                                         mfspr(SPRN_PMC6));
1712
1713         perf_read_regs(regs);
1714
1715         nmi = perf_intr_is_nmi(regs);
1716         if (nmi)
1717                 nmi_enter();
1718         else
1719                 irq_enter();
1720
1721         /* Read all the PMCs since we'll need them a bunch of times */
1722         for (i = 0; i < ppmu->n_counter; ++i)
1723                 val[i] = read_pmc(i + 1);
1724
1725         /* Try to find what caused the IRQ */
1726         found = 0;
1727         for (i = 0; i < ppmu->n_counter; ++i) {
1728                 if (!pmc_overflow(val[i]))
1729                         continue;
1730                 if (is_limited_pmc(i + 1))
1731                         continue; /* these won't generate IRQs */
1732                 /*
1733                  * We've found one that's overflowed.  For active
1734                  * counters we need to log this.  For inactive
1735                  * counters, we need to reset it anyway
1736                  */
1737                 found = 1;
1738                 active = 0;
1739                 for (j = 0; j < cpuhw->n_events; ++j) {
1740                         event = cpuhw->event[j];
1741                         if (event->hw.idx == (i + 1)) {
1742                                 active = 1;
1743                                 record_and_restart(event, val[i], regs);
1744                                 break;
1745                         }
1746                 }
1747                 if (!active)
1748                         /* reset non active counters that have overflowed */
1749                         write_pmc(i + 1, 0);
1750         }
1751         if (!found && pvr_version_is(PVR_POWER7)) {
1752                 /* check active counters for special buggy p7 overflow */
1753                 for (i = 0; i < cpuhw->n_events; ++i) {
1754                         event = cpuhw->event[i];
1755                         if (!event->hw.idx || is_limited_pmc(event->hw.idx))
1756                                 continue;
1757                         if (pmc_overflow_power7(val[event->hw.idx - 1])) {
1758                                 /* event has overflowed in a buggy way*/
1759                                 found = 1;
1760                                 record_and_restart(event,
1761                                                    val[event->hw.idx - 1],
1762                                                    regs);
1763                         }
1764                 }
1765         }
1766         if ((!found) && printk_ratelimit())
1767                 printk(KERN_WARNING "Can't find PMC that caused IRQ\n");
1768
1769         /*
1770          * Reset MMCR0 to its normal value.  This will set PMXE and
1771          * clear FC (freeze counters) and PMAO (perf mon alert occurred)
1772          * and thus allow interrupts to occur again.
1773          * XXX might want to use MSR.PM to keep the events frozen until
1774          * we get back out of this interrupt.
1775          */
1776         write_mmcr0(cpuhw, cpuhw->mmcr[0]);
1777
1778         if (nmi)
1779                 nmi_exit();
1780         else
1781                 irq_exit();
1782 }
1783
1784 static void power_pmu_setup(int cpu)
1785 {
1786         struct cpu_hw_events *cpuhw = &per_cpu(cpu_hw_events, cpu);
1787
1788         if (!ppmu)
1789                 return;
1790         memset(cpuhw, 0, sizeof(*cpuhw));
1791         cpuhw->mmcr[0] = MMCR0_FC;
1792 }
1793
1794 static int __cpuinit
1795 power_pmu_notifier(struct notifier_block *self, unsigned long action, void *hcpu)
1796 {
1797         unsigned int cpu = (long)hcpu;
1798
1799         switch (action & ~CPU_TASKS_FROZEN) {
1800         case CPU_UP_PREPARE:
1801                 power_pmu_setup(cpu);
1802                 break;
1803
1804         default:
1805                 break;
1806         }
1807
1808         return NOTIFY_OK;
1809 }
1810
1811 int __cpuinit register_power_pmu(struct power_pmu *pmu)
1812 {
1813         if (ppmu)
1814                 return -EBUSY;          /* something's already registered */
1815
1816         ppmu = pmu;
1817         pr_info("%s performance monitor hardware support registered\n",
1818                 pmu->name);
1819
1820         power_pmu.attr_groups = ppmu->attr_groups;
1821
1822 #ifdef MSR_HV
1823         /*
1824          * Use FCHV to ignore kernel events if MSR.HV is set.
1825          */
1826         if (mfmsr() & MSR_HV)
1827                 freeze_events_kernel = MMCR0_FCHV;
1828 #endif /* CONFIG_PPC64 */
1829
1830         perf_pmu_register(&power_pmu, "cpu", PERF_TYPE_RAW);
1831         perf_cpu_notifier(power_pmu_notifier);
1832
1833         return 0;
1834 }