1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2019 Arm Ltd.
3
4 #include <linux/arm-smccc.h>
5 #include <linux/kvm_host.h>
6
7 #include <asm/kvm_emulate.h>
8 #include <asm/stage2_pgtable.h>
9 #include <asm/kvm_pkvm.h>
10
11 #include <kvm/arm_hypercalls.h>
12 #include <kvm/arm_psci.h>
13
14 #define KVM_ARM_SMCCC_STD_FEATURES \
15 GENMASK(KVM_REG_ARM_STD_BMAP_BIT_COUNT - 1, 0)
16 #define KVM_ARM_SMCCC_STD_HYP_FEATURES \
17 GENMASK(KVM_REG_ARM_STD_HYP_BMAP_BIT_COUNT - 1, 0)
18 #define KVM_ARM_SMCCC_VENDOR_HYP_FEATURES ({ \
19 unsigned long f; \
20 f = GENMASK(KVM_REG_ARM_VENDOR_HYP_BMAP_BIT_COUNT - 1, 0); \
21 if (is_protected_kvm_enabled()) { \
22 f |= BIT(ARM_SMCCC_KVM_FUNC_HYP_MEMINFO); \
23 f |= BIT(ARM_SMCCC_KVM_FUNC_MEM_RELINQUISH); \
24 } \
25 f; \
26 })
27
kvm_ptp_get_time(struct kvm_vcpu * vcpu,u64 * val)28 static void kvm_ptp_get_time(struct kvm_vcpu *vcpu, u64 *val)
29 {
30 struct system_time_snapshot systime_snapshot;
31 u64 cycles = ~0UL;
32 u32 feature;
33
34 /*
35 * system time and counter value must captured at the same
36 * time to keep consistency and precision.
37 */
38 ktime_get_snapshot(&systime_snapshot);
39
40 /*
41 * This is only valid if the current clocksource is the
42 * architected counter, as this is the only one the guest
43 * can see.
44 */
45 if (systime_snapshot.cs_id != CSID_ARM_ARCH_COUNTER)
46 return;
47
48 /*
49 * The guest selects one of the two reference counters
50 * (virtual or physical) with the first argument of the SMCCC
51 * call. In case the identifier is not supported, error out.
52 */
53 feature = smccc_get_arg1(vcpu);
54 switch (feature) {
55 case KVM_PTP_VIRT_COUNTER:
56 cycles = systime_snapshot.cycles - vcpu->kvm->arch.timer_data.voffset;
57 break;
58 case KVM_PTP_PHYS_COUNTER:
59 cycles = systime_snapshot.cycles - vcpu->kvm->arch.timer_data.poffset;
60 break;
61 default:
62 return;
63 }
64
65 /*
66 * This relies on the top bit of val[0] never being set for
67 * valid values of system time, because that is *really* far
68 * in the future (about 292 years from 1970, and at that stage
69 * nobody will give a damn about it).
70 */
71 val[0] = upper_32_bits(systime_snapshot.real);
72 val[1] = lower_32_bits(systime_snapshot.real);
73 val[2] = upper_32_bits(cycles);
74 val[3] = lower_32_bits(cycles);
75 }
76
kvm_smccc_default_allowed(u32 func_id)77 static bool kvm_smccc_default_allowed(u32 func_id)
78 {
79 switch (func_id) {
80 /*
81 * List of function-ids that are not gated with the bitmapped
82 * feature firmware registers, and are to be allowed for
83 * servicing the call by default.
84 */
85 case ARM_SMCCC_VERSION_FUNC_ID:
86 case ARM_SMCCC_ARCH_FEATURES_FUNC_ID:
87 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_SHARE_FUNC_ID:
88 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_UNSHARE_FUNC_ID:
89 return true;
90 default:
91 /* PSCI 0.2 and up is in the 0:0x1f range */
92 if (ARM_SMCCC_OWNER_NUM(func_id) == ARM_SMCCC_OWNER_STANDARD &&
93 ARM_SMCCC_FUNC_NUM(func_id) <= 0x1f)
94 return true;
95
96 /*
97 * KVM's PSCI 0.1 doesn't comply with SMCCC, and has
98 * its own function-id base and range
99 */
100 if (func_id >= KVM_PSCI_FN(0) && func_id <= KVM_PSCI_FN(3))
101 return true;
102
103 return false;
104 }
105 }
106
kvm_smccc_test_fw_bmap(struct kvm_vcpu * vcpu,u32 func_id)107 static bool kvm_smccc_test_fw_bmap(struct kvm_vcpu *vcpu, u32 func_id)
108 {
109 struct kvm_smccc_features *smccc_feat = &vcpu->kvm->arch.smccc_feat;
110
111 switch (func_id) {
112 case ARM_SMCCC_TRNG_VERSION:
113 case ARM_SMCCC_TRNG_FEATURES:
114 case ARM_SMCCC_TRNG_GET_UUID:
115 case ARM_SMCCC_TRNG_RND32:
116 case ARM_SMCCC_TRNG_RND64:
117 return test_bit(KVM_REG_ARM_STD_BIT_TRNG_V1_0,
118 &smccc_feat->std_bmap);
119 case ARM_SMCCC_HV_PV_TIME_FEATURES:
120 case ARM_SMCCC_HV_PV_TIME_ST:
121 return test_bit(KVM_REG_ARM_STD_HYP_BIT_PV_TIME,
122 &smccc_feat->std_hyp_bmap);
123 case ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID:
124 case ARM_SMCCC_VENDOR_HYP_CALL_UID_FUNC_ID:
125 return test_bit(KVM_REG_ARM_VENDOR_HYP_BIT_FUNC_FEAT,
126 &smccc_feat->vendor_hyp_bmap);
127 case ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID:
128 return test_bit(KVM_REG_ARM_VENDOR_HYP_BIT_PTP,
129 &smccc_feat->vendor_hyp_bmap);
130 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_RELINQUISH_FUNC_ID:
131 return test_bit(ARM_SMCCC_KVM_FUNC_MEM_RELINQUISH,
132 &smccc_feat->vendor_hyp_bmap);
133 default:
134 return false;
135 }
136 }
137
138 #define SMC32_ARCH_RANGE_BEGIN ARM_SMCCC_VERSION_FUNC_ID
139 #define SMC32_ARCH_RANGE_END ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
140 ARM_SMCCC_SMC_32, \
141 0, ARM_SMCCC_FUNC_MASK)
142
143 #define SMC64_ARCH_RANGE_BEGIN ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
144 ARM_SMCCC_SMC_64, \
145 0, 0)
146 #define SMC64_ARCH_RANGE_END ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
147 ARM_SMCCC_SMC_64, \
148 0, ARM_SMCCC_FUNC_MASK)
149
init_smccc_filter(struct kvm * kvm)150 static void init_smccc_filter(struct kvm *kvm)
151 {
152 int r;
153
154 mt_init(&kvm->arch.smccc_filter);
155
156 /*
157 * Prevent userspace from handling any SMCCC calls in the architecture
158 * range, avoiding the risk of misrepresenting Spectre mitigation status
159 * to the guest.
160 */
161 r = mtree_insert_range(&kvm->arch.smccc_filter,
162 SMC32_ARCH_RANGE_BEGIN, SMC32_ARCH_RANGE_END,
163 xa_mk_value(KVM_SMCCC_FILTER_HANDLE),
164 GFP_KERNEL_ACCOUNT);
165 WARN_ON_ONCE(r);
166
167 r = mtree_insert_range(&kvm->arch.smccc_filter,
168 SMC64_ARCH_RANGE_BEGIN, SMC64_ARCH_RANGE_END,
169 xa_mk_value(KVM_SMCCC_FILTER_HANDLE),
170 GFP_KERNEL_ACCOUNT);
171 WARN_ON_ONCE(r);
172
173 }
174
kvm_smccc_set_filter(struct kvm * kvm,struct kvm_smccc_filter __user * uaddr)175 static int kvm_smccc_set_filter(struct kvm *kvm, struct kvm_smccc_filter __user *uaddr)
176 {
177 const void *zero_page = page_to_virt(ZERO_PAGE(0));
178 struct kvm_smccc_filter filter;
179 u32 start, end;
180 int r;
181
182 if (copy_from_user(&filter, uaddr, sizeof(filter)))
183 return -EFAULT;
184
185 if (memcmp(filter.pad, zero_page, sizeof(filter.pad)))
186 return -EINVAL;
187
188 start = filter.base;
189 end = start + filter.nr_functions - 1;
190
191 if (end < start || filter.action >= NR_SMCCC_FILTER_ACTIONS)
192 return -EINVAL;
193
194 mutex_lock(&kvm->arch.config_lock);
195
196 if (kvm_vm_has_ran_once(kvm)) {
197 r = -EBUSY;
198 goto out_unlock;
199 }
200
201 r = mtree_insert_range(&kvm->arch.smccc_filter, start, end,
202 xa_mk_value(filter.action), GFP_KERNEL_ACCOUNT);
203 if (r)
204 goto out_unlock;
205
206 set_bit(KVM_ARCH_FLAG_SMCCC_FILTER_CONFIGURED, &kvm->arch.flags);
207
208 out_unlock:
209 mutex_unlock(&kvm->arch.config_lock);
210 return r;
211 }
212
kvm_smccc_filter_get_action(struct kvm * kvm,u32 func_id)213 static u8 kvm_smccc_filter_get_action(struct kvm *kvm, u32 func_id)
214 {
215 unsigned long idx = func_id;
216 void *val;
217
218 if (!test_bit(KVM_ARCH_FLAG_SMCCC_FILTER_CONFIGURED, &kvm->arch.flags))
219 return KVM_SMCCC_FILTER_HANDLE;
220
221 /*
222 * But where's the error handling, you say?
223 *
224 * mt_find() returns NULL if no entry was found, which just so happens
225 * to match KVM_SMCCC_FILTER_HANDLE.
226 */
227 val = mt_find(&kvm->arch.smccc_filter, &idx, idx);
228 return xa_to_value(val);
229 }
230
kvm_smccc_get_action(struct kvm_vcpu * vcpu,u32 func_id)231 static u8 kvm_smccc_get_action(struct kvm_vcpu *vcpu, u32 func_id)
232 {
233 /*
234 * Intervening actions in the SMCCC filter take precedence over the
235 * pseudo-firmware register bitmaps.
236 */
237 u8 action = kvm_smccc_filter_get_action(vcpu->kvm, func_id);
238 if (action != KVM_SMCCC_FILTER_HANDLE)
239 return action;
240
241 if (kvm_smccc_test_fw_bmap(vcpu, func_id) ||
242 kvm_smccc_default_allowed(func_id))
243 return KVM_SMCCC_FILTER_HANDLE;
244
245 return KVM_SMCCC_FILTER_DENY;
246 }
247
kvm_prepare_hypercall_exit(struct kvm_vcpu * vcpu,u32 func_id)248 static void kvm_prepare_hypercall_exit(struct kvm_vcpu *vcpu, u32 func_id)
249 {
250 u8 ec = ESR_ELx_EC(kvm_vcpu_get_esr(vcpu));
251 struct kvm_run *run = vcpu->run;
252 u64 flags = 0;
253
254 if (ec == ESR_ELx_EC_SMC32 || ec == ESR_ELx_EC_SMC64)
255 flags |= KVM_HYPERCALL_EXIT_SMC;
256
257 if (!kvm_vcpu_trap_il_is32bit(vcpu))
258 flags |= KVM_HYPERCALL_EXIT_16BIT;
259
260 run->exit_reason = KVM_EXIT_HYPERCALL;
261 run->hypercall = (typeof(run->hypercall)) {
262 .nr = func_id,
263 .flags = flags,
264 };
265 }
266
kvm_smccc_call_handler(struct kvm_vcpu * vcpu)267 int kvm_smccc_call_handler(struct kvm_vcpu *vcpu)
268 {
269 struct kvm_smccc_features *smccc_feat = &vcpu->kvm->arch.smccc_feat;
270 u32 func_id = smccc_get_function(vcpu);
271 u64 val[4] = {SMCCC_RET_NOT_SUPPORTED};
272 u32 feature;
273 u8 action;
274 gpa_t gpa;
275
276 action = kvm_smccc_get_action(vcpu, func_id);
277 switch (action) {
278 case KVM_SMCCC_FILTER_HANDLE:
279 break;
280 case KVM_SMCCC_FILTER_DENY:
281 goto out;
282 case KVM_SMCCC_FILTER_FWD_TO_USER:
283 kvm_prepare_hypercall_exit(vcpu, func_id);
284 return 0;
285 default:
286 WARN_RATELIMIT(1, "Unhandled SMCCC filter action: %d\n", action);
287 goto out;
288 }
289
290 switch (func_id) {
291 case ARM_SMCCC_VERSION_FUNC_ID:
292 val[0] = ARM_SMCCC_VERSION_1_1;
293 break;
294 case ARM_SMCCC_ARCH_FEATURES_FUNC_ID:
295 feature = smccc_get_arg1(vcpu);
296 switch (feature) {
297 case ARM_SMCCC_ARCH_WORKAROUND_1:
298 switch (arm64_get_spectre_v2_state()) {
299 case SPECTRE_VULNERABLE:
300 break;
301 case SPECTRE_MITIGATED:
302 val[0] = SMCCC_RET_SUCCESS;
303 break;
304 case SPECTRE_UNAFFECTED:
305 val[0] = SMCCC_ARCH_WORKAROUND_RET_UNAFFECTED;
306 break;
307 }
308 break;
309 case ARM_SMCCC_ARCH_WORKAROUND_2:
310 switch (arm64_get_spectre_v4_state()) {
311 case SPECTRE_VULNERABLE:
312 break;
313 case SPECTRE_MITIGATED:
314 /*
315 * SSBS everywhere: Indicate no firmware
316 * support, as the SSBS support will be
317 * indicated to the guest and the default is
318 * safe.
319 *
320 * Otherwise, expose a permanent mitigation
321 * to the guest, and hide SSBS so that the
322 * guest stays protected.
323 */
324 if (cpus_have_final_cap(ARM64_SSBS))
325 break;
326 fallthrough;
327 case SPECTRE_UNAFFECTED:
328 val[0] = SMCCC_RET_NOT_REQUIRED;
329 break;
330 }
331 break;
332 case ARM_SMCCC_ARCH_WORKAROUND_3:
333 switch (arm64_get_spectre_bhb_state()) {
334 case SPECTRE_VULNERABLE:
335 break;
336 case SPECTRE_MITIGATED:
337 val[0] = SMCCC_RET_SUCCESS;
338 break;
339 case SPECTRE_UNAFFECTED:
340 val[0] = SMCCC_ARCH_WORKAROUND_RET_UNAFFECTED;
341 break;
342 }
343 break;
344 case ARM_SMCCC_HV_PV_TIME_FEATURES:
345 if (test_bit(KVM_REG_ARM_STD_HYP_BIT_PV_TIME,
346 &smccc_feat->std_hyp_bmap))
347 val[0] = SMCCC_RET_SUCCESS;
348 break;
349 }
350 break;
351 case ARM_SMCCC_HV_PV_TIME_FEATURES:
352 val[0] = kvm_hypercall_pv_features(vcpu);
353 break;
354 case ARM_SMCCC_HV_PV_TIME_ST:
355 gpa = kvm_init_stolen_time(vcpu);
356 if (gpa != INVALID_GPA)
357 val[0] = gpa;
358 break;
359 case ARM_SMCCC_VENDOR_HYP_CALL_UID_FUNC_ID:
360 val[0] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_0;
361 val[1] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_1;
362 val[2] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_2;
363 val[3] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_3;
364 break;
365 case ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID:
366 val[0] = smccc_feat->vendor_hyp_bmap;
367 break;
368 case ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID:
369 kvm_ptp_get_time(vcpu, val);
370 break;
371 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_RELINQUISH_FUNC_ID:
372 pkvm_host_reclaim_page(vcpu->kvm, smccc_get_arg1(vcpu));
373 val[0] = SMCCC_RET_SUCCESS;
374 break;
375 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_SHARE_FUNC_ID:
376 case ARM_SMCCC_VENDOR_HYP_KVM_MEM_UNSHARE_FUNC_ID:
377 if (!kvm_vm_is_protected(vcpu->kvm))
378 break;
379 atomic64_add(
380 func_id == ARM_SMCCC_VENDOR_HYP_KVM_MEM_SHARE_FUNC_ID ?
381 PAGE_SIZE : -PAGE_SIZE,
382 &vcpu->kvm->stat.protected_shared_mem);
383 val[0] = SMCCC_RET_SUCCESS;
384 break;
385 case ARM_SMCCC_TRNG_VERSION:
386 case ARM_SMCCC_TRNG_FEATURES:
387 case ARM_SMCCC_TRNG_GET_UUID:
388 case ARM_SMCCC_TRNG_RND32:
389 case ARM_SMCCC_TRNG_RND64:
390 return kvm_trng_call(vcpu);
391 default:
392 return kvm_psci_call(vcpu);
393 }
394
395 out:
396 smccc_set_retval(vcpu, val[0], val[1], val[2], val[3]);
397 return 1;
398 }
399
400 static const u64 kvm_arm_fw_reg_ids[] = {
401 KVM_REG_ARM_PSCI_VERSION,
402 KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1,
403 KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2,
404 KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3,
405 KVM_REG_ARM_STD_BMAP,
406 KVM_REG_ARM_STD_HYP_BMAP,
407 KVM_REG_ARM_VENDOR_HYP_BMAP,
408 };
409
kvm_arm_init_hypercalls(struct kvm * kvm)410 void kvm_arm_init_hypercalls(struct kvm *kvm)
411 {
412 struct kvm_smccc_features *smccc_feat = &kvm->arch.smccc_feat;
413
414 smccc_feat->std_bmap = KVM_ARM_SMCCC_STD_FEATURES;
415 smccc_feat->std_hyp_bmap = KVM_ARM_SMCCC_STD_HYP_FEATURES;
416 smccc_feat->vendor_hyp_bmap = KVM_ARM_SMCCC_VENDOR_HYP_FEATURES;
417
418 init_smccc_filter(kvm);
419 }
420
kvm_arm_teardown_hypercalls(struct kvm * kvm)421 void kvm_arm_teardown_hypercalls(struct kvm *kvm)
422 {
423 mtree_destroy(&kvm->arch.smccc_filter);
424 }
425
kvm_arm_get_fw_num_regs(struct kvm_vcpu * vcpu)426 int kvm_arm_get_fw_num_regs(struct kvm_vcpu *vcpu)
427 {
428 return ARRAY_SIZE(kvm_arm_fw_reg_ids);
429 }
430
kvm_arm_copy_fw_reg_indices(struct kvm_vcpu * vcpu,u64 __user * uindices)431 int kvm_arm_copy_fw_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
432 {
433 int i;
434
435 for (i = 0; i < ARRAY_SIZE(kvm_arm_fw_reg_ids); i++) {
436 if (put_user(kvm_arm_fw_reg_ids[i], uindices++))
437 return -EFAULT;
438 }
439
440 return 0;
441 }
442
443 #define KVM_REG_FEATURE_LEVEL_MASK GENMASK(3, 0)
444
445 /*
446 * Convert the workaround level into an easy-to-compare number, where higher
447 * values mean better protection.
448 */
get_kernel_wa_level(u64 regid)449 static int get_kernel_wa_level(u64 regid)
450 {
451 switch (regid) {
452 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1:
453 switch (arm64_get_spectre_v2_state()) {
454 case SPECTRE_VULNERABLE:
455 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL;
456 case SPECTRE_MITIGATED:
457 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL;
458 case SPECTRE_UNAFFECTED:
459 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_REQUIRED;
460 }
461 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL;
462 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2:
463 switch (arm64_get_spectre_v4_state()) {
464 case SPECTRE_MITIGATED:
465 /*
466 * As for the hypercall discovery, we pretend we
467 * don't have any FW mitigation if SSBS is there at
468 * all times.
469 */
470 if (cpus_have_final_cap(ARM64_SSBS))
471 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL;
472 fallthrough;
473 case SPECTRE_UNAFFECTED:
474 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_REQUIRED;
475 case SPECTRE_VULNERABLE:
476 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL;
477 }
478 break;
479 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3:
480 switch (arm64_get_spectre_bhb_state()) {
481 case SPECTRE_VULNERABLE:
482 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3_NOT_AVAIL;
483 case SPECTRE_MITIGATED:
484 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3_AVAIL;
485 case SPECTRE_UNAFFECTED:
486 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3_NOT_REQUIRED;
487 }
488 return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3_NOT_AVAIL;
489 }
490
491 return -EINVAL;
492 }
493
kvm_arm_get_fw_reg(struct kvm_vcpu * vcpu,const struct kvm_one_reg * reg)494 int kvm_arm_get_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
495 {
496 struct kvm_smccc_features *smccc_feat = &vcpu->kvm->arch.smccc_feat;
497 void __user *uaddr = (void __user *)(long)reg->addr;
498 u64 val;
499
500 switch (reg->id) {
501 case KVM_REG_ARM_PSCI_VERSION:
502 val = kvm_psci_version(vcpu);
503 break;
504 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1:
505 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2:
506 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3:
507 val = get_kernel_wa_level(reg->id) & KVM_REG_FEATURE_LEVEL_MASK;
508 break;
509 case KVM_REG_ARM_STD_BMAP:
510 val = READ_ONCE(smccc_feat->std_bmap);
511 break;
512 case KVM_REG_ARM_STD_HYP_BMAP:
513 val = READ_ONCE(smccc_feat->std_hyp_bmap);
514 break;
515 case KVM_REG_ARM_VENDOR_HYP_BMAP:
516 val = READ_ONCE(smccc_feat->vendor_hyp_bmap);
517 break;
518 default:
519 return -ENOENT;
520 }
521
522 if (copy_to_user(uaddr, &val, KVM_REG_SIZE(reg->id)))
523 return -EFAULT;
524
525 return 0;
526 }
527
kvm_arm_set_fw_reg_bmap(struct kvm_vcpu * vcpu,u64 reg_id,u64 val)528 static int kvm_arm_set_fw_reg_bmap(struct kvm_vcpu *vcpu, u64 reg_id, u64 val)
529 {
530 int ret = 0;
531 struct kvm *kvm = vcpu->kvm;
532 struct kvm_smccc_features *smccc_feat = &kvm->arch.smccc_feat;
533 unsigned long *fw_reg_bmap, fw_reg_features;
534
535 switch (reg_id) {
536 case KVM_REG_ARM_STD_BMAP:
537 fw_reg_bmap = &smccc_feat->std_bmap;
538 fw_reg_features = KVM_ARM_SMCCC_STD_FEATURES;
539 break;
540 case KVM_REG_ARM_STD_HYP_BMAP:
541 fw_reg_bmap = &smccc_feat->std_hyp_bmap;
542 fw_reg_features = KVM_ARM_SMCCC_STD_HYP_FEATURES;
543 break;
544 case KVM_REG_ARM_VENDOR_HYP_BMAP:
545 fw_reg_bmap = &smccc_feat->vendor_hyp_bmap;
546 fw_reg_features = KVM_ARM_SMCCC_VENDOR_HYP_FEATURES;
547 break;
548 default:
549 return -ENOENT;
550 }
551
552 /* Check for unsupported bit */
553 if (val & ~fw_reg_features)
554 return -EINVAL;
555
556 mutex_lock(&kvm->arch.config_lock);
557
558 if (kvm_vm_has_ran_once(kvm) && val != *fw_reg_bmap) {
559 ret = -EBUSY;
560 goto out;
561 }
562
563 WRITE_ONCE(*fw_reg_bmap, val);
564 out:
565 mutex_unlock(&kvm->arch.config_lock);
566 return ret;
567 }
568
kvm_arm_set_fw_reg(struct kvm_vcpu * vcpu,const struct kvm_one_reg * reg)569 int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
570 {
571 void __user *uaddr = (void __user *)(long)reg->addr;
572 u64 val;
573 int wa_level;
574
575 if (KVM_REG_SIZE(reg->id) != sizeof(val))
576 return -ENOENT;
577 if (copy_from_user(&val, uaddr, KVM_REG_SIZE(reg->id)))
578 return -EFAULT;
579
580 switch (reg->id) {
581 case KVM_REG_ARM_PSCI_VERSION:
582 {
583 bool wants_02;
584
585 wants_02 = test_bit(KVM_ARM_VCPU_PSCI_0_2, vcpu->arch.features);
586
587 switch (val) {
588 case KVM_ARM_PSCI_0_1:
589 if (wants_02)
590 return -EINVAL;
591 vcpu->kvm->arch.psci_version = val;
592 return 0;
593 case KVM_ARM_PSCI_0_2:
594 case KVM_ARM_PSCI_1_0:
595 case KVM_ARM_PSCI_1_1:
596 if (!wants_02)
597 return -EINVAL;
598 vcpu->kvm->arch.psci_version = val;
599 return 0;
600 }
601 break;
602 }
603
604 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1:
605 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3:
606 if (val & ~KVM_REG_FEATURE_LEVEL_MASK)
607 return -EINVAL;
608
609 if (get_kernel_wa_level(reg->id) < val)
610 return -EINVAL;
611
612 return 0;
613
614 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2:
615 if (val & ~(KVM_REG_FEATURE_LEVEL_MASK |
616 KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED))
617 return -EINVAL;
618
619 /* The enabled bit must not be set unless the level is AVAIL. */
620 if ((val & KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED) &&
621 (val & KVM_REG_FEATURE_LEVEL_MASK) != KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL)
622 return -EINVAL;
623
624 /*
625 * Map all the possible incoming states to the only two we
626 * really want to deal with.
627 */
628 switch (val & KVM_REG_FEATURE_LEVEL_MASK) {
629 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL:
630 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN:
631 wa_level = KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL;
632 break;
633 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL:
634 case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_REQUIRED:
635 wa_level = KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_REQUIRED;
636 break;
637 default:
638 return -EINVAL;
639 }
640
641 /*
642 * We can deal with NOT_AVAIL on NOT_REQUIRED, but not the
643 * other way around.
644 */
645 if (get_kernel_wa_level(reg->id) < wa_level)
646 return -EINVAL;
647
648 return 0;
649 case KVM_REG_ARM_STD_BMAP:
650 case KVM_REG_ARM_STD_HYP_BMAP:
651 case KVM_REG_ARM_VENDOR_HYP_BMAP:
652 return kvm_arm_set_fw_reg_bmap(vcpu, reg->id, val);
653 default:
654 return -ENOENT;
655 }
656
657 return -EINVAL;
658 }
659
kvm_vm_smccc_has_attr(struct kvm * kvm,struct kvm_device_attr * attr)660 int kvm_vm_smccc_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
661 {
662 switch (attr->attr) {
663 case KVM_ARM_VM_SMCCC_FILTER:
664 return 0;
665 default:
666 return -ENXIO;
667 }
668 }
669
kvm_vm_smccc_set_attr(struct kvm * kvm,struct kvm_device_attr * attr)670 int kvm_vm_smccc_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
671 {
672 void __user *uaddr = (void __user *)attr->addr;
673
674 switch (attr->attr) {
675 case KVM_ARM_VM_SMCCC_FILTER:
676 return kvm_smccc_set_filter(kvm, uaddr);
677 default:
678 return -ENXIO;
679 }
680 }
681