[mirror_ubuntu-eoan-kernel.git] / arch / s390 / kernel / perf_cpum_cf_common.c

// SPDX-License-Identifier: GPL-2.0
/*
 * CPU-Measurement Counter Facility Support - Common Layer
 *
 *  Copyright IBM Corp. 2019
 *  Author(s): Hendrik Brueckner <brueckner@linux.ibm.com>
 */
#define KMSG_COMPONENT	"cpum_cf_common"
#define pr_fmt(fmt)	KMSG_COMPONENT ": " fmt

#include <linux/kernel.h>
#include <linux/kernel_stat.h>
#include <linux/percpu.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/export.h>
#include <asm/ctl_reg.h>
#include <asm/irq.h>
#include <asm/cpu_mcf.h>

/* Per-CPU event structure for the counter facility */
DEFINE_PER_CPU(struct cpu_cf_events, cpu_cf_events) = {
	.ctr_set = {
		[CPUMF_CTR_SET_BASIC]	= ATOMIC_INIT(0),
		[CPUMF_CTR_SET_USER]	= ATOMIC_INIT(0),
		[CPUMF_CTR_SET_CRYPTO]	= ATOMIC_INIT(0),
		[CPUMF_CTR_SET_EXT]	= ATOMIC_INIT(0),
		[CPUMF_CTR_SET_MT_DIAG] = ATOMIC_INIT(0),
	},
	.alert = ATOMIC64_INIT(0),
	.state = 0,
	.flags = 0,
	.txn_flags = 0,
};
/* Indicator whether the CPU-Measurement Counter Facility Support is ready */
static bool cpum_cf_initalized;

/* CPU-measurement alerts for the counter facility */
static void cpumf_measurement_alert(struct ext_code ext_code,
				    unsigned int alert, unsigned long unused)
{
	struct cpu_cf_events *cpuhw;

	if (!(alert & CPU_MF_INT_CF_MASK))
		return;

	inc_irq_stat(IRQEXT_CMC);
	cpuhw = this_cpu_ptr(&cpu_cf_events);

	/* Measurement alerts are shared and might happen when the PMU
	 * is not reserved.  Ignore these alerts in this case. */
	if (!(cpuhw->flags & PMU_F_RESERVED))
		return;

	/* counter authorization change alert */
	if (alert & CPU_MF_INT_CF_CACA)
		qctri(&cpuhw->info);

	/* loss of counter data alert */
	if (alert & CPU_MF_INT_CF_LCDA)
		pr_err("CPU[%i] Counter data was lost\n", smp_processor_id());

	/* loss of MT counter data alert */
	if (alert & CPU_MF_INT_CF_MTDA)
		pr_warn("CPU[%i] MT counter data was lost\n",
			smp_processor_id());

	/* store alert for special handling by in-kernel users */
	atomic64_or(alert, &cpuhw->alert);
}

#define PMC_INIT      0
#define PMC_RELEASE   1
static void cpum_cf_setup_cpu(void *flags)
{
	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);

	switch (*((int *) flags)) {
	case PMC_INIT:
		memset(&cpuhw->info, 0, sizeof(cpuhw->info));
		qctri(&cpuhw->info);
		cpuhw->flags |= PMU_F_RESERVED;
		break;

	case PMC_RELEASE:
		cpuhw->flags &= ~PMU_F_RESERVED;
		break;
	}

	/* Disable CPU counter sets */
	lcctl(0);
}

bool kernel_cpumcf_avail(void)
{
	return cpum_cf_initalized;
}
EXPORT_SYMBOL(kernel_cpumcf_avail);


/* Reserve/release functions for sharing perf hardware */
static DEFINE_SPINLOCK(cpumcf_owner_lock);
static void *cpumcf_owner;

/* Initialize the CPU-measurement counter facility */
int __kernel_cpumcf_begin(void)
{
	int flags = PMC_INIT;
	int err = 0;

	spin_lock(&cpumcf_owner_lock);
	if (cpumcf_owner)
		err = -EBUSY;
	else
		cpumcf_owner = __builtin_return_address(0);
	spin_unlock(&cpumcf_owner_lock);
	if (err)
		return err;

	on_each_cpu(cpum_cf_setup_cpu, &flags, 1);
	irq_subclass_register(IRQ_SUBCLASS_MEASUREMENT_ALERT);

	return 0;
}
EXPORT_SYMBOL(__kernel_cpumcf_begin);

/* Obtain the CPU-measurement alerts for the counter facility */
unsigned long kernel_cpumcf_alert(int clear)
{
	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);
	unsigned long alert;

	alert = atomic64_read(&cpuhw->alert);
	if (clear)
		atomic64_set(&cpuhw->alert, 0);

	return alert;
}
EXPORT_SYMBOL(kernel_cpumcf_alert);

