Commit 42dec9a9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'perf-core-2021-04-28' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull perf event updates from Ingo Molnar:

 - Improve Intel uncore PMU support:

     - Parse uncore 'discovery tables' - a new hardware capability
       enumeration method introduced on the latest Intel platforms. This
       table is in a well-defined PCI namespace location and is read via
       MMIO. It is organized in an rbtree.

       These uncore tables will allow the discovery of standard counter
       blocks, but fancier counters still need to be enumerated
       explicitly.

     - Add Alder Lake support

     - Improve IIO stacks to PMON mapping support on Skylake servers

 - Add Intel Alder Lake PMU support - which requires the introduction of
   'hybrid' CPUs and PMUs. Alder Lake is a mix of Golden Cove ('big')
   and Gracemont ('small' - Atom derived) cores.

   The CPU-side feature set is entirely symmetrical - but on the PMU
   side there's core type dependent PMU functionality.

 - Reduce data loss with CPU level hardware tracing on Intel PT / AUX
   profiling, by fixing the AUX allocation watermark logic.

 - Improve ring buffer allocation on NUMA systems

 - Put 'struct perf_event' into their separate kmem_cache pool

 - Add support for synchronous signals for select perf events. The
   immediate motivation is to support low-overhead sampling-based race
   detection for user-space code. The feature consists of the following
   main changes:

     - Add thread-only event inheritance via
       perf_event_attr::inherit_thread, which limits inheritance of
       events to CLONE_THREAD.

     - Add the ability for events to not leak through exec(), via
       perf_event_attr::remove_on_exec.

     - Allow the generation of SIGTRAP via perf_event_attr::sigtrap,
       extend siginfo with an u64 ::si_perf, and add the breakpoint
       information to ::si_addr and ::si_perf if the event is
       PERF_TYPE_BREAKPOINT.

   The siginfo support is adequate for breakpoints right now - but the
   new field can be used to introduce support for other types of
   metadata passed over siginfo as well.

 - Misc fixes, cleanups and smaller updates.

* tag 'perf-core-2021-04-28' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (53 commits)
  signal, perf: Add missing TRAP_PERF case in siginfo_layout()
  signal, perf: Fix siginfo_t by avoiding u64 on 32-bit architectures
  perf/x86: Allow for 8<num_fixed_counters<16
  perf/x86/rapl: Add support for Intel Alder Lake
  perf/x86/cstate: Add Alder Lake CPU support
  perf/x86/msr: Add Alder Lake CPU support
  perf/x86/intel/uncore: Add Alder Lake support
  perf: Extend PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE
  perf/x86/intel: Add Alder Lake Hybrid support
  perf/x86: Support filter_match callback
  perf/x86/intel: Add attr_update for Hybrid PMUs
  perf/x86: Add structures for the attributes of Hybrid PMUs
  perf/x86: Register hybrid PMUs
  perf/x86: Factor out x86_pmu_show_pmu_cap
  perf/x86: Remove temporary pmu assignment in event_init
  perf/x86/intel: Factor out intel_pmu_check_extra_regs
  perf/x86/intel: Factor out intel_pmu_check_event_constraints
  perf/x86/intel: Factor out intel_pmu_check_num_counters
  perf/x86: Hybrid PMU support for extra_regs
  perf/x86: Hybrid PMU support for event constraints
  ...
parents 03b2cd72 ed8e5080

arch/m68k/kernel/signal.c

+3 −0
Original line number Diff line number Diff line
@@ -622,6 +622,9 @@ static inline void siginfo_build_tests(void) 
	/* _sigfault._addr_pkey */

	BUILD_BUG_ON(offsetof(siginfo_t, si_pkey) != 0x12);



	/* _sigfault._perf */

	BUILD_BUG_ON(offsetof(siginfo_t, si_perf) != 0x10);



	/* _sigpoll */

	BUILD_BUG_ON(offsetof(siginfo_t, si_band)   != 0x0c);

	BUILD_BUG_ON(offsetof(siginfo_t, si_fd)     != 0x10);

arch/x86/events/amd/iommu.c

+3 −3
Original line number Diff line number Diff line
@@ -81,12 +81,12 @@ static struct attribute_group amd_iommu_events_group = { 
};



struct amd_iommu_event_desc {

	struct kobj_attribute attr;

	struct device_attribute attr;

	const char *event;

};



static ssize_t _iommu_event_show(struct kobject *kobj,

				struct kobj_attribute *attr, char *buf)

static ssize_t _iommu_event_show(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	struct amd_iommu_event_desc *event =

		container_of(attr, struct amd_iommu_event_desc, attr);

arch/x86/events/amd/uncore.c

+3 −3
Original line number Diff line number Diff line
@@ -275,14 +275,14 @@ static struct attribute_group amd_uncore_attr_group = { 
};



#define DEFINE_UNCORE_FORMAT_ATTR(_var, _name, _format)			\

static ssize_t __uncore_##_var##_show(struct kobject *kobj,		\

				struct kobj_attribute *attr,		\

static ssize_t __uncore_##_var##_show(struct device *dev,		\

				struct device_attribute *attr,		\

				char *page)				\

{									\

	BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE);			\

	return sprintf(page, _format "\n");				\

}									\

static struct kobj_attribute format_attr_##_var =			\

static struct device_attribute format_attr_##_var =			\

	__ATTR(_name, 0444, __uncore_##_var##_show, NULL)



DEFINE_UNCORE_FORMAT_ATTR(event12,	event,		"config:0-7,32-35");

arch/x86/events/core.c

+257 −75
Original line number Diff line number Diff line
@@ -45,13 +45,16 @@ 
#include "perf_event.h"



struct x86_pmu x86_pmu __read_mostly;

static struct pmu pmu;



DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events) = {

	.enabled = 1,

	.pmu = &pmu,

};



DEFINE_STATIC_KEY_FALSE(rdpmc_never_available_key);

DEFINE_STATIC_KEY_FALSE(rdpmc_always_available_key);

DEFINE_STATIC_KEY_FALSE(perf_is_hybrid);



/*

 * This here uses DEFINE_STATIC_CALL_NULL() to get a static_call defined
@@ -151,15 +154,16 @@ u64 x86_perf_event_update(struct perf_event *event) 
 */

static int x86_pmu_extra_regs(u64 config, struct perf_event *event)

