perf, x86: Undo some some *_counter* -> *_event* renames

The big rename:

 cdd6c48 perf: Do the big rename: Performance Counters -> Performance Events

accidentally renamed some members of stucts that were named after
registers in the spec. To avoid confusion this patch reverts some
changes. The related specs are MSR descriptions in AMD's BKDGs and the
ARCHITECTURAL PERFORMANCE MONITORING section in the Intel 64 and IA-32
Architectures Software Developer's Manuals.

This patch does:

 $ sed -i -e 's:num_events:num_counters:g' \
   arch/x86/include/asm/perf_event.h \
   arch/x86/kernel/cpu/perf_event_amd.c \
   arch/x86/kernel/cpu/perf_event.c \
   arch/x86/kernel/cpu/perf_event_intel.c \
   arch/x86/kernel/cpu/perf_event_p6.c \
   arch/x86/kernel/cpu/perf_event_p4.c \
   arch/x86/oprofile/op_model_ppro.c

 $ sed -i -e 's:event_bits:cntval_bits:g' -e 's:event_mask:cntval_mask:g' \
   arch/x86/kernel/cpu/perf_event_amd.c \
   arch/x86/kernel/cpu/perf_event.c \
   arch/x86/kernel/cpu/perf_event_intel.c \
   arch/x86/kernel/cpu/perf_event_p6.c \
   arch/x86/kernel/cpu/perf_event_p4.c

Signed-off-by: Robert Richter <robert.richter@amd.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <1269880612-25800-2-git-send-email-robert.richter@amd.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 37 insertions, 37 deletions

diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
index b5343566181..9daaa1ef504 100644
--- a/arch/x86/kernel/cpu/perf_event.c
+++ b/arch/x86/kernel/cpu/perf_event.c
@@ -195,10 +195,10 @@ struct x86_pmu {
         u64             (*event_map)(int);
         u64             (*raw_event)(u64);
         int             max_events;
-        int             num_events;
-        int             num_events_fixed;
-        int             event_bits;
-        u64             event_mask;
+        int             num_counters;
+        int             num_counters_fixed;
+        int             cntval_bits;
+        u64             cntval_mask;
         int             apic;
         u64             max_period;
         struct event_constraint *
@@ -268,7 +268,7 @@ static u64
 x86_perf_event_update(struct perf_event *event)
 {
         struct hw_perf_event *hwc = &event->hw;
-        int shift = 64 - x86_pmu.event_bits;
+        int shift = 64 - x86_pmu.cntval_bits;
         u64 prev_raw_count, new_raw_count;
         int idx = hwc->idx;
         s64 delta;
@@ -320,12 +320,12 @@ static bool reserve_pmc_hardware(void)
         if (nmi_watchdog == NMI_LOCAL_APIC)
                 disable_lapic_nmi_watchdog();
 
-        for (i = 0; i < x86_pmu.num_events; i++) {
+        for (i = 0; i < x86_pmu.num_counters; i++) {
                 if (!reserve_perfctr_nmi(x86_pmu.perfctr + i))
                         goto perfctr_fail;
         }
 
-        for (i = 0; i < x86_pmu.num_events; i++) {
+        for (i = 0; i < x86_pmu.num_counters; i++) {
                 if (!reserve_evntsel_nmi(x86_pmu.eventsel + i))
                         goto eventsel_fail;
         }
@@ -336,7 +336,7 @@ eventsel_fail:
         for (i--; i >= 0; i--)
                 release_evntsel_nmi(x86_pmu.eventsel + i);
 
-        i = x86_pmu.num_events;
+        i = x86_pmu.num_counters;
 
 perfctr_fail:
         for (i--; i >= 0; i--)
@@ -352,7 +352,7 @@ static void release_pmc_hardware(void)
 {
         int i;
 
-        for (i = 0; i < x86_pmu.num_events; i++) {
+        for (i = 0; i < x86_pmu.num_counters; i++) {
                 release_perfctr_nmi(x86_pmu.perfctr + i);
                 release_evntsel_nmi(x86_pmu.eventsel + i);
         }
@@ -547,7 +547,7 @@ static void x86_pmu_disable_all(void)
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         int idx;
 
-        for (idx = 0; idx < x86_pmu.num_events; idx++) {
+        for (idx = 0; idx < x86_pmu.num_counters; idx++) {
                 u64 val;
 
                 if (!test_bit(idx, cpuc->active_mask))
@@ -582,7 +582,7 @@ static void x86_pmu_enable_all(int added)
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         int idx;
 
-        for (idx = 0; idx < x86_pmu.num_events; idx++) {
+        for (idx = 0; idx < x86_pmu.num_counters; idx++) {
                 struct perf_event *event = cpuc->events[idx];
                 u64 val;
 
@@ -657,14 +657,14 @@ static int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign)
          * assign events to counters starting with most
          * constrained events.
          */
-        wmax = x86_pmu.num_events;
+        wmax = x86_pmu.num_counters;
 
         /*
          * when fixed event counters are present,
          * wmax is incremented by 1 to account
          * for one more choice
          */
-        if (x86_pmu.num_events_fixed)
+        if (x86_pmu.num_counters_fixed)
                 wmax++;
 
         for (w = 1, num = n; num && w <= wmax; w++) {
@@ -714,7 +714,7 @@ static int collect_events(struct cpu_hw_events *cpuc, struct perf_event *leader,
         struct perf_event *event;
         int n, max_count;
 
-        max_count = x86_pmu.num_events + x86_pmu.num_events_fixed;
+        max_count = x86_pmu.num_counters + x86_pmu.num_counters_fixed;
 
         /* current number of events already accepted */
         n = cpuc->n_events;
@@ -904,7 +904,7 @@ x86_perf_event_set_period(struct perf_event *event)
         atomic64_set(&hwc->prev_count, (u64)-left);
 
         wrmsrl(hwc->event_base + idx,
-                        (u64)(-left) & x86_pmu.event_mask);
+                        (u64)(-left) & x86_pmu.cntval_mask);
 
         perf_event_update_userpage(event);
 
@@ -987,7 +987,7 @@ void perf_event_print_debug(void)
         unsigned long flags;
         int cpu, idx;
 
-        if (!x86_pmu.num_events)
+        if (!x86_pmu.num_counters)
                 return;
 
         local_irq_save(flags);
@@ -1011,7 +1011,7 @@ void perf_event_print_debug(void)
         }
         pr_info("CPU#%d: active:     %016llx\n", cpu, *(u64 *)cpuc->active_mask);
 
-        for (idx = 0; idx < x86_pmu.num_events; idx++) {
+        for (idx = 0; idx < x86_pmu.num_counters; idx++) {
                 rdmsrl(x86_pmu.eventsel + idx, pmc_ctrl);
                 rdmsrl(x86_pmu.perfctr  + idx, pmc_count);
 
@@ -1024,7 +1024,7 @@ void perf_event_print_debug(void)
                 pr_info("CPU#%d:   gen-PMC%d left:  %016llx\n",
                         cpu, idx, prev_left);
         }
-        for (idx = 0; idx < x86_pmu.num_events_fixed; idx++) {
+        for (idx = 0; idx < x86_pmu.num_counters_fixed; idx++) {
                 rdmsrl(MSR_ARCH_PERFMON_FIXED_CTR0 + idx, pmc_count);
 
                 pr_info("CPU#%d: fixed-PMC%d count: %016llx\n",
@@ -1089,7 +1089,7 @@ static int x86_pmu_handle_irq(struct pt_regs *regs)
 
         cpuc = &__get_cpu_var(cpu_hw_events);
 
-        for (idx = 0; idx < x86_pmu.num_events; idx++) {
+        for (idx = 0; idx < x86_pmu.num_counters; idx++) {
                 if (!test_bit(idx, cpuc->active_mask))
                         continue;
 
@@ -1097,7 +1097,7 @@ static int x86_pmu_handle_irq(struct pt_regs *regs)
                 hwc = &event->hw;
 
                 val = x86_perf_event_update(event);
-                if (val & (1ULL << (x86_pmu.event_bits - 1)))
+                if (val & (1ULL << (x86_pmu.cntval_bits - 1)))
                         continue;
 
                 /*
@@ -1401,46 +1401,46 @@ void __init init_hw_perf_events(void)
         if (x86_pmu.quirks)
                 x86_pmu.quirks();
 
-        if (x86_pmu.num_events > X86_PMC_MAX_GENERIC) {
+        if (x86_pmu.num_counters > X86_PMC_MAX_GENERIC) {
                 WARN(1, KERN_ERR "hw perf events %d > max(%d), clipping!",
-                     x86_pmu.num_events, X86_PMC_MAX_GENERIC);
-                x86_pmu.num_events = X86_PMC_MAX_GENERIC;
+                     x86_pmu.num_counters, X86_PMC_MAX_GENERIC);
+                x86_pmu.num_counters = X86_PMC_MAX_GENERIC;
         }
-        x86_pmu.intel_ctrl = (1 << x86_pmu.num_events) - 1;
-        perf_max_events = x86_pmu.num_events;
+        x86_pmu.intel_ctrl = (1 << x86_pmu.num_counters) - 1;
+        perf_max_events = x86_pmu.num_counters;
 
-        if (x86_pmu.num_events_fixed > X86_PMC_MAX_FIXED) {
+        if (x86_pmu.num_counters_fixed > X86_PMC_MAX_FIXED) {
                 WARN(1, KERN_ERR "hw perf events fixed %d > max(%d), clipping!",
-                     x86_pmu.num_events_fixed, X86_PMC_MAX_FIXED);
-                x86_pmu.num_events_fixed = X86_PMC_MAX_FIXED;
+                     x86_pmu.num_counters_fixed, X86_PMC_MAX_FIXED);
+                x86_pmu.num_counters_fixed = X86_PMC_MAX_FIXED;
         }
 
         x86_pmu.intel_ctrl |=
-                ((1LL << x86_pmu.num_events_fixed)-1) << X86_PMC_IDX_FIXED;
+                ((1LL << x86_pmu.num_counters_fixed)-1) << X86_PMC_IDX_FIXED;
 
         perf_events_lapic_init();
         register_die_notifier(&perf_event_nmi_notifier);
 
         unconstrained = (struct event_constraint)
-                __EVENT_CONSTRAINT(0, (1ULL << x86_pmu.num_events) - 1,
-                                   0, x86_pmu.num_events);
+                __EVENT_CONSTRAINT(0, (1ULL << x86_pmu.num_counters) - 1,
+                                   0, x86_pmu.num_counters);
 
         if (x86_pmu.event_constraints) {
                 for_each_event_constraint(c, x86_pmu.event_constraints) {
                         if (c->cmask != INTEL_ARCH_FIXED_MASK)
                                 continue;
 
-                        c->idxmsk64 |= (1ULL << x86_pmu.num_events) - 1;
-                        c->weight += x86_pmu.num_events;
+                        c->idxmsk64 |= (1ULL << x86_pmu.num_counters) - 1;
+                        c->weight += x86_pmu.num_counters;
                 }
         }
 
         pr_info("... version:                %d\n",     x86_pmu.version);
-        pr_info("... bit width:              %d\n",     x86_pmu.event_bits);
-        pr_info("... generic registers:      %d\n",     x86_pmu.num_events);
-        pr_info("... value mask:             %016Lx\n", x86_pmu.event_mask);
+        pr_info("... bit width:              %d\n",     x86_pmu.cntval_bits);
+        pr_info("... generic registers:      %d\n",     x86_pmu.num_counters);
+        pr_info("... value mask:             %016Lx\n", x86_pmu.cntval_mask);
         pr_info("... max period:             %016Lx\n", x86_pmu.max_period);
-        pr_info("... fixed-purpose events:   %d\n",     x86_pmu.num_events_fixed);
+        pr_info("... fixed-purpose events:   %d\n",     x86_pmu.num_counters_fixed);
         pr_info("... event mask:             %016Lx\n", x86_pmu.intel_ctrl);
 
         perf_cpu_notifier(x86_pmu_notifier);