/* Release the CPU-measurement counter facility */
void __kernel_cpumcf_end(void)
{
	int flags = PMC_RELEASE;

	on_each_cpu(cpum_cf_setup_cpu, &flags, 1);
	irq_subclass_unregister(IRQ_SUBCLASS_MEASUREMENT_ALERT);

	spin_lock(&cpumcf_owner_lock);
	cpumcf_owner = NULL;
	spin_unlock(&cpumcf_owner_lock);
}
EXPORT_SYMBOL(__kernel_cpumcf_end);

static int cpum_cf_setup(unsigned int cpu, int flags)
{
	local_irq_disable();
	cpum_cf_setup_cpu(&flags);
	local_irq_enable();
	return 0;
}

static int cpum_cf_online_cpu(unsigned int cpu)
{
	return cpum_cf_setup(cpu, PMC_INIT);
}

static int cpum_cf_offline_cpu(unsigned int cpu)
{
	return cpum_cf_setup(cpu, PMC_RELEASE);
}

static int __init cpum_cf_init(void)
{
	int rc;

	if (!cpum_cf_avail())
		return -ENODEV;

	/* clear bit 15 of cr0 to unauthorize problem-state to
	 * extract measurement counters */
	ctl_clear_bit(0, 48);

	/* register handler for measurement-alert interruptions */
	rc = register_external_irq(EXT_IRQ_MEASURE_ALERT,
				   cpumf_measurement_alert);
	if (rc) {
		pr_err("Registering for CPU-measurement alerts "
		       "failed with rc=%i\n", rc);
		return rc;
	}

	rc = cpuhp_setup_state(CPUHP_AP_PERF_S390_CF_ONLINE,
				"perf/s390/cf:online",
				cpum_cf_online_cpu, cpum_cf_offline_cpu);
	if (!rc)
		cpum_cf_initalized = true;

	return rc;
}
early_initcall(cpum_cf_init);
Commit	Line	Data
7f5ac1a0 HB	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* CPU-Measurement Counter Facility Support - Common Layer
	4	*
	5	* Copyright IBM Corp. 2019
	6	* Author(s): Hendrik Brueckner <brueckner@linux.ibm.com>
	7	*/
	8	#define KMSG_COMPONENT "cpum_cf_common"
	9	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	10
	11	#include <linux/kernel.h>
	12	#include <linux/kernel_stat.h>
	13	#include <linux/percpu.h>
	14	#include <linux/notifier.h>
	15	#include <linux/init.h>
	16	#include <linux/export.h>
	17	#include <asm/ctl_reg.h>
	18	#include <asm/irq.h>
	19	#include <asm/cpu_mcf.h>
	20
	21	/* Per-CPU event structure for the counter facility */
	22	DEFINE_PER_CPU(struct cpu_cf_events, cpu_cf_events) = {
	23	.ctr_set = {
	24	[CPUMF_CTR_SET_BASIC] = ATOMIC_INIT(0),
	25	[CPUMF_CTR_SET_USER] = ATOMIC_INIT(0),
	26	[CPUMF_CTR_SET_CRYPTO] = ATOMIC_INIT(0),
	27	[CPUMF_CTR_SET_EXT] = ATOMIC_INIT(0),
	28	[CPUMF_CTR_SET_MT_DIAG] = ATOMIC_INIT(0),
	29	},
	30	.alert = ATOMIC64_INIT(0),
	31	.state = 0,
	32	.flags = 0,
	33	.txn_flags = 0,
	34	};
	35	/* Indicator whether the CPU-Measurement Counter Facility Support is ready */
	36	static bool cpum_cf_initalized;
	37
	38	/* CPU-measurement alerts for the counter facility */
	39	static void cpumf_measurement_alert(struct ext_code ext_code,
	40	unsigned int alert, unsigned long unused)
	41	{
	42	struct cpu_cf_events *cpuhw;
	43
	44	if (!(alert & CPU_MF_INT_CF_MASK))
	45	return;
	46
	47	inc_irq_stat(IRQEXT_CMC);
	48	cpuhw = this_cpu_ptr(&cpu_cf_events);
	49
	50	/* Measurement alerts are shared and might happen when the PMU
	51	* is not reserved. Ignore these alerts in this case. */
	52	if (!(cpuhw->flags & PMU_F_RESERVED))
	53	return;
	54
	55	/* counter authorization change alert */
	56	if (alert & CPU_MF_INT_CF_CACA)
	57	qctri(&cpuhw->info);
	58
	59	/* loss of counter data alert */
	60	if (alert & CPU_MF_INT_CF_LCDA)
	61	pr_err("CPU[%i] Counter data was lost\n", smp_processor_id());
	62
	63	/* loss of MT counter data alert */
	64	if (alert & CPU_MF_INT_CF_MTDA)
65	pr_warn("CPU[%i] MT counter data was lost\n",
66	smp_processor_id());
67
68	/* store alert for special handling by in-kernel users */
69	atomic64_or(alert, &cpuhw->alert);
70	}
71
72	#define PMC_INIT 0
73	#define PMC_RELEASE 1
74	static void cpum_cf_setup_cpu(void *flags)
75	{
76	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);
77
78	switch (((int ) flags)) {
79	case PMC_INIT:
80	memset(&cpuhw->info, 0, sizeof(cpuhw->info));
81	qctri(&cpuhw->info);
82	cpuhw->flags \|= PMU_F_RESERVED;
83	break;
84
85	case PMC_RELEASE:
86	cpuhw->flags &= ~PMU_F_RESERVED;
87	break;
88	}
89
90	/* Disable CPU counter sets */
91	lcctl(0);
92	}
93
94	bool kernel_cpumcf_avail(void)
95	{
96	return cpum_cf_initalized;
97	}
98	EXPORT_SYMBOL(kernel_cpumcf_avail);
99
100
101	/* Reserve/release functions for sharing perf hardware */
102	static DEFINE_SPINLOCK(cpumcf_owner_lock);
103	static void *cpumcf_owner;
104
105	/* Initialize the CPU-measurement counter facility */
106	int __kernel_cpumcf_begin(void)
107	{
108	int flags = PMC_INIT;
109	int err = 0;
110
111	spin_lock(&cpumcf_owner_lock);
112	if (cpumcf_owner)
113	err = -EBUSY;
114	else
115	cpumcf_owner = __builtin_return_address(0);
116	spin_unlock(&cpumcf_owner_lock);
117	if (err)
118	return err;
119
120	on_each_cpu(cpum_cf_setup_cpu, &flags, 1);
121	irq_subclass_register(IRQ_SUBCLASS_MEASUREMENT_ALERT);
122
123	return 0;
124	}
125	EXPORT_SYMBOL(__kernel_cpumcf_begin);
126
127	/* Obtain the CPU-measurement alerts for the counter facility */
128	unsigned long kernel_cpumcf_alert(int clear)
129	{
130	struct cpu_cf_events *cpuhw = this_cpu_ptr(&cpu_cf_events);
131	unsigned long alert;
132
133	alert = atomic64_read(&cpuhw->alert);
134	if (clear)
135	atomic64_set(&cpuhw->alert, 0);
136
137	return alert;
138	}
139	EXPORT_SYMBOL(kernel_cpumcf_alert);
140
141	/* Release the CPU-measurement counter facility */
142	void __kernel_cpumcf_end(void)
143	{
144	int flags = PMC_RELEASE;
145
146	on_each_cpu(cpum_cf_setup_cpu, &flags, 1);
147	irq_subclass_unregister(IRQ_SUBCLASS_MEASUREMENT_ALERT);
148
149	spin_lock(&cpumcf_owner_lock);
150	cpumcf_owner = NULL;
151	spin_unlock(&cpumcf_owner_lock);
152	}
153	EXPORT_SYMBOL(__kernel_cpumcf_end);
154
155	static int cpum_cf_setup(unsigned int cpu, int flags)
156	{
157	local_irq_disable();
158	cpum_cf_setup_cpu(&flags);
159	local_irq_enable();
160	return 0;
161	}
162
163	static int cpum_cf_online_cpu(unsigned int cpu)
164	{
165	return cpum_cf_setup(cpu, PMC_INIT);
166	}
167
168	static int cpum_cf_offline_cpu(unsigned int cpu)
169	{
170	return cpum_cf_setup(cpu, PMC_RELEASE);
171	}
172
173	static int __init cpum_cf_init(void)
174	{
175	int rc;
176
177	if (!cpum_cf_avail())
178	return -ENODEV;
179
180	/* clear bit 15 of cr0 to unauthorize problem-state to
181	* extract measurement counters */
182	ctl_clear_bit(0, 48);
183
184	/* register handler for measurement-alert interruptions */
185	rc = register_external_irq(EXT_IRQ_MEASURE_ALERT,
186	cpumf_measurement_alert);
187	if (rc) {
188	pr_err("Registering for CPU-measurement alerts "
189	"failed with rc=%i\n", rc);
190	return rc;
191	}
192
193	rc = cpuhp_setup_state(CPUHP_AP_PERF_S390_CF_ONLINE,
194	"perf/s390/cf:online",
195	cpum_cf_online_cpu, cpum_cf_offline_cpu);
196	if (!rc)
197	cpum_cf_initalized = true;
198
199	return rc;
200	}
201	early_initcall(cpum_cf_init);