{

	struct extra_reg *extra_regs = hybrid(event->pmu, extra_regs);

	struct hw_perf_event_extra *reg;

	struct extra_reg *er;



	reg = &event->hw.extra_reg;



	if (!x86_pmu.extra_regs)

	if (!extra_regs)

		return 0;



	for (er = x86_pmu.extra_regs; er->msr; er++) {

	for (er = extra_regs; er->msr; er++) {

		if (er->event != (config & er->config_mask))

			continue;

		if (event->attr.config1 & ~er->valid_mask)
@@ -182,16 +186,29 @@ static DEFINE_MUTEX(pmc_reserve_mutex); 


#ifdef CONFIG_X86_LOCAL_APIC



static inline int get_possible_num_counters(void)

{

	int i, num_counters = x86_pmu.num_counters;



	if (!is_hybrid())

		return num_counters;



	for (i = 0; i < x86_pmu.num_hybrid_pmus; i++)

		num_counters = max_t(int, num_counters, x86_pmu.hybrid_pmu[i].num_counters);



	return num_counters;

}



static bool reserve_pmc_hardware(void)

{

	int i;

	int i, num_counters = get_possible_num_counters();



	for (i = 0; i < x86_pmu.num_counters; i++) {

	for (i = 0; i < num_counters; i++) {

		if (!reserve_perfctr_nmi(x86_pmu_event_addr(i)))

			goto perfctr_fail;

	}



	for (i = 0; i < x86_pmu.num_counters; i++) {

	for (i = 0; i < num_counters; i++) {

		if (!reserve_evntsel_nmi(x86_pmu_config_addr(i)))

			goto eventsel_fail;

	}
@@ -202,7 +219,7 @@ static bool reserve_pmc_hardware(void) 
	for (i--; i >= 0; i--)

		release_evntsel_nmi(x86_pmu_config_addr(i));



	i = x86_pmu.num_counters;

	i = num_counters;



perfctr_fail:

	for (i--; i >= 0; i--)
@@ -213,9 +230,9 @@ static bool reserve_pmc_hardware(void) 


static void release_pmc_hardware(void)

{

	int i;

	int i, num_counters = get_possible_num_counters();



	for (i = 0; i < x86_pmu.num_counters; i++) {

	for (i = 0; i < num_counters; i++) {

		release_perfctr_nmi(x86_pmu_event_addr(i));

		release_evntsel_nmi(x86_pmu_config_addr(i));

	}
@@ -228,7 +245,7 @@ static void release_pmc_hardware(void) {} 


#endif



static bool check_hw_exists(void)

bool check_hw_exists(struct pmu *pmu, int num_counters, int num_counters_fixed)

{

	u64 val, val_fail = -1, val_new= ~0;

	int i, reg, reg_fail = -1, ret = 0;
@@ -239,7 +256,7 @@ static bool check_hw_exists(void) 
	 * Check to see if the BIOS enabled any of the counters, if so

	 * complain and bail.

	 */

	for (i = 0; i < x86_pmu.num_counters; i++) {

	for (i = 0; i < num_counters; i++) {

		reg = x86_pmu_config_addr(i);

		ret = rdmsrl_safe(reg, &val);

		if (ret)
@@ -253,15 +270,15 @@ static bool check_hw_exists(void) 
		}

	}



	if (x86_pmu.num_counters_fixed) {

	if (num_counters_fixed) {

		reg = MSR_ARCH_PERFMON_FIXED_CTR_CTRL;

		ret = rdmsrl_safe(reg, &val);

		if (ret)

			goto msr_fail;

		for (i = 0; i < x86_pmu.num_counters_fixed; i++) {

			if (fixed_counter_disabled(i))

		for (i = 0; i < num_counters_fixed; i++) {

			if (fixed_counter_disabled(i, pmu))

				continue;

			if (val & (0x03 << i*4)) {

			if (val & (0x03ULL << i*4)) {

				bios_fail = 1;

				val_fail = val;

				reg_fail = reg;
@@ -360,8 +377,7 @@ set_ext_hw_attr(struct hw_perf_event *hwc, struct perf_event *event) 
		return -EINVAL;

	cache_result = array_index_nospec(cache_result, PERF_COUNT_HW_CACHE_RESULT_MAX);



	val = hw_cache_event_ids[cache_type][cache_op][cache_result];



	val = hybrid_var(event->pmu, hw_cache_event_ids)[cache_type][cache_op][cache_result];

	if (val == 0)

		return -ENOENT;
@@ -369,7 +385,7 @@ set_ext_hw_attr(struct hw_perf_event *hwc, struct perf_event *event) 
		return -EINVAL;



	hwc->config |= val;

	attr->config1 = hw_cache_extra_regs[cache_type][cache_op][cache_result];

	attr->config1 = hybrid_var(event->pmu, hw_cache_extra_regs)[cache_type][cache_op][cache_result];

	return x86_pmu_extra_regs(val, event);

}
@@ -462,7 +478,7 @@ int x86_setup_perfctr(struct perf_event *event) 
		local64_set(&hwc->period_left, hwc->sample_period);

	}



	if (attr->type == PERF_TYPE_RAW)

	if (attr->type == event->pmu->type)

		return x86_pmu_extra_regs(event->attr.config, event);



	if (attr->type == PERF_TYPE_HW_CACHE)
@@ -597,7 +613,7 @@ int x86_pmu_hw_config(struct perf_event *event) 
	if (!event->attr.exclude_kernel)

		event->hw.config |= ARCH_PERFMON_EVENTSEL_OS;



	if (event->attr.type == PERF_TYPE_RAW)

	if (event->attr.type == event->pmu->type)

		event->hw.config |= event->attr.config & X86_RAW_EVENT_MASK;



	if (event->attr.sample_period && x86_pmu.limit_period) {
@@ -724,16 +740,33 @@ void x86_pmu_enable_all(int added) 
	}

}



static struct pmu pmu;



static inline int is_x86_event(struct perf_event *event)

{

	int i;



	if (!is_hybrid())

		return event->pmu == &pmu;



	for (i = 0; i < x86_pmu.num_hybrid_pmus; i++) {

		if (event->pmu == &x86_pmu.hybrid_pmu[i].pmu)

			return true;

	}



struct pmu *x86_get_pmu(void)

	return false;

}



struct pmu *x86_get_pmu(unsigned int cpu)

{

	struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);



	/*

	 * All CPUs of the hybrid type have been offline.

	 * The x86_get_pmu() should not be invoked.

	 */

	if (WARN_ON_ONCE(!cpuc->pmu))

		return &pmu;



	return cpuc->pmu;

}

/*

 * Event scheduler state:
@@ -936,6 +969,7 @@ EXPORT_SYMBOL_GPL(perf_assign_events); 


int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign)

{

	int num_counters = hybrid(cpuc->pmu, num_counters);

	struct event_constraint *c;

	struct perf_event *e;

	int n0, i, wmin, wmax, unsched = 0;
@@ -1011,7 +1045,7 @@ int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign) 


	/* slow path */

	if (i != n) {

		int gpmax = x86_pmu.num_counters;

		int gpmax = num_counters;



		/*

		 * Do not allow scheduling of more than half the available
@@ -1032,7 +1066,7 @@ int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign) 
		 * the extra Merge events needed by large increment events.

		 */

		if (x86_pmu.flags & PMU_FL_PAIR) {

			gpmax = x86_pmu.num_counters - cpuc->n_pair;

			gpmax = num_counters - cpuc->n_pair;

			WARN_ON(gpmax <= 0);

		}
@@ -1096,8 +1130,9 @@ static void del_nr_metric_event(struct cpu_hw_events *cpuc, 
static int collect_event(struct cpu_hw_events *cpuc, struct perf_event *event,

			 int max_count, int n)

{

	union perf_capabilities intel_cap = hybrid(cpuc->pmu, intel_cap);



	if (x86_pmu.intel_cap.perf_metrics && add_nr_metric_event(cpuc, event))

	if (intel_cap.perf_metrics && add_nr_metric_event(cpuc, event))

		return -EINVAL;



	if (n >= max_count + cpuc->n_metric)
@@ -1118,10 +1153,12 @@ static int collect_event(struct cpu_hw_events *cpuc, struct perf_event *event, 
 */

static int collect_events(struct cpu_hw_events *cpuc, struct perf_event *leader, bool dogrp)

{

	int num_counters = hybrid(cpuc->pmu, num_counters);

	int num_counters_fixed = hybrid(cpuc->pmu, num_counters_fixed);

	struct perf_event *event;

	int n, max_count;



	max_count = x86_pmu.num_counters + x86_pmu.num_counters_fixed;

	max_count = num_counters + num_counters_fixed;



	/* current number of events already accepted */

	n = cpuc->n_events;
@@ -1480,7 +1517,6 @@ static void x86_pmu_start(struct perf_event *event, int flags) 


	cpuc->events[idx] = event;

	__set_bit(idx, cpuc->active_mask);

	__set_bit(idx, cpuc->running);

	static_call(x86_pmu_enable)(event);

	perf_event_update_userpage(event);

}
@@ -1489,18 +1525,19 @@ void perf_event_print_debug(void) 
{

	u64 ctrl, status, overflow, pmc_ctrl, pmc_count, prev_left, fixed;

	u64 pebs, debugctl;

	struct cpu_hw_events *cpuc;

	int cpu = smp_processor_id();

	struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);

	int num_counters = hybrid(cpuc->pmu, num_counters);

	int num_counters_fixed = hybrid(cpuc->pmu, num_counters_fixed);

	struct event_constraint *pebs_constraints = hybrid(cpuc->pmu, pebs_constraints);

	unsigned long flags;

	int cpu, idx;

	int idx;



	if (!x86_pmu.num_counters)

	if (!num_counters)

		return;



	local_irq_save(flags);



	cpu = smp_processor_id();

	cpuc = &per_cpu(cpu_hw_events, cpu);



	if (x86_pmu.version >= 2) {

		rdmsrl(MSR_CORE_PERF_GLOBAL_CTRL, ctrl);

		rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, status);
@@ -1512,7 +1549,7 @@ void perf_event_print_debug(void) 
		pr_info("CPU#%d: status:     %016llx\n", cpu, status);

		pr_info("CPU#%d: overflow:   %016llx\n", cpu, overflow);

		pr_info("CPU#%d: fixed:      %016llx\n", cpu, fixed);

		if (x86_pmu.pebs_constraints) {

		if (pebs_constraints) {

			rdmsrl(MSR_IA32_PEBS_ENABLE, pebs);

			pr_info("CPU#%d: pebs:       %016llx\n", cpu, pebs);

		}
@@ -1523,7 +1560,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_counters; idx++) {

	for (idx = 0; idx < num_counters; idx++) {

		rdmsrl(x86_pmu_config_addr(idx), pmc_ctrl);

		rdmsrl(x86_pmu_event_addr(idx), pmc_count);
@@ -1536,8 +1573,8 @@ 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_counters_fixed; idx++) {

		if (fixed_counter_disabled(idx))

	for (idx = 0; idx < num_counters_fixed; idx++) {

		if (fixed_counter_disabled(idx, cpuc->pmu))

			continue;

		rdmsrl(MSR_ARCH_PERFMON_FIXED_CTR0 + idx, pmc_count);
@@ -1573,6 +1610,7 @@ void x86_pmu_stop(struct perf_event *event, int flags) 
static void x86_pmu_del(struct perf_event *event, int flags)

{

	struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);

	union perf_capabilities intel_cap = hybrid(cpuc->pmu, intel_cap);

	int i;



	/*
@@ -1612,7 +1650,7 @@ static void x86_pmu_del(struct perf_event *event, int flags) 
	}

	cpuc->event_constraint[i-1] = NULL;

	--cpuc->n_events;

	if (x86_pmu.intel_cap.perf_metrics)

	if (intel_cap.perf_metrics)

		del_nr_metric_event(cpuc, event);



	perf_event_update_userpage(event);
@@ -1822,6 +1860,49 @@ ssize_t events_ht_sysfs_show(struct device *dev, struct device_attribute *attr, 
			pmu_attr->event_str_noht);

}



ssize_t events_hybrid_sysfs_show(struct device *dev,

				 struct device_attribute *attr,

				 char *page)

{

	struct perf_pmu_events_hybrid_attr *pmu_attr =

		container_of(attr, struct perf_pmu_events_hybrid_attr, attr);

	struct x86_hybrid_pmu *pmu;

	const char *str, *next_str;

	int i;



	if (hweight64(pmu_attr->pmu_type) == 1)

		return sprintf(page, "%s", pmu_attr->event_str);



	/*

	 * Hybrid PMUs may support the same event name, but with different

	 * event encoding, e.g., the mem-loads event on an Atom PMU has

	 * different event encoding from a Core PMU.

	 *

	 * The event_str includes all event encodings. Each event encoding

	 * is divided by ";". The order of the event encodings must follow

	 * the order of the hybrid PMU index.

	 */

	pmu = container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);



	str = pmu_attr->event_str;

	for (i = 0; i < x86_pmu.num_hybrid_pmus; i++) {

		if (!(x86_pmu.hybrid_pmu[i].cpu_type & pmu_attr->pmu_type))

			continue;

		if (x86_pmu.hybrid_pmu[i].cpu_type & pmu->cpu_type) {

			next_str = strchr(str, ';');

			if (next_str)

				return snprintf(page, next_str - str + 1, "%s", str);

			else

				return sprintf(page, "%s", str);

		}

		str = strchr(str, ';');

		str++;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(events_hybrid_sysfs_show);



EVENT_ATTR(cpu-cycles,			CPU_CYCLES		);

EVENT_ATTR(instructions,		INSTRUCTIONS		);

EVENT_ATTR(cache-references,		CACHE_REFERENCES	);
@@ -1948,6 +2029,37 @@ static void _x86_pmu_read(struct perf_event *event) 
	x86_perf_event_update(event);

}



void x86_pmu_show_pmu_cap(int num_counters, int num_counters_fixed,

			  u64 intel_ctrl)

{

	pr_info("... version:                %d\n",     x86_pmu.version);

	pr_info("... bit width:              %d\n",     x86_pmu.cntval_bits);

	pr_info("... generic registers:      %d\n",     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:   %lu\n",

			hweight64((((1ULL << num_counters_fixed) - 1)

					<< INTEL_PMC_IDX_FIXED) & intel_ctrl));

	pr_info("... event mask:             %016Lx\n", intel_ctrl);

}



/*

 * The generic code is not hybrid friendly. The hybrid_pmu->pmu

 * of the first registered PMU is unconditionally assigned to

 * each possible cpuctx->ctx.pmu.

 * Update the correct hybrid PMU to the cpuctx->ctx.pmu.

 */

void x86_pmu_update_cpu_context(struct pmu *pmu, int cpu)

{

	struct perf_cpu_context *cpuctx;



	if (!pmu->pmu_cpu_context)

		return;



	cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);

	cpuctx->ctx.pmu = pmu;

}



static int __init init_hw_perf_events(void)

{

	struct x86_pmu_quirk *quirk;
@@ -1981,7 +2093,7 @@ static int __init init_hw_perf_events(void) 
	pmu_check_apic();



	/* sanity check that the hardware exists or is emulated */

	if (!check_hw_exists())

	if (!check_hw_exists(&pmu, x86_pmu.num_counters, x86_pmu.num_counters_fixed))

		return 0;



	pr_cont("%s PMU driver.\n", x86_pmu.name);
@@ -2008,15 +2120,11 @@ static int __init init_hw_perf_events(void) 


	pmu.attr_update = x86_pmu.attr_update;



	pr_info("... version:                %d\n",     x86_pmu.version);

	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:   %lu\n",

			hweight64((((1ULL << x86_pmu.num_counters_fixed) - 1)

					<< INTEL_PMC_IDX_FIXED) & x86_pmu.intel_ctrl));

	pr_info("... event mask:             %016Lx\n", x86_pmu.intel_ctrl);

	if (!is_hybrid()) {

		x86_pmu_show_pmu_cap(x86_pmu.num_counters,

				     x86_pmu.num_counters_fixed,

				     x86_pmu.intel_ctrl);

	}



	if (!x86_pmu.read)

		x86_pmu.read = _x86_pmu_read;
@@ -2046,9 +2154,46 @@ static int __init init_hw_perf_events(void) 
	if (err)

		goto out1;



	if (!is_hybrid()) {

		err = perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

		if (err)

			goto out2;

	} else {

		u8 cpu_type = get_this_hybrid_cpu_type();

		struct x86_hybrid_pmu *hybrid_pmu;

		int i, j;



		if (!cpu_type && x86_pmu.get_hybrid_cpu_type)

			cpu_type = x86_pmu.get_hybrid_cpu_type();



		for (i = 0; i < x86_pmu.num_hybrid_pmus; i++) {

			hybrid_pmu = &x86_pmu.hybrid_pmu[i];



			hybrid_pmu->pmu = pmu;

			hybrid_pmu->pmu.type = -1;

			hybrid_pmu->pmu.attr_update = x86_pmu.attr_update;

			hybrid_pmu->pmu.capabilities |= PERF_PMU_CAP_HETEROGENEOUS_CPUS;

			hybrid_pmu->pmu.capabilities |= PERF_PMU_CAP_EXTENDED_HW_TYPE;



			err = perf_pmu_register(&hybrid_pmu->pmu, hybrid_pmu->name,

						(hybrid_pmu->cpu_type == hybrid_big) ? PERF_TYPE_RAW : -1);

			if (err)

				break;



			if (cpu_type == hybrid_pmu->cpu_type)

				x86_pmu_update_cpu_context(&hybrid_pmu->pmu, raw_smp_processor_id());

		}



		if (i < x86_pmu.num_hybrid_pmus) {

			for (j = 0; j < i; j++)

				perf_pmu_unregister(&x86_pmu.hybrid_pmu[j].pmu);

			pr_warn("Failed to register hybrid PMUs\n");

			kfree(x86_pmu.hybrid_pmu);

			x86_pmu.hybrid_pmu = NULL;

			x86_pmu.num_hybrid_pmus = 0;

			goto out2;

		}

	}



	return 0;
@@ -2173,16 +2318,27 @@ static void free_fake_cpuc(struct cpu_hw_events *cpuc) 
	kfree(cpuc);

}



static struct cpu_hw_events *allocate_fake_cpuc(void)

static struct cpu_hw_events *allocate_fake_cpuc(struct pmu *event_pmu)

{

	struct cpu_hw_events *cpuc;

	int cpu = raw_smp_processor_id();

	int cpu;



	cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL);

	if (!cpuc)

		return ERR_PTR(-ENOMEM);

	cpuc->is_fake = 1;



	if (is_hybrid()) {

		struct x86_hybrid_pmu *h_pmu;



		h_pmu = hybrid_pmu(event_pmu);

		if (cpumask_empty(&h_pmu->supported_cpus))

			goto error;

		cpu = cpumask_first(&h_pmu->supported_cpus);

	} else

		cpu = raw_smp_processor_id();

	cpuc->pmu = event_pmu;



	if (intel_cpuc_prepare(cpuc, cpu))

		goto error;
@@ -2201,7 +2357,7 @@ static int validate_event(struct perf_event *event) 
	struct event_constraint *c;

	int ret = 0;



	fake_cpuc = allocate_fake_cpuc();

	fake_cpuc = allocate_fake_cpuc(event->pmu);

	if (IS_ERR(fake_cpuc))

		return PTR_ERR(fake_cpuc);
@@ -2235,7 +2391,27 @@ static int validate_group(struct perf_event *event) 
	struct cpu_hw_events *fake_cpuc;

	int ret = -EINVAL, n;



	fake_cpuc = allocate_fake_cpuc();

	/*

	 * Reject events from different hybrid PMUs.

	 */

	if (is_hybrid()) {

		struct perf_event *sibling;

		struct pmu *pmu = NULL;



		if (is_x86_event(leader))

			pmu = leader->pmu;



		for_each_sibling_event(sibling, leader) {

			if (!is_x86_event(sibling))

				continue;

			if (!pmu)

				pmu = sibling->pmu;

			else if (pmu != sibling->pmu)

				return ret;

		}

	}



	fake_cpuc = allocate_fake_cpuc(event->pmu);

	if (IS_ERR(fake_cpuc))

		return PTR_ERR(fake_cpuc);

	/*
@@ -2263,35 +2439,26 @@ static int validate_group(struct perf_event *event) 


static int x86_pmu_event_init(struct perf_event *event)

{

	struct pmu *tmp;

	struct x86_hybrid_pmu *pmu = NULL;

	int err;



	switch (event->attr.type) {

	case PERF_TYPE_RAW:

	case PERF_TYPE_HARDWARE:

	case PERF_TYPE_HW_CACHE:

		break;

	if ((event->attr.type != event->pmu->type) &&

	    (event->attr.type != PERF_TYPE_HARDWARE) &&

	    (event->attr.type != PERF_TYPE_HW_CACHE))

		return -ENOENT;



	default:

	if (is_hybrid() && (event->cpu != -1)) {

		pmu = hybrid_pmu(event->pmu);

		if (!cpumask_test_cpu(event->cpu, &pmu->supported_cpus))

			return -ENOENT;

	}



	err = __x86_pmu_event_init(event);

	if (!err) {

		/*

		 * we temporarily connect event to its pmu

		 * such that validate_group() can classify

		 * it as an x86 event using is_x86_event()

		 */

		tmp = event->pmu;

		event->pmu = &pmu;



		if (event->group_leader != event)

			err = validate_group(event);

		else

			err = validate_event(event);



		event->pmu = tmp;

	}

	if (err) {

		if (event->destroy)
@@ -2475,6 +2642,14 @@ static int x86_pmu_aux_output_match(struct perf_event *event) 
	return 0;

}



static int x86_pmu_filter_match(struct perf_event *event)

{

	if (x86_pmu.filter_match)

		return x86_pmu.filter_match(event);



	return 1;

}



static struct pmu pmu = {

	.pmu_enable		= x86_pmu_enable,

	.pmu_disable		= x86_pmu_disable,
@@ -2502,6 +2677,8 @@ static struct pmu pmu = { 
	.check_period		= x86_pmu_check_period,



	.aux_output_match	= x86_pmu_aux_output_match,



	.filter_match		= x86_pmu_filter_match,

};



void arch_perf_update_userpage(struct perf_event *event,
@@ -2770,6 +2947,11 @@ unsigned long perf_misc_flags(struct pt_regs *regs) 
void perf_get_x86_pmu_capability(struct x86_pmu_capability *cap)

{

	cap->version		= x86_pmu.version;

	/*

	 * KVM doesn't support the hybrid PMU yet.

	 * Return the common value in global x86_pmu,

	 * which available for all cores.

	 */

	cap->num_counters_gp	= x86_pmu.num_counters;

	cap->num_counters_fixed	= x86_pmu.num_counters_fixed;

	cap->bit_width_gp	= x86_pmu.cntval_bits;

arch/x86/events/intel/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -3,6 +3,6 @@ obj-$(CONFIG_CPU_SUP_INTEL) += core.o bts.o 
obj-$(CONFIG_CPU_SUP_INTEL)		+= ds.o knc.o

obj-$(CONFIG_CPU_SUP_INTEL)		+= lbr.o p4.o p6.o pt.o

obj-$(CONFIG_PERF_EVENTS_INTEL_UNCORE)	+= intel-uncore.o

intel-uncore-objs			:= uncore.o uncore_nhmex.o uncore_snb.o uncore_snbep.o

intel-uncore-objs			:= uncore.o uncore_nhmex.o uncore_snb.o uncore_snbep.o uncore_discovery.o

obj-$(CONFIG_PERF_EVENTS_INTEL_CSTATE)	+= intel-cstate.o

intel-cstate-objs			:= cstate.o