arch/powerpc/kernel/perf_event.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 <asm/reg.h>
  17 #include <asm/pmc.h>
  18 #include <asm/machdep.h>
  19 #include <asm/firmware.h>
  20 #include <asm/ptrace.h>
  21
  22 struct cpu_hw_events {
  23         int n_events;
  24         int n_percpu;
  25         int disabled;
  26         int n_added;
  27         int n_limited;
  28         u8  pmcs_enabled;
  29         struct perf_event *event[MAX_HWEVENTS];
  30         u64 events[MAX_HWEVENTS];
  31         unsigned int flags[MAX_HWEVENTS];
  32         unsigned long mmcr[3];
  33         struct perf_event *limited_counter[MAX_LIMITED_HWCOUNTERS];
  34         u8  limited_hwidx[MAX_LIMITED_HWCOUNTERS];
  35         u64 alternatives[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  36         unsigned long amasks[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  37         unsigned long avalues[MAX_HWEVENTS][MAX_EVENT_ALTERNATIVES];
  38
  39         unsigned int group_flag;
  40         int n_txn_start;
  41 };
  42 DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
  43
  44 struct power_pmu *ppmu;
  45
  46 /*
  47  * Normally, to ignore kernel events we set the FCS (freeze counters
  48  * in supervisor mode) bit in MMCR0, but if the kernel runs with the
  49  * hypervisor bit set in the MSR, or if we are running on a processor
  50  * where the hypervisor bit is forced to 1 (as on Apple G5 processors),
  51  * then we need to use the FCHV bit to ignore kernel events.
  52  */
  53 static unsigned int freeze_events_kernel = MMCR0_FCS;
  54
  55 /*
  56  * 32-bit doesn't have MMCRA but does have an MMCR2,
  57  * and a few other names are different.
  58  */
  59 #ifdef CONFIG_PPC32
  60
  61 #define MMCR0_FCHV              0
  62 #define MMCR0_PMCjCE            MMCR0_PMCnCE
  63
  64 #define SPRN_MMCRA              SPRN_MMCR2
  65 #define MMCRA_SAMPLE_ENABLE     0
  66
  67 static inline unsigned long perf_ip_adjust(struct pt_regs *regs)
  68 {
  69         return 0;
  70 }
  71 static inline void perf_get_data_addr(struct pt_regs *regs, u64 *addrp) { }
  72 static inline u32 perf_get_misc_flags(struct pt_regs *regs)
  73 {
  74         return 0;
  75 }
  76 static inline void perf_read_regs(struct pt_regs *regs) { }
  77 static inline int perf_intr_is_nmi(struct pt_regs *regs)
  78 {
  79         return 0;
  80 }
  81
  82 #endif /* CONFIG_PPC32 */
  83
  84 /*
  85  * Things that are specific to 64-bit implementations.
  86  */
  87 #ifdef CONFIG_PPC64
  88
  89 static inline unsigned long perf_ip_adjust(struct pt_regs *regs)
  90 {
  91         unsigned long mmcra = regs->dsisr;
  92
  93         if ((mmcra & MMCRA_SAMPLE_ENABLE) && !(ppmu->flags & PPMU_ALT_SIPR)) {
  94                 unsigned long slot = (mmcra & MMCRA_SLOT) >> MMCRA_SLOT_SHIFT;
  95                 if (slot > 1)
  96                         return 4 * (slot - 1);
  97         }
  98         return 0;
  99 }
 100
 101 /*
 102  * The user wants a data address recorded.
 103  * If we're not doing instruction sampling, give them the SDAR
 104  * (sampled data address).  If we are doing instruction sampling, then
 105  * only give them the SDAR if it corresponds to the instruction
 106  * pointed to by SIAR; this is indicated by the [POWER6_]MMCRA_SDSYNC
 107  * bit in MMCRA.
 108  */
 109 static inline void perf_get_data_addr(struct pt_regs *regs, u64 *addrp)
 110 {
 111         unsigned long mmcra = regs->dsisr;
 112         unsigned long sdsync = (ppmu->flags & PPMU_ALT_SIPR) ?
 113                 POWER6_MMCRA_SDSYNC : MMCRA_SDSYNC;
 114
 115         if (!(mmcra & MMCRA_SAMPLE_ENABLE) || (mmcra & sdsync))
 116                 *addrp = mfspr(SPRN_SDAR);
 117 }
 118
 119 static inline u32 perf_get_misc_flags(struct pt_regs *regs)
 120 {
 121         unsigned long mmcra = regs->dsisr;
 122         unsigned long sihv = MMCRA_SIHV;
 123         unsigned long sipr = MMCRA_SIPR;
 124
 125         if (TRAP(regs) != 0xf00)
 126                 return 0;       /* not a PMU interrupt */
 127
 128         if (ppmu->flags & PPMU_ALT_SIPR) {
 129                 sihv = POWER6_MMCRA_SIHV;
 130                 sipr = POWER6_MMCRA_SIPR;
 131         }
 132
 133         /* PR has priority over HV, so order below is important */
 134         if (mmcra & sipr)
 135                 return PERF_RECORD_MISC_USER;
 136         if ((mmcra & sihv) && (freeze_events_kernel != MMCR0_FCHV))
 137                 return PERF_RECORD_MISC_HYPERVISOR;
 138         return PERF_RECORD_MISC_KERNEL;
 139 }
 140
 141 /*
 142  * Overload regs->dsisr to store MMCRA so we only need to read it once
 143  * on each interrupt.
 144  */
 145 static inline void perf_read_regs(struct pt_regs *regs)
 146 {
 147         regs->dsisr = mfspr(SPRN_MMCRA);
 148 }
 149
 150 /*
 151  * If interrupts were soft-disabled when a PMU interrupt occurs, treat
 152  * it as an NMI.
 153  */
 154 static inline int perf_intr_is_nmi(struct pt_regs *regs)
 155 {
 156         return !regs->softe;
 157 }
 158
 159 #endif /* CONFIG_PPC64 */
 160
 161 static void perf_event_interrupt(struct pt_regs *regs);
 162
 163 void perf_event_print_debug(void)
 164 {
 165 }
 166
 167 /*
 168  * Read one performance monitor counter (PMC).
 169  */
 170 static unsigned long read_pmc(int idx)
 171 {
 172         unsigned long val;
 173
 174         switch (idx) {
 175         case 1:
 176                 val = mfspr(SPRN_PMC1);
 177                 break;
 178         case 2:
 179                 val = mfspr(SPRN_PMC2);
 180                 break;
 181         case 3:
 182                 val = mfspr(SPRN_PMC3);
 183                 break;
 184         case 4:
 185                 val = mfspr(SPRN_PMC4);
 186                 break;
 187         case 5:
 188                 val = mfspr(SPRN_PMC5);
 189                 break;
 190         case 6:
 191                 val = mfspr(SPRN_PMC6);
 192                 break;
 193 #ifdef CONFIG_PPC64
 194         case 7:
 195                 val = mfspr(SPRN_PMC7);
 196                 break;
 197         case 8:
 198                 val = mfspr(SPRN_PMC8);
 199                 break;
 200 #endif /* CONFIG_PPC64 */
 201         default:
 202                 printk(KERN_ERR "oops trying to read PMC%d\n", idx);
 203                 val = 0;
 204         }
 205         return val;
 206 }
 207
 208 /*
 209  * Write one PMC.
 210  */
 211 static void write_pmc(int idx, unsigned long val)
 212 {
 213         switch (idx) {
 214         case 1:
 215                 mtspr(SPRN_PMC1, val);
 216                 break;
 217         case 2:
 218                 mtspr(SPRN_PMC2, val);
 219                 break;
 220         case 3:
 221                 mtspr(SPRN_PMC3, val);
 222                 break;
 223         case 4:
 224                 mtspr(SPRN_PMC4, val);
 225                 break;
 226         case 5:
 227                 mtspr(SPRN_PMC5, val);
 228                 break;
 229         case 6:
 230                 mtspr(SPRN_PMC6, val);
 231                 break;
 232 #ifdef CONFIG_PPC64
 233         case 7:
 234                 mtspr(SPRN_PMC7, val);
 235                 break;
 236         case 8:
 237                 mtspr(SPRN_PMC8, val);
 238                 break;
 239 #endif /* CONFIG_PPC64 */
 240         default:
 241                 printk(KERN_ERR "oops trying to write PMC%d\n", idx);
 242         }
 243 }
 244
 245 /*
 246  * Check if a set of events can all go on the PMU at once.
 247  * If they can't, this will look at alternative codes for the events
 248  * and see if any combination of alternative codes is feasible.
 249  * The feasible set is returned in event_id[].
 250  */
 251 static int power_check_constraints(struct cpu_hw_events *cpuhw,
 252                                    u64 event_id[], unsigned int cflags[],
 253                                    int n_ev)
 254 {
 255         unsigned long mask, value, nv;
 256         unsigned long smasks[MAX_HWEVENTS], svalues[MAX_HWEVENTS];
 257         int n_alt[MAX_HWEVENTS], choice[MAX_HWEVENTS];
 258         int i, j;
 259         unsigned long addf = ppmu->add_fields;
 260         unsigned long tadd = ppmu->test_adder;
 261
 262         if (n_ev > ppmu->n_counter)
 263                 return -1;
 264
 265         /* First see if the events will go on as-is */
 266         for (i = 0; i < n_ev; ++i) {
 267                 if ((cflags[i] & PPMU_LIMITED_PMC_REQD)
 268                     && !ppmu->limited_pmc_event(event_id[i])) {
 269                         ppmu->get_alternatives(event_id[i], cflags[i],
 270                                                cpuhw->alternatives[i]);
 271                         event_id[i] = cpuhw->alternatives[i][0];
 272                 }
 273                 if (ppmu->get_constraint(event_id[i], &cpuhw->amasks[i][0],
 274                                          &cpuhw->avalues[i][0]))
 275                         return -1;
 276         }
 277         value = mask = 0;
 278         for (i = 0; i < n_ev; ++i) {
 279                 nv = (value | cpuhw->avalues[i][0]) +
 280                         (value & cpuhw->avalues[i][0] & addf);
 281                 if ((((nv + tadd) ^ value) & mask) != 0 ||
 282                     (((nv + tadd) ^ cpuhw->avalues[i][0]) &
 283                      cpuhw->amasks[i][0]) != 0)
 284                         break;
 285                 value = nv;
 286                 mask |= cpuhw->amasks[i][0];
 287         }
 288         if (i == n_ev)
 289                 return 0;       /* all OK */
 290
 291         /* doesn't work, gather alternatives... */
 292         if (!ppmu->get_alternatives)
 293                 return -1;
 294         for (i = 0; i < n_ev; ++i) {
 295                 choice[i] = 0;
 296                 n_alt[i] = ppmu->get_alternatives(event_id[i], cflags[i],
 297                                                   cpuhw->alternatives[i]);
 298                 for (j = 1; j < n_alt[i]; ++j)
 299                         ppmu->get_constraint(cpuhw->alternatives[i][j],
 300                                              &cpuhw->amasks[i][j],
 301                                              &cpuhw->avalues[i][j]);
 302         }
 303
 304         /* enumerate all possibilities and see if any will work */
 305         i = 0;
 306         j = -1;
 307         value = mask = nv = 0;
 308         while (i < n_ev) {
 309                 if (j >= 0) {
 310                         /* we're backtracking, restore context */
 311                         value = svalues[i];
 312                         mask = smasks[i];
 313                         j = choice[i];
 314                 }
 315                 /*
 316                  * See if any alternative k for event_id i,
 317                  * where k > j, will satisfy the constraints.
 318                  */
 319                 while (++j < n_alt[i]) {
 320                         nv = (value | cpuhw->avalues[i][j]) +
 321                                 (value & cpuhw->avalues[i][j] & addf);
 322                         if ((((nv + tadd) ^ value) & mask) == 0 &&
 323                             (((nv + tadd) ^ cpuhw->avalues[i][j])
 324                              & cpuhw->amasks[i][j]) == 0)
 325                                 break;
 326                 }
 327                 if (j >= n_alt[i]) {
 328                         /*
 329                          * No feasible alternative, backtrack
 330                          * to event_id i-1 and continue enumerating its
 331                          * alternatives from where we got up to.
 332                          */
 333                         if (--i < 0)
 334                                 return -1;
 335                 } else {
 336                         /*
 337                          * Found a feasible alternative for event_id i,
 338                          * remember where we got up to with this event_id,
 339                          * go on to the next event_id, and start with
 340                          * the first alternative for it.
 341                          */
 342                         choice[i] = j;
 343                         svalues[i] = value;
 344                         smasks[i] = mask;
 345                         value = nv;
 346                         mask |= cpuhw->amasks[i][j];
 347                         ++i;
 348                         j = -1;
 349                 }
 350         }
 351
 352         /* OK, we have a feasible combination, tell the caller the solution */
 353         for (i = 0; i < n_ev; ++i)
 354                 event_id[i] = cpuhw->alternatives[i][choice[i]];
 355         return 0;
 356 }
 357
 358 /*
 359  * Check if newly-added events have consistent settings for
 360  * exclude_{user,kernel,hv} with each other and any previously
 361  * added events.
 362  */
 363 static int check_excludes(struct perf_event **ctrs, unsigned int cflags[],
 364                           int n_prev, int n_new)
 365 {
 366         int eu = 0, ek = 0, eh = 0;
 367         int i, n, first;
 368         struct perf_event *event;
 369
 370         n = n_prev + n_new;
 371         if (n <= 1)
 372                 return 0;
 373
 374         first = 1;
 375         for (i = 0; i < n; ++i) {
 376                 if (cflags[i] & PPMU_LIMITED_PMC_OK) {
 377                         cflags[i] &= ~PPMU_LIMITED_PMC_REQD;
 378                         continue;
 379                 }
 380                 event = ctrs[i];
 381                 if (first) {
 382                         eu = event->attr.exclude_user;
 383                         ek = event->attr.exclude_kernel;
 384                         eh = event->attr.exclude_hv;
 385                         first = 0;
 386                 } else if (event->attr.exclude_user != eu ||
 387                            event->attr.exclude_kernel != ek ||
 388                            event->attr.exclude_hv != eh) {
 389                         return -EAGAIN;
 390                 }
 391         }
 392
 393         if (eu || ek || eh)
 394                 for (i = 0; i < n; ++i)
 395                         if (cflags[i] & PPMU_LIMITED_PMC_OK)
 396                                 cflags[i] |= PPMU_LIMITED_PMC_REQD;
 397
 398         return 0;
 399 }
 400
 401 static void power_pmu_read(struct perf_event *event)
 402 {
 403         s64 val, delta, prev;
 404
 405         if (!event->hw.idx)
 406                 return;
 407         /*
 408          * Performance monitor interrupts come even when interrupts
 409          * are soft-disabled, as long as interrupts are hard-enabled.
 410          * Therefore we treat them like NMIs.
 411          */
 412         do {
 413                 prev = atomic64_read(&event->hw.prev_count);
 414                 barrier();
 415                 val = read_pmc(event->hw.idx);
 416         } while (atomic64_cmpxchg(&event->hw.prev_count, prev, val) != prev);
 417
 418         /* The counters are only 32 bits wide */
 419         delta = (val - prev) & 0xfffffffful;
 420         atomic64_add(delta, &event->count);
 421         atomic64_sub(delta, &event->hw.period_left);
 422 }
 423
 424 /*
 425  * On some machines, PMC5 and PMC6 can't be written, don't respect
 426  * the freeze conditions, and don't generate interrupts.  This tells
 427  * us if `event' is using such a PMC.
 428  */
 429 static int is_limited_pmc(int pmcnum)
 430 {
 431         return (ppmu->flags & PPMU_LIMITED_PMC5_6)
 432                 && (pmcnum == 5 || pmcnum == 6);
 433 }
 434
 435 static void freeze_limited_counters(struct cpu_hw_events *cpuhw,
 436                                     unsigned long pmc5, unsigned long pmc6)
 437 {
 438         struct perf_event *event;
 439         u64 val, prev, delta;
 440         int i;
 441
 442         for (i = 0; i < cpuhw->n_limited; ++i) {
 443                 event = cpuhw->limited_counter[i];
 444                 if (!event->hw.idx)
 445                         continue;
 446                 val = (event->hw.idx == 5) ? pmc5 : pmc6;
 447                 prev = atomic64_read(&event->hw.prev_count);
 448                 event->hw.idx = 0;
 449                 delta = (val - prev) & 0xfffffffful;
 450                 atomic64_add(delta, &event->count);
 451         }
 452 }
 453
 454 static void thaw_limited_counters(struct cpu_hw_events *cpuhw,
 455                                   unsigned long pmc5, unsigned long pmc6)
 456 {
 457         struct perf_event *event;
 458         u64 val;
 459         int i;
 460
 461         for (i = 0; i < cpuhw->n_limited; ++i) {
 462                 event = cpuhw->limited_counter[i];
 463                 event->hw.idx = cpuhw->limited_hwidx[i];
 464                 val = (event->hw.idx == 5) ? pmc5 : pmc6;
 465                 atomic64_set(&event->hw.prev_count, val);
 466                 perf_event_update_userpage(event);
 467         }
 468 }
 469
 470 /*
 471  * Since limited events don't respect the freeze conditions, we
 472  * have to read them immediately after freezing or unfreezing the
 473  * other events.  We try to keep the values from the limited
 474  * events as consistent as possible by keeping the delay (in
 475  * cycles and instructions) between freezing/unfreezing and reading
 476  * the limited events as small and consistent as possible.
 477  * Therefore, if any limited events are in use, we read them
 478  * both, and always in the same order, to minimize variability,
 479  * and do it inside the same asm that writes MMCR0.
 480  */
 481 static void write_mmcr0(struct cpu_hw_events *cpuhw, unsigned long mmcr0)
 482 {
 483         unsigned long pmc5, pmc6;
 484
 485         if (!cpuhw->n_limited) {
 486                 mtspr(SPRN_MMCR0, mmcr0);
 487                 return;
 488         }
 489
 490         /*
 491          * Write MMCR0, then read PMC5 and PMC6 immediately.
 492          * To ensure we don't get a performance monitor interrupt
 493          * between writing MMCR0 and freezing/thawing the limited
 494          * events, we first write MMCR0 with the event overflow
 495          * interrupt enable bits turned off.
 496          */
 497         asm volatile("mtspr %3,%2; mfspr %0,%4; mfspr %1,%5"
 498                      : "=&r" (pmc5), "=&r" (pmc6)
 499                      : "r" (mmcr0 & ~(MMCR0_PMC1CE | MMCR0_PMCjCE)),
 500                        "i" (SPRN_MMCR0),
 501                        "i" (SPRN_PMC5), "i" (SPRN_PMC6));
 502
 503         if (mmcr0 & MMCR0_FC)
 504                 freeze_limited_counters(cpuhw, pmc5, pmc6);
 505         else
 506                 thaw_limited_counters(cpuhw, pmc5, pmc6);
 507
 508         /*
 509          * Write the full MMCR0 including the event overflow interrupt
 510          * enable bits, if necessary.
 511          */
 512         if (mmcr0 & (MMCR0_PMC1CE | MMCR0_PMCjCE))
 513                 mtspr(SPRN_MMCR0, mmcr0);
 514 }
 515
 516 /*
 517  * Disable all events to prevent PMU interrupts and to allow
 518  * events to be added or removed.
 519  */
 520 void hw_perf_disable(void)
 521 {
 522         struct cpu_hw_events *cpuhw;
 523         unsigned long flags;
 524
 525         if (!ppmu)
 526                 return;
 527         local_irq_save(flags);
 528         cpuhw = &__get_cpu_var(cpu_hw_events);
 529
 530         if (!cpuhw->disabled) {
 531                 cpuhw->disabled = 1;
 532                 cpuhw->n_added = 0;
 533
 534                 /*
 535                  * Check if we ever enabled the PMU on this cpu.
 536                  */
 537                 if (!cpuhw->pmcs_enabled) {
 538                         ppc_enable_pmcs();
 539                         cpuhw->pmcs_enabled = 1;
 540                 }
 541
 542                 /*
 543                  * Disable instruction sampling if it was enabled
 544                  */
 545                 if (cpuhw->mmcr[2] & MMCRA_SAMPLE_ENABLE) {
 546                         mtspr(SPRN_MMCRA,
 547                               cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 548                         mb();
 549                 }
 550
 551                 /*
 552                  * Set the 'freeze counters' bit.
 553                  * The barrier is to make sure the mtspr has been
 554                  * executed and the PMU has frozen the events
 555                  * before we return.
 556                  */
 557                 write_mmcr0(cpuhw, mfspr(SPRN_MMCR0) | MMCR0_FC);
 558                 mb();
 559         }
 560         local_irq_restore(flags);
 561 }
 562
 563 /*
 564  * Re-enable all events if disable == 0.
 565  * If we were previously disabled and events were added, then
 566  * put the new config on the PMU.
 567  */
 568 void hw_perf_enable(void)
 569 {
 570         struct perf_event *event;
 571         struct cpu_hw_events *cpuhw;
 572         unsigned long flags;
 573         long i;
 574         unsigned long val;
 575         s64 left;
 576         unsigned int hwc_index[MAX_HWEVENTS];
 577         int n_lim;
 578         int idx;
 579
 580         if (!ppmu)
 581                 return;
 582         local_irq_save(flags);
 583         cpuhw = &__get_cpu_var(cpu_hw_events);
 584         if (!cpuhw->disabled) {
 585                 local_irq_restore(flags);
 586                 return;
 587         }
 588         cpuhw->disabled = 0;
 589
 590         /*
 591          * If we didn't change anything, or only removed events,
 592          * no need to recalculate MMCR* settings and reset the PMCs.
 593          * Just reenable the PMU with the current MMCR* settings
 594          * (possibly updated for removal of events).
 595          */
 596         if (!cpuhw->n_added) {
 597                 mtspr(SPRN_MMCRA, cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 598                 mtspr(SPRN_MMCR1, cpuhw->mmcr[1]);
 599                 if (cpuhw->n_events == 0)
 600                         ppc_set_pmu_inuse(0);
 601                 goto out_enable;
 602         }
 603
 604         /*
 605          * Compute MMCR* values for the new set of events
 606          */
 607         if (ppmu->compute_mmcr(cpuhw->events, cpuhw->n_events, hwc_index,
 608                                cpuhw->mmcr)) {
 609                 /* shouldn't ever get here */
 610                 printk(KERN_ERR "oops compute_mmcr failed\n");
 611                 goto out;
 612         }
 613
 614         /*
 615          * Add in MMCR0 freeze bits corresponding to the
 616          * attr.exclude_* bits for the first event.
 617          * We have already checked that all events have the
 618          * same values for these bits as the first event.
 619          */
 620         event = cpuhw->event[0];
 621         if (event->attr.exclude_user)
 622                 cpuhw->mmcr[0] |= MMCR0_FCP;
 623         if (event->attr.exclude_kernel)
 624                 cpuhw->mmcr[0] |= freeze_events_kernel;
 625         if (event->attr.exclude_hv)
 626                 cpuhw->mmcr[0] |= MMCR0_FCHV;
 627
 628         /*
 629          * Write the new configuration to MMCR* with the freeze
 630          * bit set and set the hardware events to their initial values.
 631          * Then unfreeze the events.
 632          */
 633         ppc_set_pmu_inuse(1);
 634         mtspr(SPRN_MMCRA, cpuhw->mmcr[2] & ~MMCRA_SAMPLE_ENABLE);
 635         mtspr(SPRN_MMCR1, cpuhw->mmcr[1]);
 636         mtspr(SPRN_MMCR0, (cpuhw->mmcr[0] & ~(MMCR0_PMC1CE | MMCR0_PMCjCE))
 637                                 | MMCR0_FC);
 638
 639         /*
 640          * Read off any pre-existing events that need to move
 641          * to another PMC.
 642          */
 643         for (i = 0; i < cpuhw->n_events; ++i) {
 644                 event = cpuhw->event[i];
 645                 if (event->hw.idx && event->hw.idx != hwc_index[i] + 1) {
 646                         power_pmu_read(event);
 647                         write_pmc(event->hw.idx, 0);
 648                         event->hw.idx = 0;
 649                 }
 650         }
 651
 652         /*
 653          * Initialize the PMCs for all the new and moved events.
 654          */
 655         cpuhw->n_limited = n_lim = 0;
 656         for (i = 0; i < cpuhw->n_events; ++i) {
 657                 event = cpuhw->event[i];
 658                 if (event->hw.idx)
 659                         continue;
 660                 idx = hwc_index[i] + 1;
 661                 if (is_limited_pmc(idx)) {
 662                         cpuhw->limited_counter[n_lim] = event;
 663                         cpuhw->limited_hwidx[n_lim] = idx;
 664                         ++n_lim;
 665                         continue;
 666                 }
 667                 val = 0;
 668                 if (event->hw.sample_period) {
 669                         left = atomic64_read(&event->hw.period_left);
 670                         if (left < 0x80000000L)
 671                                 val = 0x80000000L - left;
 672                 }
 673                 atomic64_set(&event->hw.prev_count, val);
 674                 event->hw.idx = idx;
 675                 write_pmc(idx, val);
 676                 perf_event_update_userpage(event);
 677         }
 678         cpuhw->n_limited = n_lim;
 679         cpuhw->mmcr[0] |= MMCR0_PMXE | MMCR0_FCECE;
 680
 681  out_enable:
 682         mb();
 683         write_mmcr0(cpuhw, cpuhw->mmcr[0]);
 684
 685         /*
 686          * Enable instruction sampling if necessary
 687          */
 688         if (cpuhw->mmcr[2] & MMCRA_SAMPLE_ENABLE) {
 689                 mb();
 690                 mtspr(SPRN_MMCRA, cpuhw->mmcr[2]);
 691         }
 692
 693  out:
 694         local_irq_restore(flags);
 695 }
 696
 697 static int collect_events(struct perf_event *group, int max_count,
 698                           struct perf_event *ctrs[], u64 *events,
 699                           unsigned int *flags)
 700 {
 701         int n = 0;
 702         struct perf_event *event;
 703
 704         if (!is_software_event(group)) {
 705                 if (n >= max_count)
 706                         return -1;
 707                 ctrs[n] = group;
 708                 flags[n] = group->hw.event_base;
 709                 events[n++] = group->hw.config;
 710         }
 711         list_for_each_entry(event, &group->sibling_list, group_entry) {
 712                 if (!is_software_event(event) &&
 713                     event->state != PERF_EVENT_STATE_OFF) {
 714                         if (n >= max_count)
 715                                 return -1;
 716                         ctrs[n] = event;
 717                         flags[n] = event->hw.event_base;
 718                         events[n++] = event->hw.config;
 719                 }
 720         }
 721         return n;
 722 }
 723
 724 /*
 725  * Add a event to the PMU.
 726  * If all events are not already frozen, then we disable and
 727  * re-enable the PMU in order to get hw_perf_enable to do the
 728  * actual work of reconfiguring the PMU.
 729  */
 730 static int power_pmu_enable(struct perf_event *event)
 731 {
 732         struct cpu_hw_events *cpuhw;
 733         unsigned long flags;
 734         int n0;
 735         int ret = -EAGAIN;
 736
 737         local_irq_save(flags);
 738         perf_disable();
 739
 740         /*
 741          * Add the event to the list (if there is room)
 742          * and check whether the total set is still feasible.
 743          */
 744         cpuhw = &__get_cpu_var(cpu_hw_events);
 745         n0 = cpuhw->n_events;
 746         if (n0 >= ppmu->n_counter)
 747                 goto out;
 748         cpuhw->event[n0] = event;
 749         cpuhw->events[n0] = event->hw.config;
 750         cpuhw->flags[n0] = event->hw.event_base;
 751
 752         /*
 753          * If group events scheduling transaction was started,
 754          * skip the schedulability test here, it will be peformed
 755          * at commit time(->commit_txn) as a whole
 756          */
 757         if (cpuhw->group_flag & PERF_EVENT_TXN_STARTED)
 758                 goto nocheck;
 759
 760         if (check_excludes(cpuhw->event, cpuhw->flags, n0, 1))
 761                 goto out;
 762         if (power_check_constraints(cpuhw, cpuhw->events, cpuhw->flags, n0 + 1))
 763                 goto out;
 764         event->hw.config = cpuhw->events[n0];
 765
 766 nocheck:
 767         ++cpuhw->n_events;
 768         ++cpuhw->n_added;
 769
 770         ret = 0;
 771  out:
 772         perf_enable();
 773         local_irq_restore(flags);
 774         return ret;
 775 }
 776
 777 /*
 778  * Remove a event from the PMU.
 779  */
 780 static void power_pmu_disable(struct perf_event *event)
 781 {
 782         struct cpu_hw_events *cpuhw;
 783         long i;
 784         unsigned long flags;
 785
 786         local_irq_save(flags);
 787         perf_disable();
 788
 789         power_pmu_read(event);
 790
 791         cpuhw = &__get_cpu_var(cpu_hw_events);
 792         for (i = 0; i < cpuhw->n_events; ++i) {
 793                 if (event == cpuhw->event[i]) {
 794                         while (++i < cpuhw->n_events)
 795                                 cpuhw->event[i-1] = cpuhw->event[i];
 796                         --cpuhw->n_events;
 797                         ppmu->disable_pmc(event->hw.idx - 1, cpuhw->mmcr);
 798                         if (event->hw.idx) {
 799                                 write_pmc(event->hw.idx, 0);
 800                                 event->hw.idx = 0;
 801                         }
 802                         perf_event_update_userpage(event);
 803                         break;
 804                 }
 805         }
 806         for (i = 0; i < cpuhw->n_limited; ++i)
 807                 if (event == cpuhw->limited_counter[i])
 808                         break;
 809         if (i < cpuhw->n_limited) {
 810                 while (++i < cpuhw->n_limited) {
 811                         cpuhw->limited_counter[i-1] = cpuhw->limited_counter[i];
 812                         cpuhw->limited_hwidx[i-1] = cpuhw->limited_hwidx[i];
 813                 }
 814                 --cpuhw->n_limited;
 815         }
 816         if (cpuhw->n_events == 0) {
 817                 /* disable exceptions if no events are running */
 818                 cpuhw->mmcr[0] &= ~(MMCR0_PMXE | MMCR0_FCECE);
 819         }
 820
 821         perf_enable();
 822         local_irq_restore(flags);
 823 }
 824
 825 /*
 826  * Re-enable interrupts on a event after they were throttled
 827  * because they were coming too fast.
 828  */
 829 static void power_pmu_unthrottle(struct perf_event *event)
 830 {
 831         s64 val, left;
 832         unsigned long flags;
 833
 834         if (!event->hw.idx || !event->hw.sample_period)
 835                 return;
 836         local_irq_save(flags);
 837         perf_disable();
 838         power_pmu_read(event);
 839         left = event->hw.sample_period;
 840         event->hw.last_period = left;
 841         val = 0;
 842         if (left < 0x80000000L)
 843                 val = 0x80000000L - left;
 844         write_pmc(event->hw.idx, val);
 845         atomic64_set(&event->hw.prev_count, val);
 846         atomic64_set(&event->hw.period_left, left);
 847         perf_event_update_userpage(event);
 848         perf_enable();
 849         local_irq_restore(flags);
 850 }
 851
 852 /*
 853  * Start group events scheduling transaction
 854  * Set the flag to make pmu::enable() not perform the
 855  * schedulability test, it will be performed at commit time
 856  */
 857 void power_pmu_start_txn(const struct pmu *pmu)
 858 {
 859         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 860
 861         cpuhw->group_flag |= PERF_EVENT_TXN_STARTED;
 862         cpuhw->n_txn_start = cpuhw->n_events;
 863 }
 864
 865 /*
 866  * Stop group events scheduling transaction
 867  * Clear the flag and pmu::enable() will perform the
 868  * schedulability test.
 869  */
 870 void power_pmu_cancel_txn(const struct pmu *pmu)
 871 {
 872         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 873
 874         cpuhw->group_flag &= ~PERF_EVENT_TXN_STARTED;
 875 }
 876
 877 /*
 878  * Commit group events scheduling transaction
 879  * Perform the group schedulability test as a whole
 880  * Return 0 if success
 881  */
 882 int power_pmu_commit_txn(const struct pmu *pmu)
 883 {
 884         struct cpu_hw_events *cpuhw;
 885         long i, n;
 886
 887         if (!ppmu)
 888                 return -EAGAIN;
 889         cpuhw = &__get_cpu_var(cpu_hw_events);
 890         n = cpuhw->n_events;
 891         if (check_excludes(cpuhw->event, cpuhw->flags, 0, n))
 892                 return -EAGAIN;
 893         i = power_check_constraints(cpuhw, cpuhw->events, cpuhw->flags, n);
 894         if (i < 0)
 895                 return -EAGAIN;
 896
 897         for (i = cpuhw->n_txn_start; i < n; ++i)
 898                 cpuhw->event[i]->hw.config = cpuhw->events[i];
 899
 900         return 0;
 901 }
 902
 903 struct pmu power_pmu = {
 904         .enable         = power_pmu_enable,
 905         .disable        = power_pmu_disable,
 906         .read           = power_pmu_read,
 907         .unthrottle     = power_pmu_unthrottle,
 908         .start_txn      = power_pmu_start_txn,
 909         .cancel_txn     = power_pmu_cancel_txn,
 910         .commit_txn     = power_pmu_commit_txn,
 911 };
 912
 913 /*
 914  * Return 1 if we might be able to put event on a limited PMC,
 915  * or 0 if not.
 916  * A event can only go on a limited PMC if it counts something
 917  * that a limited PMC can count, doesn't require interrupts, and
 918  * doesn't exclude any processor mode.
 919  */
 920 static int can_go_on_limited_pmc(struct perf_event *event, u64 ev,
 921                                  unsigned int flags)
 922 {
 923         int n;
 924         u64 alt[MAX_EVENT_ALTERNATIVES];
 925
 926         if (event->attr.exclude_user
 927             || event->attr.exclude_kernel
 928             || event->attr.exclude_hv
 929             || event->attr.sample_period)
 930                 return 0;
 931
 932         if (ppmu->limited_pmc_event(ev))
 933                 return 1;
 934
 935         /*
 936          * The requested event_id isn't on a limited PMC already;
 937          * see if any alternative code goes on a limited PMC.
 938          */
 939         if (!ppmu->get_alternatives)
 940                 return 0;
 941
 942         flags |= PPMU_LIMITED_PMC_OK | PPMU_LIMITED_PMC_REQD;
 943         n = ppmu->get_alternatives(ev, flags, alt);
 944
 945         return n > 0;
 946 }
 947
 948 /*
 949  * Find an alternative event_id that goes on a normal PMC, if possible,
 950  * and return the event_id code, or 0 if there is no such alternative.
 951  * (Note: event_id code 0 is "don't count" on all machines.)
 952  */
 953 static u64 normal_pmc_alternative(u64 ev, unsigned long flags)
 954 {
 955         u64 alt[MAX_EVENT_ALTERNATIVES];
 956         int n;
 957
 958         flags &= ~(PPMU_LIMITED_PMC_OK | PPMU_LIMITED_PMC_REQD);
 959         n = ppmu->get_alternatives(ev, flags, alt);
 960         if (!n)
 961                 return 0;
 962         return alt[0];
 963 }
 964
 965 /* Number of perf_events counting hardware events */
 966 static atomic_t num_events;
 967 /* Used to avoid races in calling reserve/release_pmc_hardware */
 968 static DEFINE_MUTEX(pmc_reserve_mutex);
 969
 970 /*
 971  * Release the PMU if this is the last perf_event.
 972  */
 973 static void hw_perf_event_destroy(struct perf_event *event)
 974 {
 975         if (!atomic_add_unless(&num_events, -1, 1)) {
 976                 mutex_lock(&pmc_reserve_mutex);
 977                 if (atomic_dec_return(&num_events) == 0)
 978                         release_pmc_hardware();
 979                 mutex_unlock(&pmc_reserve_mutex);
 980         }
 981 }
 982
 983 /*
 984  * Translate a generic cache event_id config to a raw event_id code.
 985  */
 986 static int hw_perf_cache_event(u64 config, u64 *eventp)
 987 {
 988         unsigned long type, op, result;
 989         int ev;
 990
 991         if (!ppmu->cache_events)
 992                 return -EINVAL;
 993
 994         /* unpack config */
 995         type = config & 0xff;
 996         op = (config >> 8) & 0xff;
 997         result = (config >> 16) & 0xff;
 998
 999         if (type >= PERF_COUNT_HW_CACHE_MAX ||
1000             op >= PERF_COUNT_HW_CACHE_OP_MAX ||
1001             result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
1002                 return -EINVAL;
1003
1004         ev = (*ppmu->cache_events)[type][op][result];
1005         if (ev == 0)
1006                 return -EOPNOTSUPP;
1007         if (ev == -1)
1008                 return -EINVAL;
1009         *eventp = ev;
1010         return 0;
1011 }
1012
1013 const struct pmu *hw_perf_event_init(struct perf_event *event)
1014 {
1015         u64 ev;
1016         unsigned long flags;
1017         struct perf_event *ctrs[MAX_HWEVENTS];
1018         u64 events[MAX_HWEVENTS];
1019         unsigned int cflags[MAX_HWEVENTS];
1020         int n;
1021         int err;
1022         struct cpu_hw_events *cpuhw;
1023
1024         if (!ppmu)
1025                 return ERR_PTR(-ENXIO);
1026         switch (event->attr.type) {
1027         case PERF_TYPE_HARDWARE:
1028                 ev = event->attr.config;
1029                 if (ev >= ppmu->n_generic || ppmu->generic_events[ev] == 0)
1030                         return ERR_PTR(-EOPNOTSUPP);
1031                 ev = ppmu->generic_events[ev];
1032                 break;
1033         case PERF_TYPE_HW_CACHE:
1034                 err = hw_perf_cache_event(event->attr.config, &ev);
1035                 if (err)
1036                         return ERR_PTR(err);
1037                 break;
1038         case PERF_TYPE_RAW:
1039                 ev = event->attr.config;
1040                 break;
1041         default:
1042                 return ERR_PTR(-EINVAL);
1043         }
1044         event->hw.config_base = ev;
1045         event->hw.idx = 0;
1046
1047         /*
1048          * If we are not running on a hypervisor, force the
1049          * exclude_hv bit to 0 so that we don't care what
1050          * the user set it to.
1051          */
1052         if (!firmware_has_feature(FW_FEATURE_LPAR))
1053                 event->attr.exclude_hv = 0;
1054
1055         /*
1056          * If this is a per-task event, then we can use
1057          * PM_RUN_* events interchangeably with their non RUN_*
1058          * equivalents, e.g. PM_RUN_CYC instead of PM_CYC.
1059          * XXX we should check if the task is an idle task.
1060          */
1061         flags = 0;
1062         if (event->ctx->task)
1063                 flags |= PPMU_ONLY_COUNT_RUN;
1064
1065         /*
1066          * If this machine has limited events, check whether this
1067          * event_id could go on a limited event.
1068          */
1069         if (ppmu->flags & PPMU_LIMITED_PMC5_6) {
1070                 if (can_go_on_limited_pmc(event, ev, flags)) {
1071                         flags |= PPMU_LIMITED_PMC_OK;
1072                 } else if (ppmu->limited_pmc_event(ev)) {
1073                         /*
1074                          * The requested event_id is on a limited PMC,
1075                          * but we can't use a limited PMC; see if any
1076                          * alternative goes on a normal PMC.
1077                          */
1078                         ev = normal_pmc_alternative(ev, flags);
1079                         if (!ev)
1080                                 return ERR_PTR(-EINVAL);
1081                 }
1082         }
1083
1084         /*
1085          * If this is in a group, check if it can go on with all the
1086          * other hardware events in the group.  We assume the event
1087          * hasn't been linked into its leader's sibling list at this point.
1088          */
1089         n = 0;
1090         if (event->group_leader != event) {
1091                 n = collect_events(event->group_leader, ppmu->n_counter - 1,
1092                                    ctrs, events, cflags);
1093                 if (n < 0)
1094                         return ERR_PTR(-EINVAL);
1095         }
1096         events[n] = ev;
1097         ctrs[n] = event;
1098         cflags[n] = flags;
1099         if (check_excludes(ctrs, cflags, n, 1))
1100                 return ERR_PTR(-EINVAL);
1101
1102         cpuhw = &get_cpu_var(cpu_hw_events);
1103         err = power_check_constraints(cpuhw, events, cflags, n + 1);
1104         put_cpu_var(cpu_hw_events);
1105         if (err)
1106                 return ERR_PTR(-EINVAL);
1107
1108         event->hw.config = events[n];
1109         event->hw.event_base = cflags[n];
1110         event->hw.last_period = event->hw.sample_period;
1111         atomic64_set(&event->hw.period_left, event->hw.last_period);
1112
1113         /*
1114          * See if we need to reserve the PMU.
1115          * If no events are currently in use, then we have to take a
1116          * mutex to ensure that we don't race with another task doing
1117          * reserve_pmc_hardware or release_pmc_hardware.
1118          */
1119         err = 0;
1120         if (!atomic_inc_not_zero(&num_events)) {
1121                 mutex_lock(&pmc_reserve_mutex);
1122                 if (atomic_read(&num_events) == 0 &&
1123                     reserve_pmc_hardware(perf_event_interrupt))
1124                         err = -EBUSY;
1125                 else
1126                         atomic_inc(&num_events);
1127                 mutex_unlock(&pmc_reserve_mutex);
1128         }
1129         event->destroy = hw_perf_event_destroy;
1130
1131         if (err)
1132                 return ERR_PTR(err);
1133         return &power_pmu;
1134 }
1135
1136 /*
1137  * A counter has overflowed; update its count and record
1138  * things if requested.  Note that interrupts are hard-disabled
1139  * here so there is no possibility of being interrupted.
1140  */
1141 static void record_and_restart(struct perf_event *event, unsigned long val,
1142                                struct pt_regs *regs, int nmi)
1143 {
1144         u64 period = event->hw.sample_period;
1145         s64 prev, delta, left;
1146         int record = 0;
1147
1148         /* we don't have to worry about interrupts here */
1149         prev = atomic64_read(&event->hw.prev_count);
1150         delta = (val - prev) & 0xfffffffful;
1151         atomic64_add(delta, &event->count);
1152
1153         /*
1154          * See if the total period for this event has expired,
1155          * and update for the next period.
1156          */
1157         val = 0;
1158         left = atomic64_read(&event->hw.period_left) - delta;
1159         if (period) {
1160                 if (left <= 0) {
1161                         left += period;
1162                         if (left <= 0)
1163                                 left = period;
1164                         record = 1;
1165                 }
1166                 if (left < 0x80000000LL)
1167                         val = 0x80000000LL - left;
1168         }
1169
1170         /*
1171          * Finally record data if requested.
1172          */
1173         if (record) {
1174                 struct perf_sample_data data;
1175
1176                 perf_sample_data_init(&data, ~0ULL);
1177                 data.period = event->hw.last_period;
1178
1179                 if (event->attr.sample_type & PERF_SAMPLE_ADDR)
1180                         perf_get_data_addr(regs, &data.addr);
1181
1182                 if (perf_event_overflow(event, nmi, &data, regs)) {
1183                         /*
1184                          * Interrupts are coming too fast - throttle them
1185                          * by setting the event to 0, so it will be
1186                          * at least 2^30 cycles until the next interrupt
1187                          * (assuming each event counts at most 2 counts
1188                          * per cycle).
1189                          */
1190                         val = 0;
1191                         left = ~0ULL >> 1;
1192                 }
1193         }
1194
1195         write_pmc(event->hw.idx, val);
1196         atomic64_set(&event->hw.prev_count, val);
1197         atomic64_set(&event->hw.period_left, left);
1198         perf_event_update_userpage(event);
1199 }
1200
1201 /*
1202  * Called from generic code to get the misc flags (i.e. processor mode)
1203  * for an event_id.
1204  */
1205 unsigned long perf_misc_flags(struct pt_regs *regs)
1206 {
1207         u32 flags = perf_get_misc_flags(regs);
1208
1209         if (flags)
1210                 return flags;
1211         return user_mode(regs) ? PERF_RECORD_MISC_USER :
1212                 PERF_RECORD_MISC_KERNEL;
1213 }
1214
1215 /*
1216  * Called from generic code to get the instruction pointer
1217  * for an event_id.
1218  */
1219 unsigned long perf_instruction_pointer(struct pt_regs *regs)
1220 {
1221         unsigned long ip;
1222
1223         if (TRAP(regs) != 0xf00)
1224                 return regs->nip;       /* not a PMU interrupt */
1225
1226         ip = mfspr(SPRN_SIAR) + perf_ip_adjust(regs);
1227         return ip;
1228 }
1229
1230 /*
1231  * Performance monitor interrupt stuff
1232  */
1233 static void perf_event_interrupt(struct pt_regs *regs)
1234 {
1235         int i;
1236         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
1237         struct perf_event *event;
1238         unsigned long val;
1239         int found = 0;
1240         int nmi;
1241
1242         if (cpuhw->n_limited)
1243                 freeze_limited_counters(cpuhw, mfspr(SPRN_PMC5),
1244                                         mfspr(SPRN_PMC6));
1245
1246         perf_read_regs(regs);
1247
1248         nmi = perf_intr_is_nmi(regs);
1249         if (nmi)
1250                 nmi_enter();
1251         else
1252                 irq_enter();
1253
1254         for (i = 0; i < cpuhw->n_events; ++i) {
1255                 event = cpuhw->event[i];
1256                 if (!event->hw.idx || is_limited_pmc(event->hw.idx))
1257                         continue;
1258                 val = read_pmc(event->hw.idx);
1259                 if ((int)val < 0) {
1260                         /* event has overflowed */
1261                         found = 1;
1262                         record_and_restart(event, val, regs, nmi);
1263                 }
1264         }
1265
1266         /*
1267          * In case we didn't find and reset the event that caused
1268          * the interrupt, scan all events and reset any that are
1269          * negative, to avoid getting continual interrupts.
1270          * Any that we processed in the previous loop will not be negative.
1271          */
1272         if (!found) {
1273                 for (i = 0; i < ppmu->n_counter; ++i) {
1274                         if (is_limited_pmc(i + 1))
1275                                 continue;
1276                         val = read_pmc(i + 1);
1277                         if ((int)val < 0)
1278                                 write_pmc(i + 1, 0);
1279                 }
1280         }
1281
1282         /*
1283          * Reset MMCR0 to its normal value.  This will set PMXE and
1284          * clear FC (freeze counters) and PMAO (perf mon alert occurred)
1285          * and thus allow interrupts to occur again.
1286          * XXX might want to use MSR.PM to keep the events frozen until
1287          * we get back out of this interrupt.
1288          */
1289         write_mmcr0(cpuhw, cpuhw->mmcr[0]);
1290
1291         if (nmi)
1292                 nmi_exit();
1293         else
1294                 irq_exit();
1295 }
1296
1297 static void power_pmu_setup(int cpu)
1298 {
1299         struct cpu_hw_events *cpuhw = &per_cpu(cpu_hw_events, cpu);
1300
1301         if (!ppmu)
1302                 return;
1303         memset(cpuhw, 0, sizeof(*cpuhw));
1304         cpuhw->mmcr[0] = MMCR0_FC;
1305 }
1306
1307 static int __cpuinit
1308 power_pmu_notifier(struct notifier_block *self, unsigned long action, void *hcpu)
1309 {
1310         unsigned int cpu = (long)hcpu;
1311
1312         switch (action & ~CPU_TASKS_FROZEN) {
1313         case CPU_UP_PREPARE:
1314                 power_pmu_setup(cpu);
1315                 break;
1316
1317         default:
1318                 break;
1319         }
1320
1321         return NOTIFY_OK;
1322 }
1323
1324 int register_power_pmu(struct power_pmu *pmu)
1325 {
1326         if (ppmu)
1327                 return -EBUSY;          /* something's already registered */
1328
1329         ppmu = pmu;
1330         pr_info("%s performance monitor hardware support registered\n",
1331                 pmu->name);
1332
1333 #ifdef MSR_HV
1334         /*
1335          * Use FCHV to ignore kernel events if MSR.HV is set.
1336          */
1337         if (mfmsr() & MSR_HV)
1338                 freeze_events_kernel = MMCR0_FCHV;
1339 #endif /* CONFIG_PPC64 */
1340
1341         perf_cpu_notifier(power_pmu_notifier);
1342
1343         return 0;
1344 }