ARM: oprofile: use perf-events framework as backend
Subsystems (3)
cover ARM: oprofile: use perf-events framework as backend
There are currently two hardware performance monitoring subsystems in the kernel for ARM: OProfile and perf-events. This creates the following problems:
1.) Duplicate PMU accessor code. Inevitable code drift may lead to bugs in one framework that are fixed in the other.
2.) Locking issues. OProfile doesn't reprogram hardware counters between profiling runs if the events to be monitored have not been changed. This means that other profiling frameworks cannot use the counters if OProfile is in use.
3.) Due to differences in the two frameworks, it may not be possible to compare the results obtained by OProfile with those obtained by perf.
This patch series removes the OProfile PMU driver code and replaces it with calls to perf, therefore resolving the issues mentioned above. To preserve compatibility with existing OProfile tools, drivers for XScale v1 and v2 PMUs are added to the perf backend.
The only userspace-visible change is the lack of SCU counter support for 11MPCore. This is currently unsupported by OProfile userspace tools anyway and therefore shouldn't cause any problems.
Tested on dual-core A9MP [Realview PBX], quad-core 11MPCore [Realview PB11MP] and XScale PXA270 [Gumstix Verdex XL6P].
Patch taken against 2.6.33 + perf-events patches in Russell's branch:
ARM: 5890/1: Fix incorrect Realview board IRQs for L220 and PMU
ARM: 5899/2: arm: provide a mechanism to reserve performance counters
ARM: 5901/2: arm/oprofile: reserve the PMU when starting
ARM: 5900/2: arm: enable support for software perf events
ARM: 5902/4: arm/perfevents: implement perf event support for ARMv6
ARM: 5903/1: arm/perfevents: add support for ARMv7
Will Deacon (6):
ARM: perf-events: add Realview PMU IRQs to pmu.c
ARM: perf-events: use numeric ID to identify PMU
ARM: perf-events: add support for xscale PMUs
perf-events: export enable/disable event symbols to kernel modules
ARM: oprofile: use perf-events framework as backend
ARM: oprofile: remove old files and update KConfig
arch/arm/Kconfig | 26 +- arch/arm/include/asm/perf_event.h | 12 + arch/arm/kernel/perf_event.c | 862 ++++++++++++++++++++++++++++++- arch/arm/kernel/pmu.c | 14 + arch/arm/oprofile/Makefile | 7 +- arch/arm/oprofile/backtrace.c | 83 --- arch/arm/oprofile/common.c | 356 +++++++++++-- arch/arm/oprofile/op_arm_model.h | 35 -- arch/arm/oprofile/op_counter.h | 27 - arch/arm/oprofile/op_model_arm11_core.c | 162 ------ arch/arm/oprofile/op_model_arm11_core.h | 45 -- arch/arm/oprofile/op_model_mpcore.c | 306 ----------- arch/arm/oprofile/op_model_mpcore.h | 61 --- arch/arm/oprofile/op_model_v6.c | 78 --- arch/arm/oprofile/op_model_v7.c | 415 --------------- arch/arm/oprofile/op_model_v7.h | 103 ---- arch/arm/oprofile/op_model_xscale.c | 444 ---------------- include/linux/perf_event.h | 1 + kernel/perf_event.c | 8 + 19 files changed, 1192 insertions(+), 1853 deletions(-) delete mode 100644 arch/arm/oprofile/backtrace.c delete mode 100644 arch/arm/oprofile/op_arm_model.h delete mode 100644 arch/arm/oprofile/op_counter.h delete mode 100644 arch/arm/oprofile/op_model_arm11_core.c delete mode 100644 arch/arm/oprofile/op_model_arm11_core.h delete mode 100644 arch/arm/oprofile/op_model_mpcore.c delete mode 100644 arch/arm/oprofile/op_model_mpcore.h delete mode 100644 arch/arm/oprofile/op_model_v6.c delete mode 100644 arch/arm/oprofile/op_model_v7.c delete mode 100644 arch/arm/oprofile/op_model_v7.h delete mode 100644 arch/arm/oprofile/op_model_xscale.c
PATCH 1/6 ARM: perf-events: add Realview PMU IRQs to pmu.c
Add the PMU IRQs for the Realview boards to kernel/pmu.c so that they can be used by the perf-events framework.
--- arch/arm/kernel/pmu.c | 14 ++++++++++++++ 1 files changed, 14 insertions(+), 0 deletions(-)
arch/arm/kernel/pmu.c +14 -0
@@ -36,6 +36,20 @@ static const int irqs[] = { IRQ_EB11MP_PMU_CPU1, IRQ_EB11MP_PMU_CPU2, IRQ_EB11MP_PMU_CPU3, +#elif defined(CONFIG_MACH_REALVIEW_PB1176) + IRQ_DC1176_CORE_PMU, +#elif defined(CONFIG_MACH_REALVIEW_PB11MP ) + IRQ_TC11MP_PMU_CPU0, + IRQ_TC11MP_PMU_CPU1, + IRQ_TC11MP_PMU_CPU2, + IRQ_TC11MP_PMU_CPU3, +#elif defined(CONFIG_MACH_REALVIEW_PBA8) + IRQ_PBA8_PMU, +#elif defined(CONFIG_MACH_REALVIEW_PBX ) + IRQ_PBX_PMU_CPU0, + IRQ_PBX_PMU_CPU1, + IRQ_PBX_PMU_CPU2, + IRQ_PBX_PMU_CPU3, #elif defined(CONFIG_ARCH_OMAP3) INT_34XX_BENCH_MPU_EMUL,#elif defined(CONFIG_ARCH_IOP32X )
Signature · 1 line
1.6.3.3
PATCH 2/6 ARM: perf-events: use numeric ID to identify PMU
The ARM perf-events framework provides support for a number of different PMUs using struct arm_pmu. The char *name field of this struct can be used to identify the PMU, but this is cumbersome if used outside of perf.
This patch replaces the name string for a PMU with an int, which holds a unique ID for the PMU being represented. This ID can be used to index an array of names within perf, so no functionality is lost. The presence of the ID field, allows other kernel subsystems [currently oprofile] to use their own mappings for the PMU name.
--- arch/arm/include/asm/perf_event.h | 12 +++++++++++ arch/arm/kernel/perf_event.c | 39 +++++++++++++++++++++++++++--------- 2 files changed, 41 insertions(+), 10 deletions(-)
arch/arm/include/asm/perf_event.h +12 -0
@@ -28,4 +28,16 @@ set_perf_event_pending(void)* same indexes here for consistency. */ #define PERF_EVENT_INDEX_OFFSET 1 +/* ARM perf PMU IDs for use by internal perf clients. */ +#define ARM_PERF_PMU_ID_XSCALE1 0 +#define ARM_PERF_PMU_ID_XSCALE2 (ARM_PERF_PMU_ID_XSCALE1 + 1) +#define ARM_PERF_PMU_ID_V6 (ARM_PERF_PMU_ID_XSCALE2 + 1) +#define ARM_PERF_PMU_ID_V6MP (ARM_PERF_PMU_ID_V6 + 1) +#define ARM_PERF_PMU_ID_CA8 (ARM_PERF_PMU_ID_V6MP + 1) +#define ARM_PERF_PMU_ID_CA9 (ARM_PERF_PMU_ID_CA8 + 1) +#define ARM_NUM_PMU_IDS (ARM_PERF_PMU_ID_CA9 + 1) + +extern int +armpmu_get_pmu_id (void ); +#endif /* __ARM_PERF_EVENT_H__ */
arch/arm/kernel/perf_event.c +29 -10
@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/perf_event.h> #include <linux/spinlock.h> #include <linux/uaccess.h>
@@ -67,8 +68,18 @@ struct cpu_hw_events { }; DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events); +/* PMU names. */ +static const char *arm_pmu_names[ARM_NUM_PMU_IDS ] = { +"xscale1" , +"xscale2" , +"v6" , +"v6mpcore" , +"ARMv7 Cortex-A8" , +"ARMv7 Cortex-A9" , +}; +struct arm_pmu { -char *name; +int id;irqreturn_t (*handle_irq)(int irq_num,void *dev);void (*enable)(struct hw_perf_event *evt,int idx);void (*disable)(struct hw_perf_event *evt,int idx);
@@ -87,6 +98,18 @@ struct arm_pmu {/* Set at runtime when we know what CPU type we are. */ static const struct arm_pmu *armpmu; +int +armpmu_get_pmu_id (void ) +{ +int id = -ENODEV ; + +if (armpmu !=NULL ) + id = armpmu->id; + +return id; +} +EXPORT_SYMBOL_GPL (armpmu_get_pmu_id); +#define HW_OP_UNSUPPORTED 0xFFFF#define C (_x) \
@@ -1143,7 +1166,7 @@ armv6mpcore_pmu_disable_event(struct hw_perf_event *hwc, }static const struct arm_pmu armv6pmu = { - .name ="v6" , + .id =ARM_PERF_PMU_ID_V6 , .handle_irq = armv6pmu_handle_irq, .enable = armv6pmu_enable_event, .disable = armv6pmu_disable_event,
@@ -1166,7 +1189,7 @@ static const struct arm_pmu armv6pmu = {* reset the period and enable the interrupt reporting. */ static const struct arm_pmu armv6mpcore_pmu = { - .name ="v6mpcore" , + .id =ARM_PERF_PMU_ID_V6MP , .handle_irq = armv6pmu_handle_irq, .enable = armv6pmu_enable_event, .disable = armv6mpcore_pmu_disable_event,
@@ -1196,10 +1219,6 @@ static const struct arm_pmu armv6mpcore_pmu = {* counter and all 4 performance counters together can be reset separately. */ -#define ARMV7_PMU_CORTEX_A8_NAME "ARMv7 Cortex-A8" - -#define ARMV7_PMU_CORTEX_A9_NAME "ARMv7 Cortex-A9" -/* Common ARMv7 event types */ enum armv7_perf_types {ARMV7_PERFCTR_PMNC_SW_INCR =0x00 ,
@@ -2104,7 +2123,7 @@ init_hw_perf_events(void) perf_max_events = armv6mpcore_pmu.num_events;break ;case 0xC080 :/* Cortex-A8 */ - armv7pmu.name =ARMV7_PMU_CORTEX_A8_NAME ; + armv7pmu.id =ARM_PERF_PMU_ID_CA8 ;memcpy (armpmu_perf_cache_map, armv7_a8_perf_cache_map,sizeof (armv7_a8_perf_cache_map)); armv7pmu.event_map = armv7_a8_pmu_event_map;
@@ -2116,7 +2135,7 @@ init_hw_perf_events(void) perf_max_events = armv7pmu.num_events;break ;case 0xC090 :/* Cortex-A9 */ - armv7pmu.name =ARMV7_PMU_CORTEX_A9_NAME ; + armv7pmu.id =ARM_PERF_PMU_ID_CA9 ;memcpy (armpmu_perf_cache_map, armv7_a9_perf_cache_map,sizeof (armv7_a9_perf_cache_map)); armv7pmu.event_map = armv7_a9_pmu_event_map;
@@ -2135,7 +2154,7 @@ init_hw_perf_events(void)if (armpmu)pr_info ("enabled with %s PMU driver, %d counters available\n" , - armpmu->name, armpmu->num_events); + arm_pmu_names[armpmu->id], armpmu->num_events);return 0 ; }
Signature · 1 line
1.6.3.3
PATCH 3/6 ARM: perf-events: add support for xscale PMUs
The perf-events framework for ARM only supports v6 and v7 cores.
This patch adds support for xscale v1 and v2 PMUs to perf, based on the OProfile drivers in arch/arm/oprofile/op_model_xscale.c
--- arch/arm/kernel/perf_event.c | 825 +++++++++++++++++++++++++++++++++++++++++- 1 files changed, 819 insertions(+), 6 deletions(-)
arch/arm/kernel/perf_event.c +819 -6
@@ -2097,6 +2097,801 @@ static u32 __init armv7_reset_read_pmnc(void)return nb_cnt +1 ; } +/* +* ARMv5 [xscale] Performance counter handling code. +* +* Based on xscale OProfile code. +* +* There are two variants of the xscale PMU that we support: +* - xscale1pmu: 2 event counters and a cycle counter +* - xscale2pmu: 4 event counters and a cycle counter +* The two variants share event definitions, but have different +* PMU structures. +*/ + +enum xscale_perf_types { +XSCALE_PERFCTR_ICACHE_MISS =0x00 , +XSCALE_PERFCTR_ICACHE_NO_DELIVER =0x01 , +XSCALE_PERFCTR_DATA_STALL =0x02 , +XSCALE_PERFCTR_ITLB_MISS =0x03 , +XSCALE_PERFCTR_DTLB_MISS =0x04 , +XSCALE_PERFCTR_BRANCH =0x05 , +XSCALE_PERFCTR_BRANCH_MISS =0x06 , +XSCALE_PERFCTR_INSTRUCTION =0x07 , +XSCALE_PERFCTR_DCACHE_FULL_STALL =0x08 , +XSCALE_PERFCTR_DCACHE_FULL_STALL_CONTIG =0x09 , +XSCALE_PERFCTR_DCACHE_ACCESS =0x0A , +XSCALE_PERFCTR_DCACHE_MISS =0x0B , +XSCALE_PERFCTR_DCACE_WRITE_BACK =0x0C , +XSCALE_PERFCTR_PC_CHANGED =0x0D , +XSCALE_PERFCTR_BCU_REQUEST =0x10 , +XSCALE_PERFCTR_BCU_FULL =0x11 , +XSCALE_PERFCTR_BCU_DRAIN =0x12 , +XSCALE_PERFCTR_BCU_ECC_NO_ELOG =0x14 , +XSCALE_PERFCTR_BCU_1_BIT_ERR =0x15 , +XSCALE_PERFCTR_RMW =0x16 , +/* XSCALE_PERFCTR_CCNT is not hardware defined */ +XSCALE_PERFCTR_CCNT =0xFE , +XSCALE_PERFCTR_UNUSED =0xFF , +}; + +enum xscale_counters { +XSCALE_CYCLE_COUNTER =1 , +XSCALE_COUNTER0 , +XSCALE_COUNTER1 , +XSCALE_COUNTER2 , +XSCALE_COUNTER3 , +}; + +static const unsigned xscale_perf_map[PERF_COUNT_HW_MAX ] = { + [PERF_COUNT_HW_CPU_CYCLES ] =XSCALE_PERFCTR_CCNT , + [PERF_COUNT_HW_INSTRUCTIONS ] =XSCALE_PERFCTR_INSTRUCTION , + [PERF_COUNT_HW_CACHE_REFERENCES ] =HW_OP_UNSUPPORTED , + [PERF_COUNT_HW_CACHE_MISSES ] =HW_OP_UNSUPPORTED , + [PERF_COUNT_HW_BRANCH_INSTRUCTIONS ] =XSCALE_PERFCTR_BRANCH , + [PERF_COUNT_HW_BRANCH_MISSES ] =XSCALE_PERFCTR_BRANCH_MISS , + [PERF_COUNT_HW_BUS_CYCLES ] =HW_OP_UNSUPPORTED , +}; + +static const unsigned xscale_perf_cache_map[PERF_COUNT_HW_CACHE_MAX ] + [PERF_COUNT_HW_CACHE_OP_MAX ] + [PERF_COUNT_HW_CACHE_RESULT_MAX ] = { + [C (L1D )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =XSCALE_PERFCTR_DCACHE_ACCESS , + [C (RESULT_MISS )] =XSCALE_PERFCTR_DCACHE_MISS , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =XSCALE_PERFCTR_DCACHE_ACCESS , + [C (RESULT_MISS )] =XSCALE_PERFCTR_DCACHE_MISS , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, + [C (L1I )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_ICACHE_MISS , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_ICACHE_MISS , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, + [C (LL )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, + [C (DTLB )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_DTLB_MISS , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_DTLB_MISS , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, + [C (ITLB )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_ITLB_MISS , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =XSCALE_PERFCTR_ITLB_MISS , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, + [C (BPU )] = { + [C (OP_READ )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + [C (OP_WRITE )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + [C (OP_PREFETCH )] = { + [C (RESULT_ACCESS )] =CACHE_OP_UNSUPPORTED , + [C (RESULT_MISS )] =CACHE_OP_UNSUPPORTED , + }, + }, +}; + +#define XSCALE_PMU_ENABLE 0x001 +#define XSCALE_PMN_RESET 0x002 +#define XSCALE_CCNT_RESET 0x004 +#define XSCALE_PMU_RESET (CCNT_RESET | PMN_RESET) +#define XSCALE_PMU_CNT64 0x008 + +static inline int +xscalepmu_event_map (int config) +{ +int mapping = xscale_perf_map[config]; +if (HW_OP_UNSUPPORTED == mapping) + mapping = -EOPNOTSUPP ; +return mapping; +} + +static u64 +xscalepmu_raw_event (u64 config) +{ +return config &0xff ; +} + +#define XSCALE1_OVERFLOWED_MASK 0x700 +#define XSCALE1_CCOUNT_OVERFLOW 0x400 +#define XSCALE1_COUNT0_OVERFLOW 0x100 +#define XSCALE1_COUNT1_OVERFLOW 0x200 +#define XSCALE1_CCOUNT_INT_EN 0x040 +#define XSCALE1_COUNT0_INT_EN 0x010 +#define XSCALE1_COUNT1_INT_EN 0x020 +#define XSCALE1_COUNT0_EVT_SHFT 12 +#define XSCALE1_COUNT0_EVT_MASK (0xff << XSCALE1_COUNT0_EVT_SHFT) +#define XSCALE1_COUNT1_EVT_SHFT 20 +#define XSCALE1_COUNT1_EVT_MASK (0xff << XSCALE1_COUNT1_EVT_SHFT) + +static inline u32 +xscale1pmu_read_pmnc (void ) +{ +u32 val; + asmvolatile ("mrc p14, 0, %0, c0, c0, 0" :"=r" (val)); +return val; +} + +static inline void +xscale1pmu_write_pmnc (u32 val) +{ +/* upper 4bits and 7, 11 are write-as-0 */ + val &=0xffff77f ; + asmvolatile ("mcr p14, 0, %0, c0, c0, 0" : :"r" (val)); +} + +static inline int +xscale1_pmnc_counter_has_overflowed (unsigned long pmnc, +enum xscale_counters counter) +{ +int ret =0 ; + +switch (counter) { +case XSCALE_CYCLE_COUNTER : + ret = pmnc &XSCALE1_CCOUNT_OVERFLOW ; +break ; +case XSCALE_COUNTER0 : + ret = pmnc &XSCALE1_COUNT0_OVERFLOW ; +break ; +case XSCALE_COUNTER1 : + ret = pmnc &XSCALE1_COUNT1_OVERFLOW ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , counter); + } + +return ret; +} + +static irqreturn_t +xscale1pmu_handle_irq (int irq_num,void *dev) +{ +unsigned long pmnc; +struct perf_sample_data data; +struct cpu_hw_events *cpuc; +struct pt_regs *regs; +int idx; + +/* +* NOTE: there's an A stepping erratum that states if an overflow +* bit already exists and another occurs, the previous +* Overflow bit gets cleared. There's no workaround. +* Fixed in B stepping or later. +*/ + pmnc =xscale1pmu_read_pmnc (); + +/* +* Write the value back to clear the overflow flags. Overflow +* flags remain in pmnc for use below. We also disable the PMU +* while we process the interrupt. +*/ +xscale1pmu_write_pmnc (pmnc & ~XSCALE_PMU_ENABLE ); + +if (!(pmnc &XSCALE1_OVERFLOWED_MASK )) +return IRQ_NONE ; + + regs =get_irq_regs (); + data.addr =0 ; + + cpuc = &__get_cpu_var (cpu_hw_events); +for (idx =0 ; idx <= armpmu->num_events; ++idx) { +struct perf_event *event = cpuc->events[idx]; +struct hw_perf_event *hwc; + +if (!test_bit (idx, cpuc->active_mask)) +continue ; + +if (!xscale1_pmnc_counter_has_overflowed (pmnc, idx)) +continue ; + + hwc = &event->hw; +armpmu_event_update (event, hwc, idx); + data.period = event->hw.last_period; +if (!armpmu_event_set_period (event, hwc, idx)) +continue ; + +if (perf_event_overflow (event,0 , &data, regs)) + armpmu->disable (hwc, idx); + } + +perf_event_do_pending (); + +/* +* Re-enable the PMU. +*/ + pmnc =xscale1pmu_read_pmnc () |XSCALE_PMU_ENABLE ; +xscale1pmu_write_pmnc (pmnc); + +return IRQ_HANDLED ; +} + +static void +xscale1pmu_enable_event (struct hw_perf_event *hwc,int idx) +{ +unsigned long val, mask, evt, flags; + +switch (idx) { +case XSCALE_CYCLE_COUNTER : + mask =0 ; + evt =XSCALE1_CCOUNT_INT_EN ; +break ; +case XSCALE_COUNTER0 : + mask =XSCALE1_COUNT0_EVT_MASK ; + evt = (hwc->config_base <<XSCALE1_COUNT0_EVT_SHFT ) | +XSCALE1_COUNT0_INT_EN ; +break ; +case XSCALE_COUNTER1 : + mask =XSCALE1_COUNT1_EVT_MASK ; + evt = (hwc->config_base <<XSCALE1_COUNT1_EVT_SHFT ) | +XSCALE1_COUNT1_INT_EN ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , idx); +return ; + } + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale1pmu_read_pmnc (); + val &= ~mask; + val |= evt; +xscale1pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static void +xscale1pmu_disable_event (struct hw_perf_event *hwc,int idx) +{ +unsigned long val, mask, evt, flags; + +switch (idx) { +case XSCALE_CYCLE_COUNTER : + mask =XSCALE1_CCOUNT_INT_EN ; + evt =0 ; +break ; +case XSCALE_COUNTER0 : + mask =XSCALE1_COUNT0_INT_EN |XSCALE1_COUNT0_EVT_MASK ; + evt =XSCALE_PERFCTR_UNUSED <<XSCALE1_COUNT0_EVT_SHFT ; +break ; +case XSCALE_COUNTER1 : + mask =XSCALE1_COUNT1_INT_EN |XSCALE1_COUNT1_EVT_MASK ; + evt =XSCALE_PERFCTR_UNUSED <<XSCALE1_COUNT1_EVT_SHFT ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , idx); +return ; + } + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale1pmu_read_pmnc (); + val &= ~mask; + val |= evt; +xscale1pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static int +xscale1pmu_get_event_idx (struct cpu_hw_events *cpuc, +struct hw_perf_event *event) +{ +if (XSCALE_PERFCTR_CCNT == event->config_base) { +if (test_and_set_bit (XSCALE_CYCLE_COUNTER , cpuc->used_mask)) +return -EAGAIN ; + +return XSCALE_CYCLE_COUNTER ; + }else { +if (!test_and_set_bit (XSCALE_COUNTER1 , cpuc->used_mask)) { +return XSCALE_COUNTER1 ; + } + +if (!test_and_set_bit (XSCALE_COUNTER0 , cpuc->used_mask)) { +return XSCALE_COUNTER0 ; + } + +return -EAGAIN ; + } +} + +static void +xscale1pmu_start (void ) +{ +unsigned long flags, val; + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale1pmu_read_pmnc (); + val |=XSCALE_PMU_ENABLE ; +xscale1pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static void +xscale1pmu_stop (void ) +{ +unsigned long flags, val; + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale1pmu_read_pmnc (); + val &= ~XSCALE_PMU_ENABLE ; +xscale1pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static inline u32 +xscale1pmu_read_counter (int counter) +{ +u32 val =0 ; + +switch (counter) { +case XSCALE_CYCLE_COUNTER : + asmvolatile ("mrc p14, 0, %0, c1, c0, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER0 : + asmvolatile ("mrc p14, 0, %0, c2, c0, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER1 : + asmvolatile ("mrc p14, 0, %0, c3, c0, 0" :"=r" (val)); +break ; + } + +return val; +} + +static inline void +xscale1pmu_write_counter (int counter,u32 val) +{ +switch (counter) { +case XSCALE_CYCLE_COUNTER : + asmvolatile ("mcr p14, 0, %0, c1, c0, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER0 : + asmvolatile ("mcr p14, 0, %0, c2, c0, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER1 : + asmvolatile ("mcr p14, 0, %0, c3, c0, 0" : :"r" (val)); +break ; + } +} + +static const struct arm_pmu xscale1pmu = { + .id =ARM_PERF_PMU_ID_XSCALE1 , + .handle_irq = xscale1pmu_handle_irq, + .enable = xscale1pmu_enable_event, + .disable = xscale1pmu_disable_event, + .event_map = xscalepmu_event_map, + .raw_event = xscalepmu_raw_event, + .read_counter = xscale1pmu_read_counter, + .write_counter = xscale1pmu_write_counter, + .get_event_idx = xscale1pmu_get_event_idx, + .start = xscale1pmu_start, + .stop = xscale1pmu_stop, + .num_events =3 , + .max_period = (1LLU <<32 ) -1 , +}; + +#define XSCALE2_OVERFLOWED_MASK 0x01f +#define XSCALE2_CCOUNT_OVERFLOW 0x001 +#define XSCALE2_COUNT0_OVERFLOW 0x002 +#define XSCALE2_COUNT1_OVERFLOW 0x004 +#define XSCALE2_COUNT2_OVERFLOW 0x008 +#define XSCALE2_COUNT3_OVERFLOW 0x010 +#define XSCALE2_CCOUNT_INT_EN 0x001 +#define XSCALE2_COUNT0_INT_EN 0x002 +#define XSCALE2_COUNT1_INT_EN 0x004 +#define XSCALE2_COUNT2_INT_EN 0x008 +#define XSCALE2_COUNT3_INT_EN 0x010 +#define XSCALE2_COUNT0_EVT_SHFT 0 +#define XSCALE2_COUNT0_EVT_MASK (0xff << XSCALE2_COUNT0_EVT_SHFT) +#define XSCALE2_COUNT1_EVT_SHFT 8 +#define XSCALE2_COUNT1_EVT_MASK (0xff << XSCALE2_COUNT1_EVT_SHFT) +#define XSCALE2_COUNT2_EVT_SHFT 16 +#define XSCALE2_COUNT2_EVT_MASK (0xff << XSCALE2_COUNT2_EVT_SHFT) +#define XSCALE2_COUNT3_EVT_SHFT 24 +#define XSCALE2_COUNT3_EVT_MASK (0xff << XSCALE2_COUNT3_EVT_SHFT) + +static inline u32 +xscale2pmu_read_pmnc (void ) +{ +u32 val; + asmvolatile ("mrc p14, 0, %0, c0, c1, 0" :"=r" (val)); +/* bits 1-2 and 4-23 are read-unpredictable */ +return val &0xff000009 ; +} + +static inline void +xscale2pmu_write_pmnc (u32 val) +{ +/* bits 4-23 are write-as-0, 24-31 are write ignored */ + val &=0xf ; + asmvolatile ("mcr p14, 0, %0, c0, c1, 0" : :"r" (val)); +} + +static inline u32 +xscale2pmu_read_overflow_flags (void ) +{ +u32 val; + asmvolatile ("mrc p14, 0, %0, c5, c1, 0" :"=r" (val)); +return val; +} + +static inline void +xscale2pmu_write_overflow_flags (u32 val) +{ + asmvolatile ("mcr p14, 0, %0, c5, c1, 0" : :"r" (val)); +} + +static inline u32 +xscale2pmu_read_event_select (void ) +{ +u32 val; + asmvolatile ("mrc p14, 0, %0, c8, c1, 0" :"=r" (val)); +return val; +} + +static inline void +xscale2pmu_write_event_select (u32 val) +{ + asmvolatile ("mcr p14, 0, %0, c8, c1, 0" : :"r" (val)); +} + +static inline u32 +xscale2pmu_read_int_enable (void ) +{ +u32 val; + asmvolatile ("mrc p14, 0, %0, c4, c1, 0" :"=r" (val)); +return val; +} + +static void +xscale2pmu_write_int_enable (u32 val) +{ + asmvolatile ("mcr p14, 0, %0, c4, c1, 0" : :"r" (val)); +} + +static inline int +xscale2_pmnc_counter_has_overflowed (unsigned long of_flags, +enum xscale_counters counter) +{ +int ret =0 ; + +switch (counter) { +case XSCALE_CYCLE_COUNTER : + ret = of_flags &XSCALE2_CCOUNT_OVERFLOW ; +break ; +case XSCALE_COUNTER0 : + ret = of_flags &XSCALE2_COUNT0_OVERFLOW ; +break ; +case XSCALE_COUNTER1 : + ret = of_flags &XSCALE2_COUNT1_OVERFLOW ; +break ; +case XSCALE_COUNTER2 : + ret = of_flags &XSCALE2_COUNT2_OVERFLOW ; +break ; +case XSCALE_COUNTER3 : + ret = of_flags &XSCALE2_COUNT3_OVERFLOW ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , counter); + } + +return ret; +} + +static irqreturn_t +xscale2pmu_handle_irq (int irq_num,void *dev) +{ +unsigned long pmnc, of_flags; +struct perf_sample_data data; +struct cpu_hw_events *cpuc; +struct pt_regs *regs; +int idx; + +/* Disable the PMU. */ + pmnc =xscale2pmu_read_pmnc (); +xscale2pmu_write_pmnc (pmnc & ~XSCALE_PMU_ENABLE ); + +/* Check the overflow flag register. */ + of_flags =xscale2pmu_read_overflow_flags (); +if (!(of_flags &XSCALE2_OVERFLOWED_MASK )) +return IRQ_NONE ; + +/* Clear the overflow bits. */ +xscale2pmu_write_overflow_flags (of_flags); + + regs =get_irq_regs (); + data.addr =0 ; + + cpuc = &__get_cpu_var (cpu_hw_events); +for (idx =0 ; idx <= armpmu->num_events; ++idx) { +struct perf_event *event = cpuc->events[idx]; +struct hw_perf_event *hwc; + +if (!test_bit (idx, cpuc->active_mask)) +continue ; + +if (!xscale2_pmnc_counter_has_overflowed (pmnc, idx)) +continue ; + + hwc = &event->hw; +armpmu_event_update (event, hwc, idx); + data.period = event->hw.last_period; +if (!armpmu_event_set_period (event, hwc, idx)) +continue ; + +if (perf_event_overflow (event,0 , &data, regs)) + armpmu->disable (hwc, idx); + } + +perf_event_do_pending (); + +/* +* Re-enable the PMU. +*/ + pmnc =xscale2pmu_read_pmnc () |XSCALE_PMU_ENABLE ; +xscale2pmu_write_pmnc (pmnc); + +return IRQ_HANDLED ; +} + +static void +xscale2pmu_enable_event (struct hw_perf_event *hwc,int idx) +{ +unsigned long flags, ien, evtsel; + + ien =xscale2pmu_read_int_enable (); + evtsel =xscale2pmu_read_event_select (); + +switch (idx) { +case XSCALE_CYCLE_COUNTER : + ien |=XSCALE2_CCOUNT_INT_EN ; +break ; +case XSCALE_COUNTER0 : + ien |=XSCALE2_COUNT0_INT_EN ; + evtsel &= ~XSCALE2_COUNT0_EVT_MASK ; + evtsel |= hwc->config_base <<XSCALE2_COUNT0_EVT_SHFT ; +break ; +case XSCALE_COUNTER1 : + ien |=XSCALE2_COUNT1_INT_EN ; + evtsel &= ~XSCALE2_COUNT1_EVT_MASK ; + evtsel |= hwc->config_base <<XSCALE2_COUNT1_EVT_SHFT ; +break ; +case XSCALE_COUNTER2 : + ien |=XSCALE2_COUNT2_INT_EN ; + evtsel &= ~XSCALE2_COUNT2_EVT_MASK ; + evtsel |= hwc->config_base <<XSCALE2_COUNT2_EVT_SHFT ; +break ; +case XSCALE_COUNTER3 : + ien |=XSCALE2_COUNT3_INT_EN ; + evtsel &= ~XSCALE2_COUNT3_EVT_MASK ; + evtsel |= hwc->config_base <<XSCALE2_COUNT3_EVT_SHFT ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , idx); +return ; + } + +spin_lock_irqsave (&pmu_lock, flags); +xscale2pmu_write_event_select (evtsel); +xscale2pmu_write_int_enable (ien); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static void +xscale2pmu_disable_event (struct hw_perf_event *hwc,int idx) +{ +unsigned long flags, ien, evtsel; + + ien =xscale2pmu_read_int_enable (); + evtsel =xscale2pmu_read_event_select (); + +switch (idx) { +case XSCALE_CYCLE_COUNTER : + ien &= ~XSCALE2_CCOUNT_INT_EN ; +break ; +case XSCALE_COUNTER0 : + ien &= ~XSCALE2_COUNT0_INT_EN ; + evtsel &= ~XSCALE2_COUNT0_EVT_MASK ; + evtsel |=XSCALE_PERFCTR_UNUSED <<XSCALE2_COUNT0_EVT_SHFT ; +break ; +case XSCALE_COUNTER1 : + ien &= ~XSCALE2_COUNT1_INT_EN ; + evtsel &= ~XSCALE2_COUNT1_EVT_MASK ; + evtsel |=XSCALE_PERFCTR_UNUSED <<XSCALE2_COUNT1_EVT_SHFT ; +break ; +case XSCALE_COUNTER2 : + ien &= ~XSCALE2_COUNT2_INT_EN ; + evtsel &= ~XSCALE2_COUNT2_EVT_MASK ; + evtsel |=XSCALE_PERFCTR_UNUSED <<XSCALE2_COUNT2_EVT_SHFT ; +break ; +case XSCALE_COUNTER3 : + ien &= ~XSCALE2_COUNT3_INT_EN ; + evtsel &= ~XSCALE2_COUNT3_EVT_MASK ; + evtsel |=XSCALE_PERFCTR_UNUSED <<XSCALE2_COUNT3_EVT_SHFT ; +break ; +default : +WARN_ONCE (1 ,"invalid counter number (%d)\n" , idx); +return ; + } + +spin_lock_irqsave (&pmu_lock, flags); +xscale2pmu_write_event_select (evtsel); +xscale2pmu_write_int_enable (ien); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static int +xscale2pmu_get_event_idx (struct cpu_hw_events *cpuc, +struct hw_perf_event *event) +{ +int idx =xscale1pmu_get_event_idx (cpuc, event); +if (idx >=0 ) + goto out; + +if (!test_and_set_bit (XSCALE_COUNTER3 , cpuc->used_mask)) + idx =XSCALE_COUNTER3 ; +else if (!test_and_set_bit (XSCALE_COUNTER2 , cpuc->used_mask)) + idx =XSCALE_COUNTER2 ; +out: +return idx; +} + +static void +xscale2pmu_start (void ) +{ +unsigned long flags, val; + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale2pmu_read_pmnc () & ~XSCALE_PMU_CNT64 ; + val |=XSCALE_PMU_ENABLE ; +xscale2pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static void +xscale2pmu_stop (void ) +{ +unsigned long flags, val; + +spin_lock_irqsave (&pmu_lock, flags); + val =xscale2pmu_read_pmnc (); + val &= ~XSCALE_PMU_ENABLE ; +xscale2pmu_write_pmnc (val); +spin_unlock_irqrestore (&pmu_lock, flags); +} + +static inline u32 +xscale2pmu_read_counter (int counter) +{ +u32 val =0 ; + +switch (counter) { +case XSCALE_CYCLE_COUNTER : + asmvolatile ("mrc p14, 0, %0, c1, c1, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER0 : + asmvolatile ("mrc p14, 0, %0, c0, c2, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER1 : + asmvolatile ("mrc p14, 0, %0, c1, c2, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER2 : + asmvolatile ("mrc p14, 0, %0, c2, c2, 0" :"=r" (val)); +break ; +case XSCALE_COUNTER3 : + asmvolatile ("mrc p14, 0, %0, c3, c2, 0" :"=r" (val)); +break ; + } + +return val; +} + +static inline void +xscale2pmu_write_counter (int counter,u32 val) +{ +switch (counter) { +case XSCALE_CYCLE_COUNTER : + asmvolatile ("mcr p14, 0, %0, c1, c1, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER0 : + asmvolatile ("mcr p14, 0, %0, c0, c2, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER1 : + asmvolatile ("mcr p14, 0, %0, c1, c2, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER2 : + asmvolatile ("mcr p14, 0, %0, c2, c2, 0" : :"r" (val)); +break ; +case XSCALE_COUNTER3 : + asmvolatile ("mcr p14, 0, %0, c3, c2, 0" : :"r" (val)); +break ; + } +} + +static const struct arm_pmu xscale2pmu = { + .id =ARM_PERF_PMU_ID_XSCALE2 , + .handle_irq = xscale2pmu_handle_irq, + .enable = xscale2pmu_enable_event, + .disable = xscale2pmu_disable_event, + .event_map = xscalepmu_event_map, + .raw_event = xscalepmu_raw_event, + .read_counter = xscale2pmu_read_counter, + .write_counter = xscale2pmu_write_counter, + .get_event_idx = xscale2pmu_get_event_idx, + .start = xscale2pmu_start, + .stop = xscale2pmu_stop, + .num_events =5 , + .max_period = (1LLU <<32 ) -1 , +}; +static int __init init_hw_perf_events (void ) {
@@ -2104,7 +2899,7 @@ init_hw_perf_events(void)unsigned long implementor = (cpuid &0xFF000000 ) >>24 ;unsigned long part_number = (cpuid &0xFFF0 ); -/* We only support ARM CPUs implemented by ARM at the moment. */ +/* ARM Ltd CPUs. */ if (0x41 == implementor) {switch (part_number) {case 0xB360 :/* ARM1136 */
@@ -2146,15 +2941,33 @@ init_hw_perf_events(void) armv7pmu.num_events =armv7_reset_read_pmnc (); perf_max_events = armv7pmu.num_events;break ; -default : -pr_info ("no hardware support available\n" ); - perf_max_events =-1 ; + } +/* Intel CPUs [xscale]. */ + }else if (0x69 == implementor) { + part_number = (cpuid >>13 ) &0x7 ; +switch (part_number) { +case 1 : + armpmu = &xscale1pmu; +memcpy (armpmu_perf_cache_map, xscale_perf_cache_map, +sizeof (xscale_perf_cache_map)); + perf_max_events = xscale1pmu.num_events; +break ; +case 2 : + armpmu = &xscale2pmu; +memcpy (armpmu_perf_cache_map, xscale_perf_cache_map, +sizeof (xscale_perf_cache_map)); + perf_max_events = xscale2pmu.num_events; +break ; } } -if (armpmu) +if (armpmu) {pr_info ("enabled with %s PMU driver, %d counters available\n" , - arm_pmu_names[armpmu->id], armpmu->num_events); + arm_pmu_names[armpmu->id], armpmu->num_events); + }else { +pr_info ("no hardware support available\n" ); + perf_max_events =-1 ; + }return 0 ; }
Signature · 1 line
1.6.3.3
PATCH 4/6 perf-events: export enable/disable event symbols to kernel modules
The perf_event_enable and perf_event_disable functions are used to control the activation of perf-events for a given context or CPU.
This patch exports these symbols so that they can be used by kernel modules. Without these symbols, an event must be destroyed and recreated to disable or enable it respectively. The maximum number of perf-events is also made available to modules via the perf_get_max_events function.
--- include/linux/perf_event.h | 1 + kernel/perf_event.c | 8 ++++++++ 2 files changed, 9 insertions(+), 0 deletions(-)
include/linux/perf_event.h +1 -0
@@ -741,6 +741,7 @@ struct perf_output_handle {* Set by architecture code: */ extern int perf_max_events; +extern int perf_get_max_events (void );extern const struct pmu *hw_perf_event_init (struct perf_event *event);
kernel/perf_event.c +8 -0
@@ -39,6 +39,12 @@ static DEFINE_PER_CPU(struct perf_cpu_context, perf_cpu_context);int perf_max_events__read_mostly =1 ; +int perf_get_max_events (void ) +{ +return perf_max_events; +} +EXPORT_SYMBOL_GPL (perf_get_max_events); +static int perf_reserved_percpu__read_mostly ;static int perf_overcommit__read_mostly =1 ;
@@ -604,6 +610,7 @@ void perf_event_disable(struct perf_event *event)raw_spin_unlock_irq (&ctx->lock); } +EXPORT_SYMBOL_GPL (perf_event_disable); static int event_sched_in(struct perf_event *event,
@@ -1028,6 +1035,7 @@ void perf_event_enable(struct perf_event *event) out:raw_spin_unlock_irq (&ctx->lock); } +EXPORT_SYMBOL_GPL (perf_event_enable);static int perf_event_refresh (struct perf_event *event,int refresh) {
Signature · 1 line
1.6.3.3
PATCH 5/6 ARM: oprofile: use perf-events framework as backend
There are currently two hardware performance monitoring subsystems in the kernel for ARM: OProfile and perf-events. This creates the following problems:
1.) Duplicate PMU accessor code. Inevitable code drift may lead to bugs in one framework that are fixed in the other.
2.) Locking issues. OProfile doesn't reprogram hardware counters between profiling runs if the events to be monitored have not been changed. This means that other profiling frameworks cannot use the counters if OProfile is in use.
3.) Due to differences in the two frameworks, it may not be possible to compare the results obtained by OProfile with those obtained by perf.
This patch removes the OProfile PMU driver code and replaces it with calls to perf, therefore solving the issues mentioned above.
The only userspace-visible change is the lack of SCU counter support for 11MPCore. This is currently unsupported by OProfile userspace tools anyway and therefore shouldn't cause any problems.
--- arch/arm/oprofile/common.c | 356 ++++++++++++++++++++++++++++++++++++++------ 1 files changed, 307 insertions(+), 49 deletions(-)
arch/arm/oprofile/common.c +307 -49
@@ -2,32 +2,210 @@* @file common.c * * @remark Copyright 2004 Oprofile Authors +* @remark Copyright 2010 ARM Ltd. * @remark Read the file COPYING * * @author Zwane Mwaikambo +* @author Will Deacon [move to perf] */ +#include <linux/cpumask.h> +#include <linux/errno.h> #include <linux/init.h> +#include <linux/mutex.h> #include <linux/oprofile.h> -#include <linux/errno.h> +#include <linux/perf_event.h> #include <linux/slab.h> #include <linux/sysdev.h> -#include <linux/mutex.h> +#include <asm/stacktrace.h> +#include <linux/uaccess.h> -#include "op_counter.h" -#include "op_arm_model.h" +#include <asm/perf_event.h> +#include <asm/ptrace.h> + +#ifdef CONFIG_HW_PERF_EVENTS +/* +* Per performance monitor configuration as set via oprofilefs. +*/ +struct op_counter_config { +unsigned long count; +unsigned long enabled; +unsigned long event; +unsigned long unit_mask; +unsigned long kernel; +unsigned long user; +struct perf_event_attr attr; +}; -static struct op_arm_model_spec *op_arm_model;static int op_arm_enabled;static DEFINE_MUTEX (op_arm_mutex); -struct op_counter_config *counter_config; +static struct op_counter_config *counter_config; +static struct perf_event **perf_events[nr_cpumask_bits]; +static int perf_num_counters; + +/* +* Create perf attributes to mirror the oprofile settings in counter_config. +* Attributes are created in the disabled state and are permanently scheduled +* on the PMU. +*/ +static void op_setup_counter_attrs (void ) +{ +int i; +u32 size =sizeof (struct perf_event_attr ); +struct perf_event_attr *attr; + +for (i =0 ; i < perf_num_counters; ++i) { + attr = &counter_config[i].attr; +memset (attr,0 , size); + attr->type =PERF_TYPE_RAW ; + attr->size = size; + attr->config = counter_config[i].event; + attr->sample_period = counter_config[i].count; + attr->pinned =1 ; + attr->disabled =1 ; + } +} + +/* +* Overflow callback for oprofile. +*/ +static void op_overflow_handler (struct perf_event *event,int unused, +struct perf_sample_data *data,struct pt_regs *regs) +{ +int id; +u32 cpu =smp_processor_id (); + +for (id =0 ; id < perf_num_counters; ++id) +if (perf_events[cpu][id] == event) +break ; + +if (id != perf_num_counters) +oprofile_add_sample (regs, id); +else +pr_warning ("oprofile: ignoring spurious overflow " +"on cpu %u\n" , cpu); +} + +/* +* Create a new perf event for event `id' on cpu `cpu' using the latest +* perf attribute for the corresponding counter. +*/ +static int op_update_perf_event (int cpu,int id) +{ +int ret =0 ; +struct perf_event *event = perf_events[cpu][id]; +struct perf_event_attr *attr = &counter_config[id].attr; + +if (event !=NULL ) +perf_event_release_kernel (event); + + event =perf_event_create_kernel_counter (attr, cpu,-1 , + op_overflow_handler); +if (IS_ERR (event)) { + ret =PTR_ERR (event); + event =NULL ; + } + + perf_events[cpu][id] = event; +return ret; +} + +/* +* Called by op_arm_setup to program the PMU with the parameters held in +* counter_config. +*/ +static int op_perf_setup (void ) +{ +int cpu, event, ret =0 ; + +op_setup_counter_attrs (); + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) { + ret =op_update_perf_event (cpu, event); +if (ret) +break ; + } + } + +return ret; +} + +/* +* Enable the perf events whose counter_configs are also enabled. +* We check that the event becomes active because we specify that +* the attribute is pinned. +*/ +static int op_enable_counter (int cpu,int event) +{ +int ret =0 ; + +if (counter_config[event].enabled) { +perf_event_enable (perf_events[cpu][event]); +if (perf_events[cpu][event]->state !=PERF_EVENT_STATE_ACTIVE ) { +pr_warning ("oprofile: failed to enable event %d " +"on CPU %d\n" , event, cpu); + ret = -EBUSY ; + } + } + +return ret; +} + +static void op_perf_stop (void ) +{ +int cpu, event; + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) +perf_event_disable (perf_events[cpu][event]); + } +} + +static int op_perf_start (void ) +{ +int cpu, event, ret =0 ; + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) { + ret =op_enable_counter (cpu, event); +if (ret) { +/* Disabling a disabled event is idempotent. */ +op_perf_stop (); +break ; + } + } + } + +return ret; +} + +static char *op_name_from_perf_id (int id) +{ +switch (id) { +case ARM_PERF_PMU_ID_XSCALE1 : +return "arm/xscale1" ; +case ARM_PERF_PMU_ID_XSCALE2 : +return "arm/xscale2" ; +case ARM_PERF_PMU_ID_V6 : +return "arm/armv6" ; +case ARM_PERF_PMU_ID_V6MP : +return "arm/mpcore" ; +case ARM_PERF_PMU_ID_CA8 : +return "arm/armv7" ; +case ARM_PERF_PMU_ID_CA9 : +return "arm/armv7-ca9" ; +default : +return NULL ; + } +}static int op_arm_create_files (struct super_block *sb,struct dentry *root) {unsigned int i; -for (i =0 ; i < op_arm_model->num_counters; i++) { +for (i =0 ; i < perf_num_counters; i++) {struct dentry *dir;char buf[4 ];
@@ -49,7 +227,7 @@ static int op_arm_setup(void)int ret;spin_lock (&oprofilefs_lock); - ret = op_arm_model->setup_ctrs (); + ret =op_perf_setup ();spin_unlock (&oprofilefs_lock);return ret; }
@@ -60,8 +238,9 @@ static int op_arm_start(void)mutex_lock (&op_arm_mutex);if (!op_arm_enabled) { - ret = op_arm_model->start (); - op_arm_enabled = !ret; + ret =0 ; +op_perf_start (); + op_arm_enabled =1 ; }mutex_unlock (&op_arm_mutex);return ret;
@@ -71,7 +250,7 @@ static void op_arm_stop(void) {mutex_lock (&op_arm_mutex);if (op_arm_enabled) - op_arm_model->stop (); +op_perf_stop (); op_arm_enabled =0 ;mutex_unlock (&op_arm_mutex); }
@@ -81,7 +260,7 @@ static int op_arm_suspend(struct sys_device *dev, pm_message_t state) {mutex_lock (&op_arm_mutex);if (op_arm_enabled) - op_arm_model->stop (); +op_perf_stop ();mutex_unlock (&op_arm_mutex);return 0 ; }
@@ -89,7 +268,7 @@ static int op_arm_suspend(struct sys_device *dev, pm_message_t state)static int op_arm_resume (struct sys_device *dev) {mutex_lock (&op_arm_mutex); -if (op_arm_enabled && op_arm_model->start ()) +if (op_arm_enabled &&op_perf_start ()) op_arm_enabled =0 ;mutex_unlock (&op_arm_mutex);return 0 ;
@@ -126,58 +305,137 @@ static void exit_driverfs(void)#define exit_driverfs () do { } while (0)#endif /* CONFIG_PM */ -int __init oprofile_arch_init (struct oprofile_operations *ops) +static int report_trace (struct stackframe *frame,void *d) { -struct op_arm_model_spec *spec =NULL ; -int ret = -ENODEV ; +unsigned int *depth = d; - ops->backtrace = arm_backtrace; +if (*depth) { +oprofile_add_trace (frame->pc); + (*depth)--; + } + +return *depth ==0 ; +} -#ifdef CONFIG_CPU_XSCALE - spec = &op_xscale_spec; -#endif +/* +* The registers we're interested in are at the end of the variable +* length saved register structure. The fp points at the end of this +* structure so the address of this struct is: +* (struct frame_tail *)(xxx->fp)-1 +*/ +struct frame_tail { +struct frame_tail *fp; +unsigned long sp; +unsigned long lr; +} __attribute__((packed)); -#ifdef CONFIG_OPROFILE_ARMV6 - spec = &op_armv6_spec; -#endif +static struct frame_tail *user_backtrace (struct frame_tail *tail) +{ +struct frame_tail buftail[2 ]; -#ifdef CONFIG_OPROFILE_MPCORE - spec = &op_mpcore_spec; -#endif +/* Also check accessibility of one struct frame_tail beyond */ +if (!access_ok (VERIFY_READ , tail,sizeof (buftail))) +return NULL ; +if (__copy_from_user_inatomic (buftail, tail,sizeof (buftail))) +return NULL ; -#ifdef CONFIG_OPROFILE_ARMV7 - spec = &op_armv7_spec; -#endif +oprofile_add_trace (buftail[0 ].lr); -if (spec) { - ret = spec->init (); -if (ret <0 ) -return ret; +/* frame pointers should strictly progress back up the stack +* (towards higher addresses) */ +if (tail >= buftail[0 ].fp) +return NULL ; - counter_config =kcalloc (spec->num_counters,sizeof (struct op_counter_config ), -GFP_KERNEL ); -if (!counter_config) -return -ENOMEM ; +return buftail[0 ].fp-1 ; +} - op_arm_model = spec; -init_driverfs (); - ops->create_files = op_arm_create_files; - ops->setup = op_arm_setup; - ops->shutdown = op_arm_stop; - ops->start = op_arm_start; - ops->stop = op_arm_stop; - ops->cpu_type = op_arm_model->name; -printk (KERN_INFO "oprofile: using %s\n" , spec->name); +static void arm_backtrace (struct pt_regs *const regs,unsigned int depth) +{ +struct frame_tail *tail = ((struct frame_tail *) regs->ARM_fp) -1 ; + +if (!user_mode (regs)) { +struct stackframe frame; + frame.fp = regs->ARM_fp; + frame.sp = regs->ARM_sp; + frame.lr = regs->ARM_lr; + frame.pc = regs->ARM_pc; +walk_stackframe (&frame, report_trace, &depth); +return ; } +while (depth-- && tail && !((unsigned long ) tail &3 )) + tail =user_backtrace (tail); +} + +int __init oprofile_arch_init (struct oprofile_operations *ops) +{ +int cpu, ret =0 ; + + perf_num_counters =perf_get_max_events (); + + counter_config =kcalloc (perf_num_counters, +sizeof (struct op_counter_config ),GFP_KERNEL ); + +if (!counter_config) { +pr_info ("oprofile: failed to allocate %d " +"counters\n" , perf_num_counters); +return -ENOMEM ; + } + +for_each_possible_cpu (cpu) { + perf_events[cpu] =kcalloc (perf_num_counters, +sizeof (struct perf_event *),GFP_KERNEL ); +if (!perf_events[cpu]) { +pr_info ("oprofile: failed to allocate %d perf events " +"for cpu %d\n" , perf_num_counters, cpu); +while (--cpu >=0 ) +kfree (perf_events[cpu]); +return -ENOMEM ; + } + } + +init_driverfs (); + ops->backtrace = arm_backtrace; + ops->create_files = op_arm_create_files; + ops->setup = op_arm_setup; + ops->shutdown = op_arm_stop; + ops->start = op_arm_start; + ops->stop = op_arm_stop; + ops->cpu_type =op_name_from_perf_id (armpmu_get_pmu_id ()); + +if (!ops->cpu_type) + ret = -ENODEV ; +else +pr_info ("oprofile: using %s\n" , ops->cpu_type); +return ret; }void oprofile_arch_exit (void ) { -if (op_arm_model) { +int cpu, id; +struct perf_event *event; + +if (*perf_events) {exit_driverfs (); - op_arm_model =NULL ; +for_each_possible_cpu (cpu) { +for (id =0 ; id < perf_num_counters; ++id) { + event = perf_events[cpu][id]; +if (event !=NULL ) +perf_event_release_kernel (event); + } +kfree (perf_events[cpu]); + } } -kfree (counter_config); + +if (counter_config) +kfree (counter_config); +} +#else +int __init oprofile_arch_init (struct oprofile_operations *ops) +{ +pr_info ("oprofile: hardware counters not available\n" ); +return -ENODEV ; } +void oprofile_arch_exit (void ) {} +#endif /* CONFIG_HW_PERF_EVENTS */
Signature · 1 line
1.6.3.3
PATCH 6/6 ARM: oprofile: remove old files and update KConfig
Enable hardware perf-events if CPU_HAS_PMU and select HAVE_OPROFILE if HAVE_PERF_EVENTS. If no hardware support is present, oprofile will fall back to timer mode.
This patch also removes the old OProfile drivers in favour of the code implemented by perf.
--- arch/arm/Kconfig | 26 +-- arch/arm/oprofile/Makefile | 7 +- arch/arm/oprofile/backtrace.c | 83 ------ arch/arm/oprofile/op_arm_model.h | 35 --- arch/arm/oprofile/op_counter.h | 27 -- arch/arm/oprofile/op_model_arm11_core.c | 162 ----------- arch/arm/oprofile/op_model_arm11_core.h | 45 --- arch/arm/oprofile/op_model_mpcore.c | 306 --------------------- arch/arm/oprofile/op_model_mpcore.h | 61 ----- arch/arm/oprofile/op_model_v6.c | 78 ------ arch/arm/oprofile/op_model_v7.c | 415 ----------------------------- arch/arm/oprofile/op_model_v7.h | 103 ------- arch/arm/oprofile/op_model_xscale.c | 444 ------------------------------- 13 files changed, 3 insertions(+), 1789 deletions(-) delete mode 100644 arch/arm/oprofile/backtrace.c delete mode 100644 arch/arm/oprofile/op_arm_model.h delete mode 100644 arch/arm/oprofile/op_counter.h delete mode 100644 arch/arm/oprofile/op_model_arm11_core.c delete mode 100644 arch/arm/oprofile/op_model_arm11_core.h delete mode 100644 arch/arm/oprofile/op_model_mpcore.c delete mode 100644 arch/arm/oprofile/op_model_mpcore.h delete mode 100644 arch/arm/oprofile/op_model_v6.c delete mode 100644 arch/arm/oprofile/op_model_v7.c delete mode 100644 arch/arm/oprofile/op_model_v7.h delete mode 100644 arch/arm/oprofile/op_model_xscale.c
arch/arm/Kconfig +2 -24
@@ -12,7 +12,6 @@ config ARM select HAVE_IDE select RTC_LIB select SYS_SUPPORTS_APM_EMULATION - select HAVE_OPROFILE select HAVE_ARCH_KGDB select HAVE_KPROBES if (!XIP_KERNEL) select HAVE_KRETPROBES if (HAVE_KPROBES)
@@ -23,6 +22,7 @@ config ARM select GENERIC_ATOMIC64 if (!CPU_32v6K) select HAVE_PERF_EVENTS select PERF_USE_VMALLOC + select HAVE_OPROFILE if (HAVE_PERF_EVENTS) help The ARM series is a line of low-power-consumption RISC chip designs licensed by ARM Ltd and targeted at embedded applications and
@@ -164,28 +164,6 @@ config ARCH_MTD_XIP config GENERIC_HARDIRQS_NO__DO_IRQ def_bool y -if OPROFILE - -config OPROFILE_ARMV6 - def_bool y - depends on CPU_V6 && !SMP - select OPROFILE_ARM11_CORE - -config OPROFILE_MPCORE - def_bool y - depends on CPU_V6 && SMP - select OPROFILE_ARM11_CORE - -config OPROFILE_ARM11_CORE - bool - -config OPROFILE_ARMV7 - def_bool y - depends on CPU_V7 && !SMP - bool - -endif - config VECTORS_BASE hex default 0xffff0000 if MMU || CPU_HIGH_VECTOR
@@ -1181,7 +1159,7 @@ config HIGHPTE config HW_PERF_EVENTS bool "Enable hardware performance counter support for perf events" - depends on PERF_EVENTS && CPU_HAS_PMU && (CPU_V6 || CPU_V7) + depends on PERF_EVENTS && CPU_HAS_PMU default y help Enable hardware performance counter support for perf events. If
arch/arm/oprofile/Makefile +1 -6
@@ -6,9 +6,4 @@ DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \ oprofilefs.o oprofile_stats.o \ timer_int.o ) -oprofile-y := $(DRIVER_OBJS) common.o backtrace.o -oprofile-$(CONFIG_CPU_XSCALE) += op_model_xscale.o -oprofile-$(CONFIG_OPROFILE_ARM11_CORE) += op_model_arm11_core.o -oprofile-$(CONFIG_OPROFILE_ARMV6) += op_model_v6.o -oprofile-$(CONFIG_OPROFILE_MPCORE) += op_model_mpcore.o -oprofile-$(CONFIG_OPROFILE_ARMV7) += op_model_v7.o +oprofile-y := $(DRIVER_OBJS) common.o
arch/arm/oprofile/backtrace.c deleted +0 -83
83 lines not on this page · raw message
arch/arm/oprofile/op_arm_model.h deleted +0 -35
@@ -1,35 +0,0 @@ -/** -* @file op_arm_model.h -* interface to ARM machine specific operations -* -* @remark Copyright 2004 Oprofile Authors -* @remark Read the file COPYING -* -* @author Zwane Mwaikambo -*/ - -#ifndef OP_ARM_MODEL_H -#define OP_ARM_MODEL_H - -struct op_arm_model_spec { -int (*init)(void ); -unsigned int num_counters; -int (*setup_ctrs)(void ); -int (*start)(void ); -void (*stop)(void ); -char *name; -}; - -#ifdef CONFIG_CPU_XSCALE -extern struct op_arm_model_spec op_xscale_spec; -#endif - -extern struct op_arm_model_spec op_armv6_spec; -extern struct op_arm_model_spec op_mpcore_spec; -extern struct op_arm_model_spec op_armv7_spec; - -extern void arm_backtrace (struct pt_regs *const regs,unsigned int depth); - -extern int __init op_arm_init (struct oprofile_operations *ops,struct op_arm_model_spec *spec); -extern void op_arm_exit (void ); -#endif /* OP_ARM_MODEL_H */
arch/arm/oprofile/op_counter.h deleted +0 -27
@@ -1,27 +0,0 @@ -/** -* @file op_counter.h -* -* @remark Copyright 2004 Oprofile Authors -* @remark Read the file COPYING -* -* @author Zwane Mwaikambo -*/ - -#ifndef OP_COUNTER_H -#define OP_COUNTER_H - -/* Per performance monitor configuration as set via -* oprofilefs. -*/ -struct op_counter_config { -unsigned long count; -unsigned long enabled; -unsigned long event; -unsigned long unit_mask; -unsigned long kernel; -unsigned long user; -}; - -extern struct op_counter_config *counter_config; - -#endif /* OP_COUNTER_H */
arch/arm/oprofile/op_model_arm11_core.c deleted +0 -162
162 lines not on this page · raw message
arch/arm/oprofile/op_model_arm11_core.h deleted +0 -45
45 lines not on this page · raw message
arch/arm/oprofile/op_model_mpcore.c deleted +0 -306
306 lines not on this page · raw message
arch/arm/oprofile/op_model_mpcore.h deleted +0 -61
61 lines not on this page · raw message
arch/arm/oprofile/op_model_v6.c deleted +0 -78
78 lines not on this page · raw message
arch/arm/oprofile/op_model_v7.c deleted +0 -415
415 lines not on this page · raw message
arch/arm/oprofile/op_model_v7.h deleted +0 -103
103 lines not on this page · raw message
arch/arm/oprofile/op_model_xscale.c deleted +0 -444
444 lines not on this page · raw message
Signature · 1 line
1.6.3.3
PATCH 5/6 ARM: oprofile: use perf-events framework as backend
In reply to Will DeaconWill,
How is the underlaying HW reserved? In Oprofile we used to have a call to reserve_pmu.
Otherwise I am OK with the concept of cleaning the profiling tools. Very good!
Jean
Quoted 472 lines · On Thursday 25 February 2010 19:56:14 Will Deacon wrote:
There are currently two hardware performance monitoring subsystems in the kernel for ARM: OProfile and perf-events. This creates the following problems:
1.) Duplicate PMU accessor code. Inevitable code drift may lead to bugs in one framework that are fixed in the other.
2.) Locking issues. OProfile doesn't reprogram hardware counters between profiling runs if the events to be monitored have not been changed. This means that other profiling frameworks cannot use the counters if OProfile is in use.
3.) Due to differences in the two frameworks, it may not be possible to compare the results obtained by OProfile with those obtained by perf.
This patch removes the OProfile PMU driver code and replaces it with calls to perf, therefore solving the issues mentioned above.
The only userspace-visible change is the lack of SCU counter support for 11MPCore. This is currently unsupported by OProfile userspace tools anyway and therefore shouldn't cause any problems.
Signed-off-by Will Deacon <[email protected]>--- arch/arm/oprofile/common.c | 356++++++++++++++++++++++++++++++++++++++------ 1 files changed, 307 insertions(+), 49 deletions(-)
arch/arm/oprofile/common.c +30
-6@@ -2,32 +2,210 @@* @file common.c * * @remark Copyright 2004 Oprofile Authors +* @remark Copyright 2010 ARM Ltd. * @remark Read the file COPYING * * @author Zwane Mwaikambo +* @author Will Deacon [move to perf] */ +#include <linux/cpumask.h> +#include <linux/errno.h> #include <linux/init.h> +#include <linux/mutex.h> #include <linux/oprofile.h> -#include <linux/errno.h> +#include <linux/perf_event.h> #include <linux/slab.h> #include <linux/sysdev.h> -#include <linux/mutex.h> +#include <asm/stacktrace.h> +#include <linux/uaccess.h> -#include "op_counter.h" -#include "op_arm_model.h" +#include <asm/perf_event.h> +#include <asm/ptrace.h> + +#ifdef CONFIG_HW_PERF_EVENTS +/* +* Per performance monitor configuration as set via oprofilefs. +*/ +struct op_counter_config { +unsigned long count; +unsigned long enabled; +unsigned long event; +unsigned long unit_mask; +unsigned long kernel; +unsigned long user; +struct perf_event_attr attr; +}; -static struct op_arm_model_spec *op_arm_model;static int op_arm_enabled;static DEFINE_MUTEX (op_arm_mutex); -struct op_counter_config *counter_config; +static struct op_counter_config *counter_config; +static struct perf_event **perf_events[nr_cpumask_bits]; +static int perf_num_counters; + +/* +* Create perf attributes to mirror the oprofile settings in
counter_config. + * Attributes are created in the disabled state and are permanently scheduled + * on the PMU.
+ */arch/arm/oprofile/common.c +151
-0+static void op_setup_counter_attrs (void ) +{ +int i; +u32 size =sizeof (struct perf_event_attr ); +struct perf_event_attr *attr; + +for (i =0 ; i < perf_num_counters; ++i) { + attr = &counter_config[i].attr; +memset (attr,0 , size); + attr->type =PERF_TYPE_RAW ; + attr->size = size; + attr->config = counter_config[i].event; + attr->sample_period = counter_config[i].count; + attr->pinned =1 ; + attr->disabled =1 ; + } +} + +/* +* Overflow callback for oprofile. +*/ +static void op_overflow_handler (struct perf_event *event,int unused, +struct perf_sample_data *data,struct pt_regs *regs) +{ +int id; +u32 cpu =smp_processor_id (); + +for (id =0 ; id < perf_num_counters; ++id) +if (perf_events[cpu][id] == event) +break ; + +if (id != perf_num_counters) +oprofile_add_sample (regs, id); +else +pr_warning ("oprofile: ignoring spurious overflow " +"on cpu %u\n" , cpu); +} + +/* +* Create a new perf event for event `id' on cpu `cpu' using the latest +* perf attribute for the corresponding counter. +*/ +static int op_update_perf_event (int cpu,int id) +{ +int ret =0 ; +struct perf_event *event = perf_events[cpu][id]; +struct perf_event_attr *attr = &counter_config[id].attr; + +if (event !=NULL ) +perf_event_release_kernel (event); + + event =perf_event_create_kernel_counter (attr, cpu,-1 , + op_overflow_handler); +if (IS_ERR (event)) { + ret =PTR_ERR (event); + event =NULL ; + } + + perf_events[cpu][id] = event; +return ret; +} + +/* +* Called by op_arm_setup to program the PMU with the parameters held in +* counter_config. +*/ +static int op_perf_setup (void ) +{ +int cpu, event, ret =0 ; + +op_setup_counter_attrs (); + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) { + ret =op_update_perf_event (cpu, event); +if (ret) +break ; + } + } + +return ret; +} + +/* +* Enable the perf events whose counter_configs are also enabled. +* We check that the event becomes active because we specify that +* the attribute is pinned. +*/ +static int op_enable_counter (int cpu,int event) +{ +int ret =0 ; + +if (counter_config[event].enabled) { +perf_event_enable (perf_events[cpu][event]); +if (perf_events[cpu][event]->state !=PERF_EVENT_STATE_ACTIVE ) { +pr_warning ("oprofile: failed to enable event %d " +"on CPU %d\n" , event, cpu); + ret = -EBUSY ; + } + } + +return ret; +} + +static void op_perf_stop (void ) +{ +int cpu, event; + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) +perf_event_disable (perf_events[cpu][event]); + } +} + +static int op_perf_start (void ) +{ +int cpu, event, ret =0 ; + +for_each_online_cpu (cpu) { +for (event =0 ; event < perf_num_counters; ++event) { + ret =op_enable_counter (cpu, event); +if (ret) { +/* Disabling a disabled event is idempotent. */ +op_perf_stop (); +break ; + } + } + } + +return ret; +} + +static char *op_name_from_perf_id (int id) +{ +switch (id) { +case ARM_PERF_PMU_ID_XSCALE1 : +return "arm/xscale1" ; +case ARM_PERF_PMU_ID_XSCALE2 : +return "arm/xscale2" ; +case ARM_PERF_PMU_ID_V6 : +return "arm/armv6" ; +case ARM_PERF_PMU_ID_V6MP : +return "arm/mpcore" ; +case ARM_PERF_PMU_ID_CA8 : +return "arm/armv7" ; +case ARM_PERF_PMU_ID_CA9 : +return "arm/armv7-ca9" ; +default : +return NULL ; + } +} static int op_arm_create_files(struct super_block *sb, struct dentry*root) {
arch/arm/oprofile/common.c +123
-42unsigned int i; -for (i =0 ; i < op_arm_model->num_counters; i++) { +for (i =0 ; i < perf_num_counters; i++) {struct dentry *dir;char buf[4 ];@@ -49,7 +227,7 @@ static int op_arm_setup(void)int ret;spin_lock (&oprofilefs_lock); - ret = op_arm_model->setup_ctrs (); + ret =op_perf_setup ();spin_unlock (&oprofilefs_lock);return ret; }@@ -60,8 +238,9 @@ static int op_arm_start(void)mutex_lock (&op_arm_mutex);if (!op_arm_enabled) { - ret = op_arm_model->start (); - op_arm_enabled = !ret; + ret =0 ; +op_perf_start (); + op_arm_enabled =1 ; }mutex_unlock (&op_arm_mutex);return ret;@@ -71,7 +250,7 @@ static void op_arm_stop(void) {mutex_lock (&op_arm_mutex);if (op_arm_enabled) - op_arm_model->stop (); +op_perf_stop (); op_arm_enabled =0 ;mutex_unlock (&op_arm_mutex); }@@ -81,7 +260,7 @@ static int op_arm_suspend(struct sys_device *dev, pm_message_t state) {mutex_lock (&op_arm_mutex);if (op_arm_enabled) - op_arm_model->stop (); +op_perf_stop ();mutex_unlock (&op_arm_mutex);return 0 ; }@@ -89,7 +268,7 @@ static int op_arm_suspend(struct sys_device *dev, pm_message_t state) static int op_arm_resume(struct sys_device *dev) {mutex_lock (&op_arm_mutex); -if (op_arm_enabled && op_arm_model->start ()) +if (op_arm_enabled &&op_perf_start ()) op_arm_enabled =0 ;mutex_unlock (&op_arm_mutex);return 0 ;@@ -126,58 +305,137 @@ static void exit_driverfs(void)#define exit_driverfs () do { } while (0)#endif /* CONFIG_PM */ -int __init oprofile_arch_init (struct oprofile_operations *ops) +static int report_trace (struct stackframe *frame,void *d) { -struct op_arm_model_spec *spec =NULL ; -int ret = -ENODEV ; +unsigned int *depth = d; - ops->backtrace = arm_backtrace; +if (*depth) { +oprofile_add_trace (frame->pc); + (*depth)--; + } + +return *depth ==0 ; +} -#ifdef CONFIG_CPU_XSCALE - spec = &op_xscale_spec; -#endif +/* +* The registers we're interested in are at the end of the variable +* length saved register structure. The fp points at the end of this +* structure so the address of this struct is: +* (struct frame_tail *)(xxx->fp)-1 +*/ +struct frame_tail { +struct frame_tail *fp; +unsigned long sp; +unsigned long lr; +} __attribute__((packed)); -#ifdef CONFIG_OPROFILE_ARMV6 - spec = &op_armv6_spec; -#endif +static struct frame_tail *user_backtrace (struct frame_tail *tail) +{ +struct frame_tail buftail[2 ]; -#ifdef CONFIG_OPROFILE_MPCORE - spec = &op_mpcore_spec; -#endif +/* Also check accessibility of one struct frame_tail beyond */ +if (!access_ok (VERIFY_READ , tail,sizeof (buftail))) +return NULL ; +if (__copy_from_user_inatomic (buftail, tail,sizeof (buftail))) +return NULL ; -#ifdef CONFIG_OPROFILE_ARMV7 - spec = &op_armv7_spec; -#endif +oprofile_add_trace (buftail[0 ].lr); -if (spec) { - ret = spec->init (); -if (ret <0 ) -return ret; +/* frame pointers should strictly progress back up the stack +* (towards higher addresses) */ +if (tail >= buftail[0 ].fp) +return NULL ; - counter_config =kcalloc (spec->num_counters,sizeof (struct op_counter_config), - GFP_KERNEL); -if (!counter_config) -return -ENOMEM ; +return buftail[0 ].fp-1 ; +} - op_arm_model = spec; -init_driverfs (); - ops->create_files = op_arm_create_files; - ops->setup = op_arm_setup; - ops->shutdown = op_arm_stop; - ops->start = op_arm_start; - ops->stop = op_arm_stop; - ops->cpu_type = op_arm_model->name; -printk (KERN_INFO "oprofile: using %s\n" , spec->name); +static void arm_backtrace (struct pt_regs *const regs,unsigned int depth) +{ +struct frame_tail *tail = ((struct frame_tail *) regs->ARM_fp) -1 ; + +if (!user_mode (regs)) { +struct stackframe frame; + frame.fp = regs->ARM_fp; + frame.sp = regs->ARM_sp; + frame.lr = regs->ARM_lr; + frame.pc = regs->ARM_pc; +walk_stackframe (&frame, report_trace, &depth); +return ; } +while (depth-- && tail && !((unsigned long ) tail &3 )) + tail =user_backtrace (tail); +} + +int __init oprofile_arch_init (struct oprofile_operations *ops) +{ +int cpu, ret =0 ; + + perf_num_counters =perf_get_max_events (); + + counter_config =kcalloc (perf_num_counters, +sizeof (struct op_counter_config ),GFP_KERNEL ); + +if (!counter_config) { +pr_info ("oprofile: failed to allocate %d " +"counters\n" , perf_num_counters); +return -ENOMEM ; + } + +for_each_possible_cpu (cpu) { + perf_events[cpu] =kcalloc (perf_num_counters, +sizeof (struct perf_event *),GFP_KERNEL ); +if (!perf_events[cpu]) { +pr_info ("oprofile: failed to allocate %d perf events " +"for cpu %d\n" , perf_num_counters, cpu); +while (--cpu >=0 ) +kfree (perf_events[cpu]); +return -ENOMEM ; + } + } + +init_driverfs (); + ops->backtrace = arm_backtrace; + ops->create_files = op_arm_create_files; + ops->setup = op_arm_setup; + ops->shutdown = op_arm_stop; + ops->start = op_arm_start; + ops->stop = op_arm_stop; + ops->cpu_type =op_name_from_perf_id (armpmu_get_pmu_id ()); + +if (!ops->cpu_type) + ret = -ENODEV ; +else +pr_info ("oprofile: using %s\n" , ops->cpu_type); +return ret; }void oprofile_arch_exit (void ) { -if (op_arm_model) { +int cpu, id; +struct perf_event *event; + +if (*perf_events) {exit_driverfs (); - op_arm_model =NULL ; +for_each_possible_cpu (cpu) { +for (id =0 ; id < perf_num_counters; ++id) { + event = perf_events[cpu][id]; +if (event !=NULL ) +perf_event_release_kernel (event); + } +kfree (perf_events[cpu]); + } } -kfree (counter_config); + +if (counter_config) +kfree (counter_config); +} +#else +int __init oprofile_arch_init (struct oprofile_operations *ops) +{ +pr_info ("oprofile: hardware counters not available\n" ); +return -ENODEV ; } +void oprofile_arch_exit (void ) {} +#endif /* CONFIG_HW_PERF_EVENTS */
PATCH 5/6 ARM: oprofile: use perf-events framework as backend
Hi Jean,
Thanks for the feedback.
Quoted 2 lines
How is the underlaying HW reserved? In Oprofile we used to have a call to
reserve_pmu.
Since this patch uses the perf API, perf will take care of reserving the hardware for us [well, it reserves it for the perf framework]. The events created by OProfile are pinned to each CPU, so provided the perf calls don't fail, we know that we have access to the PMU. If the calls do fail, we report failure back to the generic OProfile framework.
Quoted 1 line
Otherwise I am OK with the concept of cleaning the profiling tools. Very good!
Thanks. Not only does it clean the code - it adds A9MP support to OProfile for free!
Cheers,
Will
PATCH 5/6 ARM: oprofile: use perf-events framework as backend
HI Will,
Quoted 4 lines · On Friday 26 February 2010 11:01:14 Will Deacon wrote:
Hi Jean,
Thanks for the feedback.
Quoted 8 lines
Quoted 2 lines
How is the underlaying HW reserved? In Oprofile we used to have a call to
reserve_pmu.Since this patch uses the perf API, perf will take care of reserving the hardware for us [well, it reserves it for the perf framework]. The events created by OProfile are pinned to each CPU, so provided the perf calls don't fail, we know that we have access to the PMU. If the calls do fail, we report failure back to the generic OProfile framework.
Ok that looks good!
Quoted 6 lines
Quoted 3 lines
Otherwise I am OK with the concept of cleaning the profiling tools. Very good!
Thanks. Not only does it clean the code - it adds A9MP support to OProfile for free!
Sure, very nice! I was wondering how to maintain both Oprofile and Perf Events. You come with the good solution.
I am OK to co-maintain this code if you do not mind.
Thanks,
Jean
Quoted 11 lines
Cheers,
Will
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH 5/6 ARM: oprofile: use perf-events framework as backend
Hi Jean,
Quoted 1 line
I am OK to co-maintain this code if you do not mind.
Sure - the more the merrier. I'll post an updated version of the patch [using an enum instead of #defined PMU IDs] once I've heard back from Ingo about the symbols I'm exporting from the generic perf events code.
Will
PATCH 4/6 perf-events: export enable/disable event symbols to kernel modules
In reply to Will DeaconQuoted 8 lines · Will Deacon
The
perf_event_enableandperf_event_disablefunctions are used to control the activation of perf-events for a given context or CPU.This patch exports these symbols so that they can be used by kernel modules. Without these symbols, an event must be destroyed and recreated to disable or enable it respectively. The maximum number of perf-events is also made available to modules via the
perf_get_max_eventsfunction.
Quoted 6 lines
Cc Ingo Molnar <[email protected]>Signed-off-by Will Deacon <[email protected]>--- include/linux/perf_event.h | 1 + kernel/perf_event.c | 8 ++++++++ 2 files changed, 9 insertions(+), 0 deletions(-)
Hm, what modules would like to use them, and in what fashion?
Thanks,
Ingo
PATCH 4/6 perf-events: export enable/disable event symbols to kernel modules
Hi Ingo,
Thanks for the quick response.
Quoted 5 lines · Will Deacon
Quoted 4 lines
The
perf_event_enableandperf_event_disablefunctions are used to control the activation of perf-events for a given context or CPU.
Quoted 8 lines
Quoted 5 lines
This patch exports these symbols so that they can be used by kernel modules. Without these symbols, an event must be destroyed and recreated to disable or enable it respectively. The maximum number of perf-events is also made available to modules via the
perf_get_max_eventsfunction.Hm, what modules would like to use them, and in what fashion?
The module I had in mind was OProfile [currently just the ARM port, but perhaps other architectures may decide to do this too]. The patch I posted here:
http://lists.infradead.org/pipermail/linux-arm-kernel/2010-February/010479.html
removes the PMU control code from OProfile and replaces it with calls to perf. This means that when OProfile starts or stops a profiling session, the corresponding events are enabled or disabled respectively.
If you want to compile OProfile as a module, then the enable/disable functions will need to be exported. I suppose the other solution is to prevent OProfile from being compiled as a module.
Thanks,
Will
PATCH 2/6 ARM: perf-events: use numeric ID to identify PMU
In reply to Will DeaconHi,
Here are some remarks, inlined.
Quoted 24 lines · On Thursday 25 February 2010 19:56:11 Will Deacon wrote:
The ARM perf-events framework provides support for a number of different PMUs using struct
arm_pmu. The char *name field of this struct can be used to identify the PMU, but this is cumbersome if used outside of perf.This patch replaces the name string for a PMU with an int, which holds a unique ID for the PMU being represented. This ID can be used to index an array of names within perf, so no functionality is lost. The presence of the ID field, allows other kernel subsystems [currently oprofile] to use their own mappings for the PMU name.
Cc Jamie Iles <[email protected]>Signed-off-by Will Deacon <[email protected]>--- arch/arm/include/asm/perf_event.h | 12 +++++++++++ arch/arm/kernel/perf_event.c | 39+++++++++++++++++++++++++++--------- 2 files changed, 41 insertions(+), 10 deletions(-)
(quoted diff) +0
-0
b/arch/arm/include/asm/perf_event.hindex 49e3049..925b9a4 100644arch/arm/include/asm/perf_event.h +0
-0@@ -28,4 +28,16 @@ set_perf_event_pending(void)* same indexes here for consistency. */
arch/arm/include/asm/perf_event.h set_perf_event_pending(void) · line 38
Quoted 10 lines
arch/arm/include/asm/perf_event.h +8
-0#define PERF_EVENT_INDEX_OFFSET 1 +/* ARM perf PMU IDs for use by internal perf clients. */ +#define ARM_PERF_PMU_ID_XSCALE1 0 +#define ARM_PERF_PMU_ID_XSCALE2 (ARM_PERF_PMU_ID_XSCALE1 + 1) +#define ARM_PERF_PMU_ID_V6 (ARM_PERF_PMU_ID_XSCALE2 + 1) +#define ARM_PERF_PMU_ID_V6MP (ARM_PERF_PMU_ID_V6 + 1) +#define ARM_PERF_PMU_ID_CA8 (ARM_PERF_PMU_ID_V6MP + 1) +#define ARM_PERF_PMU_ID_CA9 (ARM_PERF_PMU_ID_CA8 + 1) +#define ARM_NUM_PMU_IDS (ARM_PERF_PMU_ID_CA9 + 1)
I think we need a better representation of the IDs and names. This is error prone in case of modification, e.g. adding an ID.
Quoted 20 lines
arch/arm/include/asm/perf_event.h +4
-0+ +extern int +armpmu_get_pmu_id (void ); +#endif /* __ARM_PERF_EVENT_H__ */ arch/arm/kernel/perf_event.c +1
-0@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/kernel.h> +#include <linux/module.h> #include <linux/perf_event.h> #include <linux/spinlock.h> #include <linux/uaccess.h> @@ -67,8 +68,18 @@ struct cpu_hw_events { }; DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
arch/arm/kernel/perf_event.c struct cpu_hw_events { · line 79
Quoted 10 lines
arch/arm/kernel/perf_event.c +9
-0+/* PMU names. */ +static const char *arm_pmu_names[ARM_NUM_PMU_IDS ] = { +"xscale1" , +"xscale2" , +"v6" , +"v6mpcore" , +"ARMv7 Cortex-A8" , +"ARMv7 Cortex-A9" , +};
Same remark as above.
Jean
Quoted 82 lines
arch/arm/kernel/perf_event.c +16
-3+struct arm_pmu { -char *name; +int id;irqreturn_t (*handle_irq)(int irq_num,void *dev);void (*enable)(struct hw_perf_event *evt,int idx);void (*disable)(struct hw_perf_event *evt,int idx);@@ -87,6 +98,18 @@ struct arm_pmu {/* Set at runtime when we know what CPU type we are. */ static const struct arm_pmu *armpmu; +int +armpmu_get_pmu_id (void ) +{ +int id = -ENODEV ; + +if (armpmu !=NULL ) + id = armpmu->id; + +return id; +} +EXPORT_SYMBOL_GPL (armpmu_get_pmu_id); +#define HW_OP_UNSUPPORTED 0xFFFF#define C (_x) \@@ -1143,7 +1166,7 @@ armv6mpcore_pmu_disable_event(struct hw_perf_event *hwc, }static const struct arm_pmu armv6pmu = { - .name ="v6" , + .id =ARM_PERF_PMU_ID_V6 , .handle_irq = armv6pmu_handle_irq, .enable = armv6pmu_enable_event, .disable = armv6pmu_disable_event,@@ -1166,7 +1189,7 @@ static const struct arm_pmu armv6pmu = {* reset the period and enable the interrupt reporting. */ static const struct arm_pmu armv6mpcore_pmu = { - .name ="v6mpcore" , + .id =ARM_PERF_PMU_ID_V6MP , .handle_irq = armv6pmu_handle_irq, .enable = armv6pmu_enable_event, .disable = armv6mpcore_pmu_disable_event,@@ -1196,10 +1219,6 @@ static const struct arm_pmu armv6mpcore_pmu = {* counter and all 4 performance counters together can be reset separately. */
arch/arm/kernel/perf_event.c +3
-7-#define ARMV7_PMU_CORTEX_A8_NAME "ARMv7 Cortex-A8" - -#define ARMV7_PMU_CORTEX_A9_NAME "ARMv7 Cortex-A9" -/* Common ARMv7 event types */ enum armv7_perf_types {ARMV7_PERFCTR_PMNC_SW_INCR =0x00 ,@@ -2104,7 +2123,7 @@ init_hw_perf_events(void) perf_max_events = armv6mpcore_pmu.num_events;break ;case 0xC080 :/* Cortex-A8 */ - armv7pmu.name =ARMV7_PMU_CORTEX_A8_NAME ; + armv7pmu.id =ARM_PERF_PMU_ID_CA8 ;memcpy (armpmu_perf_cache_map, armv7_a8_perf_cache_map,sizeof (armv7_a8_perf_cache_map)); armv7pmu.event_map = armv7_a8_pmu_event_map;@@ -2116,7 +2135,7 @@ init_hw_perf_events(void) perf_max_events = armv7pmu.num_events;break ;case 0xC090 :/* Cortex-A9 */ - armv7pmu.name =ARMV7_PMU_CORTEX_A9_NAME ; + armv7pmu.id =ARM_PERF_PMU_ID_CA9 ;memcpy (armpmu_perf_cache_map, armv7_a9_perf_cache_map,sizeof (armv7_a9_perf_cache_map)); armv7pmu.event_map = armv7_a9_pmu_event_map;@@ -2135,7 +2154,7 @@ init_hw_perf_events(void)if (armpmu)pr_info ("enabled with %s PMU driver, %d counters available\n" , - armpmu->name, armpmu->num_events); + arm_pmu_names[armpmu->id], armpmu->num_events);return 0 ; }
PATCH 2/6 ARM: perf-events: use numeric ID to identify PMU
Hi Jean,
Quoted 10 lines
Review
Quoted 8 lines
(quoted diff) +8
-0+/* ARM perf PMU IDs for use by internal perf clients. */ +#define ARM_PERF_PMU_ID_XSCALE1 0 +#define ARM_PERF_PMU_ID_XSCALE2 (ARM_PERF_PMU_ID_XSCALE1 + 1) +#define ARM_PERF_PMU_ID_V6 (ARM_PERF_PMU_ID_XSCALE2 + 1) +#define ARM_PERF_PMU_ID_V6MP (ARM_PERF_PMU_ID_V6 + 1) +#define ARM_PERF_PMU_ID_CA8 (ARM_PERF_PMU_ID_V6MP + 1) +#define ARM_PERF_PMU_ID_CA9 (ARM_PERF_PMU_ID_CA8 + 1) +#define ARM_NUM_PMU_IDS (ARM_PERF_PMU_ID_CA9 + 1)I think we need a better representation of the IDs and names. This is error prone in case of modification, e.g. adding an ID.
OK - how about something like this?:
arch/arm/include/asm/perf_event.h +9 -7
@@ -29,13 +29,15 @@ set_perf_event_pending(void)#define PERF_EVENT_INDEX_OFFSET 1/* ARM perf PMU IDs for use by internal perf clients. */ -#define ARM_PERF_PMU_ID_XSCALE1 0 -#define ARM_PERF_PMU_ID_XSCALE2 (ARM_PERF_PMU_ID_XSCALE1 + 1) -#define ARM_PERF_PMU_ID_V6 (ARM_PERF_PMU_ID_XSCALE2 + 1) -#define ARM_PERF_PMU_ID_V6MP (ARM_PERF_PMU_ID_V6 + 1) -#define ARM_PERF_PMU_ID_CA8 (ARM_PERF_PMU_ID_V6MP + 1) -#define ARM_PERF_PMU_ID_CA9 (ARM_PERF_PMU_ID_CA8 + 1) -#define ARM_NUM_PMU_IDS (ARM_PERF_PMU_ID_CA9 + 1) +static enum arm_perf_pmu_ids { +ARM_PERF_PMU_ID_XSCALE1 =0 , +ARM_PERF_PMU_ID_XSCALE2 , +ARM_PERF_PMU_ID_V6 , +ARM_PERF_PMU_ID_V6MP , +ARM_PERF_PMU_ID_CA8 , +ARM_PERF_PMU_ID_CA9 , +ARM_NUM_PMU_IDS , +};extern int armpmu_get_pmu_id (void );
arch/arm/kernel/perf_event.c +7 -7
@@ -69,13 +69,13 @@ struct cpu_hw_events { DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);/* PMU names. */ -static const char *arm_pmu_names[ARM_NUM_PMU_IDS ] = { -"xscale1" , -"xscale2" , -"v6" , -"v6mpcore" , -"ARMv7 Cortex-A8" , -"ARMv7 Cortex-A9" , +static const char *arm_pmu_names[] = { + [ARM_PERF_PMU_ID_XSCALE1 ] ="xscale1" , + [ARM_PERF_PMU_ID_XSCALE2 ] ="xscale2" , + [ARM_PERF_PMU_ID_V6 ] ="v6" , + [ARM_PERF_PMU_ID_V6MP ] ="v6mpcore" , + [ARM_PERF_PMU_ID_CA8 ] ="ARMv7 Cortex-A8" , + [ARM_PERF_PMU_ID_CA9 ] ="ARMv7 Cortex-A9" , };struct arm_pmu {
Cheers,
Will
cover ARM: oprofile: use perf-events framework as backend
In reply to Will DeaconWill,
Quoted 3 lines · On Thursday 25 February 2010 19:56:09 Will Deacon wrote:
There are currently two hardware performance monitoring subsystems in the kernel for ARM: OProfile and perf-events. This creates the following problems:
Note: the latest LTTng also uses the PMU (only the CCNT is use). The code is not as organized as for Perf Events: no reservation mechanism, ARMv7 only ...
Quoted 2 lines
1.) Duplicate PMU accessor code. Inevitable code drift may lead to bugs in one framework that are fixed in the other.
Good point
Quoted 5 lines
2.) Locking issues. OProfile doesn't reprogram hardware counters between profiling runs if the events to be monitored have not been changed. This means that other profiling frameworks cannot use the counters if OProfile is in use.
Anyway only one profiling tool that uses PMU can run at a time. I think the reservation mechanism is enough. Oprofile also can run in timer mode; this is is used now on Cortex-A8 due to silicon errata.
Quoted 3 lines
3.) Due to differences in the two frameworks, it may not be possible to compare the results obtained by OProfile with those obtained by perf.
That would be nice (or even ideal) to have but every tool out there is different wrt the results.
Jean
Quoted 69 lines
This patch series removes the OProfile PMU driver code and replaces it with calls to perf, therefore resolving the issues mentioned above. To preserve compatibility with existing OProfile tools, drivers for XScale v1 and v2 PMUs are added to the perf backend.
The only userspace-visible change is the lack of SCU counter support for 11MPCore. This is currently unsupported by OProfile userspace tools anyway and therefore shouldn't cause any problems.
Tested on dual-core A9MP [Realview PBX], quad-core 11MPCore [Realview PB11MP] and XScale PXA270 [Gumstix Verdex XL6P].
Patch taken against 2.6.33 + perf-events patches in Russell's branch:
ARM: 5890/1: Fix incorrect Realview board IRQs for L220 and PMU
ARM: 5899/2: arm: provide a mechanism to reserve performance counters
ARM: 5901/2: arm/oprofile: reserve the PMU when starting
ARM: 5900/2: arm: enable support for software perf events
ARM: 5902/4: arm/perfevents: implement perf event support for ARMv6
ARM: 5903/1: arm/perfevents: add support for ARMv7Will Deacon (6):
ARM: perf-events: add Realview PMU IRQs topmu.c
ARM: perf-events: use numeric ID to identify PMU
ARM: perf-events: add support for xscale PMUs
perf-events: export enable/disable event symbols to kernel modules
ARM: oprofile: use perf-events framework as backend
ARM: oprofile: remove old files and update KConfigarch/arm/Kconfig | 26 +- arch/arm/include/asm/perf_event.h | 12 + arch/arm/kernel/perf_event.c | 862 ++++++++++++++++++++++++++++++- arch/arm/kernel/pmu.c | 14 + arch/arm/oprofile/Makefile | 7 +- arch/arm/oprofile/backtrace.c | 83 --- arch/arm/oprofile/common.c | 356 +++++++++++-- arch/arm/oprofile/op_arm_model.h | 35 -- arch/arm/oprofile/op_counter.h | 27 - arch/arm/oprofile/op_model_arm11_core.c | 162 ------ arch/arm/oprofile/op_model_arm11_core.h | 45 -- arch/arm/oprofile/op_model_mpcore.c | 306 ----------- arch/arm/oprofile/op_model_mpcore.h | 61 --- arch/arm/oprofile/op_model_v6.c | 78 --- arch/arm/oprofile/op_model_v7.c | 415 --------------- arch/arm/oprofile/op_model_v7.h | 103 ---- arch/arm/oprofile/op_model_xscale.c | 444 ---------------- include/linux/perf_event.h | 1 + kernel/perf_event.c | 8 + 19 files changed, 1192 insertions(+), 1853 deletions(-) delete mode 100644 arch/arm/oprofile/backtrace.c delete mode 100644 arch/arm/oprofile/op_arm_model.h delete mode 100644 arch/arm/oprofile/op_counter.h delete mode 100644 arch/arm/oprofile/op_model_arm11_core.c delete mode 100644 arch/arm/oprofile/op_model_arm11_core.h delete mode 100644 arch/arm/oprofile/op_model_mpcore.c delete mode 100644 arch/arm/oprofile/op_model_mpcore.h delete mode 100644 arch/arm/oprofile/op_model_v6.c delete mode 100644 arch/arm/oprofile/op_model_v7.c delete mode 100644 arch/arm/oprofile/op_model_v7.h delete mode 100644 arch/arm/oprofile/op_model_xscale.c_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel