1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 * Debug and Guest Debug support
4
 *
5
 * Copyright (C) 2015 - Linaro Ltd
6
 * Authors: Alex Bennée <[email protected]>
7
 * 	    Oliver Upton <[email protected]>
8
 */
9

10
#include <linux/kvm_host.h>
11
#include <linux/hw_breakpoint.h>
12

13
#include <asm/debug-monitors.h>
14
#include <asm/kvm_asm.h>
15
#include <asm/kvm_arm.h>
16
#include <asm/kvm_emulate.h>
17

18
/**
19
 * kvm_arm_setup_mdcr_el2 - configure vcpu mdcr_el2 value
20
 *
21
 * @vcpu:	the vcpu pointer
22
 *
23
 * This ensures we will trap access to:
24
 *  - Performance monitors (MDCR_EL2_TPM/MDCR_EL2_TPMCR)
25
 *  - Debug ROM Address (MDCR_EL2_TDRA)
26
 *  - OS related registers (MDCR_EL2_TDOSA)
27
 *  - Statistical profiler (MDCR_EL2_TPMS/MDCR_EL2_E2PB)
28
 *  - Self-hosted Trace Filter controls (MDCR_EL2_TTRF)
29
 *  - Self-hosted Trace (MDCR_EL2_TTRF/MDCR_EL2_E2TB)
30
 */
31
static void kvm_arm_setup_mdcr_el2(struct kvm_vcpu *vcpu)
32
{
33
	preempt_disable();
34

35
	/*
36
	 * This also clears MDCR_EL2_E2PB_MASK and MDCR_EL2_E2TB_MASK
37
	 * to disable guest access to the profiling and trace buffers
38
	 */
39
	vcpu->arch.mdcr_el2 = FIELD_PREP(MDCR_EL2_HPMN,
40
					 *host_data_ptr(nr_event_counters));
41
	vcpu->arch.mdcr_el2 |= (MDCR_EL2_TPM |
42
				MDCR_EL2_TPMS |
43
				MDCR_EL2_TTRF |
44
				MDCR_EL2_TPMCR |
45
				MDCR_EL2_TDRA |
46
				MDCR_EL2_TDOSA);
47

48
	/* Is the VM being debugged by userspace? */
49
	if (vcpu->guest_debug)
50
		/* Route all software debug exceptions to EL2 */
51
		vcpu->arch.mdcr_el2 |= MDCR_EL2_TDE;
52

53
	/*
54
	 * Trap debug registers if the guest doesn't have ownership of them.
55
	 */
56
	if (!kvm_guest_owns_debug_regs(vcpu))
57
		vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA;
58

59
	if (vcpu_has_nv(vcpu))
60
		kvm_nested_setup_mdcr_el2(vcpu);
61

62
	/* Write MDCR_EL2 directly if we're already at EL2 */
63
	if (has_vhe())
64
		write_sysreg(vcpu->arch.mdcr_el2, mdcr_el2);
65

66
	preempt_enable();
67
}
68

69
void kvm_init_host_debug_data(void)
70
{
71
	u64 dfr0 = read_sysreg(id_aa64dfr0_el1);
72

73
	if (cpuid_feature_extract_signed_field(dfr0, ID_AA64DFR0_EL1_PMUVer_SHIFT) > 0)
74
		*host_data_ptr(nr_event_counters) = FIELD_GET(ARMV8_PMU_PMCR_N,
75
							      read_sysreg(pmcr_el0));
76

77
	*host_data_ptr(debug_brps) = SYS_FIELD_GET(ID_AA64DFR0_EL1, BRPs, dfr0);
78
	*host_data_ptr(debug_wrps) = SYS_FIELD_GET(ID_AA64DFR0_EL1, WRPs, dfr0);
79

80
	if (has_vhe())
81
		return;
82

83
	if (cpuid_feature_extract_unsigned_field(dfr0, ID_AA64DFR0_EL1_PMSVer_SHIFT) &&
84
	    !(read_sysreg_s(SYS_PMBIDR_EL1) & PMBIDR_EL1_P))
85
		host_data_set_flag(HAS_SPE);
86

87
	/* Check if we have BRBE implemented and available at the host */
88
	if (cpuid_feature_extract_unsigned_field(dfr0, ID_AA64DFR0_EL1_BRBE_SHIFT))
89
		host_data_set_flag(HAS_BRBE);
90

91
	if (cpuid_feature_extract_unsigned_field(dfr0, ID_AA64DFR0_EL1_TraceFilt_SHIFT)) {
92
		/* Force disable trace in protected mode in case of no TRBE */
93
		if (is_protected_kvm_enabled())
94
			host_data_set_flag(EL1_TRACING_CONFIGURED);
95

96
		if (cpuid_feature_extract_unsigned_field(dfr0, ID_AA64DFR0_EL1_TraceBuffer_SHIFT) &&
97
		    !(read_sysreg_s(SYS_TRBIDR_EL1) & TRBIDR_EL1_P))
98
			host_data_set_flag(HAS_TRBE);
99
	}
100
}
101

102
void kvm_debug_init_vhe(void)
103
{
104
	/* Clear PMSCR_EL1.E{0,1}SPE which reset to UNKNOWN values. */
105
	if (SYS_FIELD_GET(ID_AA64DFR0_EL1, PMSVer, read_sysreg(id_aa64dfr0_el1)))
106
		write_sysreg_el1(0, SYS_PMSCR);
107
}
108

109
/*
110
 * Configures the 'external' MDSCR_EL1 value for the guest, i.e. when the host
111
 * has taken over MDSCR_EL1.
112
 *
113
 *  - Userspace is single-stepping the guest, and MDSCR_EL1.SS is forced to 1.
114
 *
115
 *  - Userspace is using the breakpoint/watchpoint registers to debug the
116
 *    guest, and MDSCR_EL1.MDE is forced to 1.
117
 *
118
 *  - The guest has enabled the OS Lock, and KVM is forcing MDSCR_EL1.MDE to 0,
119
 *    masking all debug exceptions affected by the OS Lock.
120
 */
121
static void setup_external_mdscr(struct kvm_vcpu *vcpu)
122
{
123
	/*
124
	 * Use the guest's MDSCR_EL1 as a starting point, since there are
125
	 * several other features controlled by MDSCR_EL1 that are not relevant
126
	 * to the host.
127
	 *
128
	 * Clear the bits that KVM may use which also satisfies emulation of
129
	 * the OS Lock as MDSCR_EL1.MDE is cleared.
130
	 */
131
	u64 mdscr = vcpu_read_sys_reg(vcpu, MDSCR_EL1) & ~(MDSCR_EL1_SS |
132
							   MDSCR_EL1_MDE |
133
							   MDSCR_EL1_KDE);
134

135
	if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
136
		mdscr |= MDSCR_EL1_SS;
137

138
	if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW)
139
		mdscr |= MDSCR_EL1_MDE | MDSCR_EL1_KDE;
140

141
	vcpu->arch.external_mdscr_el1 = mdscr;
142
}
143

144
void kvm_vcpu_load_debug(struct kvm_vcpu *vcpu)
145
{
146
	u64 mdscr;
147

148
	/* Must be called before kvm_vcpu_load_vhe() */
149
	KVM_BUG_ON(vcpu_get_flag(vcpu, SYSREGS_ON_CPU), vcpu->kvm);
150

151
	if (has_vhe())
152
		*host_data_ptr(host_debug_state.mdcr_el2) = read_sysreg(mdcr_el2);
153

154
	/*
155
	 * Determine which of the possible debug states we're in:
156
	 *
157
	 *  - VCPU_DEBUG_HOST_OWNED: KVM has taken ownership of the guest's
158
	 *    breakpoint/watchpoint registers, or needs to use MDSCR_EL1 to do
159
	 *    software step or emulate the effects of the OS Lock being enabled.
160
	 *
161
	 *  - VCPU_DEBUG_GUEST_OWNED: The guest has debug exceptions enabled, and
162
	 *    the breakpoint/watchpoint registers need to be loaded eagerly.
163
	 *
164
	 *  - VCPU_DEBUG_FREE: Neither of the above apply, no breakpoint/watchpoint
165
	 *    context needs to be loaded on the CPU.
166
	 */
167
	if (vcpu->guest_debug || kvm_vcpu_os_lock_enabled(vcpu)) {
168
		vcpu->arch.debug_owner = VCPU_DEBUG_HOST_OWNED;
169
		setup_external_mdscr(vcpu);
170

171
		/*
172
		 * Steal the guest's single-step state machine if userspace wants
173
		 * single-step the guest.
174
		 */
175
		if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) {
176
			if (*vcpu_cpsr(vcpu) & DBG_SPSR_SS)
177
				vcpu_clear_flag(vcpu, GUEST_SS_ACTIVE_PENDING);
178
			else
179
				vcpu_set_flag(vcpu, GUEST_SS_ACTIVE_PENDING);
180

181
			if (!vcpu_get_flag(vcpu, HOST_SS_ACTIVE_PENDING))
182
				*vcpu_cpsr(vcpu) |= DBG_SPSR_SS;
183
			else
184
				*vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS;
185
		}
186
	} else {
187
		mdscr = vcpu_read_sys_reg(vcpu, MDSCR_EL1);
188

189
		if (mdscr & (MDSCR_EL1_KDE | MDSCR_EL1_MDE))
190
			vcpu->arch.debug_owner = VCPU_DEBUG_GUEST_OWNED;
191
		else
192
			vcpu->arch.debug_owner = VCPU_DEBUG_FREE;
193
	}
194

195
	kvm_arm_setup_mdcr_el2(vcpu);
196
}
197

198
void kvm_vcpu_put_debug(struct kvm_vcpu *vcpu)
199
{
200
	if (has_vhe())
201
		write_sysreg(*host_data_ptr(host_debug_state.mdcr_el2), mdcr_el2);
202

203
	if (likely(!(vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)))
204
		return;
205

206
	/*
207
	 * Save the host's software step state and restore the guest's before
208
	 * potentially returning to userspace.
209
	 */
210
	if (!(*vcpu_cpsr(vcpu) & DBG_SPSR_SS))
211
		vcpu_set_flag(vcpu, HOST_SS_ACTIVE_PENDING);
212
	else
213
		vcpu_clear_flag(vcpu, HOST_SS_ACTIVE_PENDING);
214

215
	if (vcpu_get_flag(vcpu, GUEST_SS_ACTIVE_PENDING))
216
		*vcpu_cpsr(vcpu) &= ~DBG_SPSR_SS;
217
	else
218
		*vcpu_cpsr(vcpu) |= DBG_SPSR_SS;
219
}
220

221
/*
222
 * Updates ownership of the debug registers after a trapped guest access to a
223
 * breakpoint/watchpoint register. Host ownership of the debug registers is of
224
 * strictly higher priority, and it is the responsibility of the VMM to emulate
225
 * guest debug exceptions in this configuration.
226
 */
227
void kvm_debug_set_guest_ownership(struct kvm_vcpu *vcpu)
228
{
229
	if (kvm_host_owns_debug_regs(vcpu))
230
		return;
231

232
	vcpu->arch.debug_owner = VCPU_DEBUG_GUEST_OWNED;
233
	kvm_arm_setup_mdcr_el2(vcpu);
234
}
235

236
void kvm_debug_handle_oslar(struct kvm_vcpu *vcpu, u64 val)
237
{
238
	if (val & OSLAR_EL1_OSLK)
239
		__vcpu_rmw_sys_reg(vcpu, OSLSR_EL1, |=, OSLSR_EL1_OSLK);
240
	else
241
		__vcpu_rmw_sys_reg(vcpu, OSLSR_EL1, &=, ~OSLSR_EL1_OSLK);
242

243
	preempt_disable();
244
	kvm_arch_vcpu_put(vcpu);
245
	kvm_arch_vcpu_load(vcpu, smp_processor_id());
246
	preempt_enable();
247
}
248

249
static bool skip_trbe_access(bool skip_condition)
250
{
251
	return (WARN_ON_ONCE(preemptible()) || skip_condition ||
252
		is_protected_kvm_enabled() || !is_kvm_arm_initialised());
253
}
254

255
void kvm_enable_trbe(void)
256
{
257
	if (!skip_trbe_access(has_vhe()))
258
		host_data_set_flag(TRBE_ENABLED);
259
}
260
EXPORT_SYMBOL_GPL(kvm_enable_trbe);
261

262
void kvm_disable_trbe(void)
263
{
264
	if (!skip_trbe_access(has_vhe()))
265
		host_data_clear_flag(TRBE_ENABLED);
266
}
267
EXPORT_SYMBOL_GPL(kvm_disable_trbe);
268

269
void kvm_tracing_set_el1_configuration(u64 trfcr_while_in_guest)
270
{
271
	if (skip_trbe_access(false))
272
		return;
273

274
	if (has_vhe()) {
275
		write_sysreg_s(trfcr_while_in_guest, SYS_TRFCR_EL12);
276
		return;
277
	}
278

279
	*host_data_ptr(trfcr_while_in_guest) = trfcr_while_in_guest;
280
	if (read_sysreg_s(SYS_TRFCR_EL1) != trfcr_while_in_guest)
281
		host_data_set_flag(EL1_TRACING_CONFIGURED);
282
	else
283
		host_data_clear_flag(EL1_TRACING_CONFIGURED);
284
}
285
EXPORT_SYMBOL_GPL(kvm_tracing_set_el1_configuration);
286

287