Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2011. Freescale Inc. All rights reserved.
4 *
5 * Authors:
6 * Alexander Graf <agraf@suse.de>
7 * Paul Mackerras <paulus@samba.org>
8 *
9 * Description:
10 *
11 * Hypercall handling for running PAPR guests in PR KVM on Book 3S
12 * processors.
13 */
14
15#include <linux/anon_inodes.h>
16
17#include <linux/uaccess.h>
18#include <asm/kvm_ppc.h>
19#include <asm/kvm_book3s.h>
20
21#define HPTE_SIZE 16 /* bytes per HPT entry */
22
23static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
24{
25 struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
26 unsigned long pteg_addr;
27
28 pte_index <<= 4;
29 pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70;
30 pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
31 pteg_addr |= pte_index;
32
33 return pteg_addr;
34}
35
36static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
37{
38 long flags = kvmppc_get_gpr(vcpu, 4);
39 long pte_index = kvmppc_get_gpr(vcpu, 5);
40 __be64 pteg[2 * 8];
41 __be64 *hpte;
42 unsigned long pteg_addr, i;
43 long int ret;
44
45 i = pte_index & 7;
46 pte_index &= ~7UL;
47 pteg_addr = get_pteg_addr(vcpu, pte_index);
48
49 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
50 ret = H_FUNCTION;
51 if (copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)))
52 goto done;
53 hpte = pteg;
54
55 ret = H_PTEG_FULL;
56 if (likely((flags & H_EXACT) == 0)) {
57 for (i = 0; ; ++i) {
58 if (i == 8)
59 goto done;
60 if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
61 break;
62 hpte += 2;
63 }
64 } else {
65 hpte += i * 2;
66 if (*hpte & HPTE_V_VALID)
67 goto done;
68 }
69
70 hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
71 hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
72 pteg_addr += i * HPTE_SIZE;
73 ret = H_FUNCTION;
74 if (copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE))
75 goto done;
76 kvmppc_set_gpr(vcpu, 4, pte_index | i);
77 ret = H_SUCCESS;
78
79 done:
80 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
81 kvmppc_set_gpr(vcpu, 3, ret);
82
83 return EMULATE_DONE;
84}
85
86static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
87{
88 unsigned long flags= kvmppc_get_gpr(vcpu, 4);
89 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
90 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
91 unsigned long v = 0, pteg, rb;
92 unsigned long pte[2];
93 long int ret;
94
95 pteg = get_pteg_addr(vcpu, pte_index);
96 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
97 ret = H_FUNCTION;
98 if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
99 goto done;
100 pte[0] = be64_to_cpu((__force __be64)pte[0]);
101 pte[1] = be64_to_cpu((__force __be64)pte[1]);
102
103 ret = H_NOT_FOUND;
104 if ((pte[0] & HPTE_V_VALID) == 0 ||
105 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
106 ((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
107 goto done;
108
109 ret = H_FUNCTION;
110 if (copy_to_user((void __user *)pteg, &v, sizeof(v)))
111 goto done;
112
113 rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
114 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
115
116 ret = H_SUCCESS;
117 kvmppc_set_gpr(vcpu, 4, pte[0]);
118 kvmppc_set_gpr(vcpu, 5, pte[1]);
119
120 done:
121 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
122 kvmppc_set_gpr(vcpu, 3, ret);
123
124 return EMULATE_DONE;
125}
126
127/* Request defs for kvmppc_h_pr_bulk_remove() */
128#define H_BULK_REMOVE_TYPE 0xc000000000000000ULL
129#define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL
130#define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL
131#define H_BULK_REMOVE_END 0xc000000000000000ULL
132#define H_BULK_REMOVE_CODE 0x3000000000000000ULL
133#define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL
134#define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL
135#define H_BULK_REMOVE_PARM 0x2000000000000000ULL
136#define H_BULK_REMOVE_HW 0x3000000000000000ULL
137#define H_BULK_REMOVE_RC 0x0c00000000000000ULL
138#define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL
139#define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL
140#define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL
141#define H_BULK_REMOVE_AVPN 0x0200000000000000ULL
142#define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL
143#define H_BULK_REMOVE_MAX_BATCH 4
144
145static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
146{
147 int i;
148 int paramnr = 4;
149 int ret = H_SUCCESS;
150
151 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
152 for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
153 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
154 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
155 unsigned long pteg, rb, flags;
156 unsigned long pte[2];
157 unsigned long v = 0;
158
159 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
160 break; /* Exit success */
161 } else if ((tsh & H_BULK_REMOVE_TYPE) !=
162 H_BULK_REMOVE_REQUEST) {
163 ret = H_PARAMETER;
164 break; /* Exit fail */
165 }
166
167 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
168 tsh |= H_BULK_REMOVE_RESPONSE;
169
170 if ((tsh & H_BULK_REMOVE_ANDCOND) &&
171 (tsh & H_BULK_REMOVE_AVPN)) {
172 tsh |= H_BULK_REMOVE_PARM;
173 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
174 ret = H_PARAMETER;
175 break; /* Exit fail */
176 }
177
178 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
179 if (copy_from_user(pte, (void __user *)pteg, sizeof(pte))) {
180 ret = H_FUNCTION;
181 break;
182 }
183 pte[0] = be64_to_cpu((__force __be64)pte[0]);
184 pte[1] = be64_to_cpu((__force __be64)pte[1]);
185
186 /* tsl = AVPN */
187 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;
188
189 if ((pte[0] & HPTE_V_VALID) == 0 ||
190 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
191 ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
192 tsh |= H_BULK_REMOVE_NOT_FOUND;
193 } else {
194 /* Splat the pteg in (userland) hpt */
195 if (copy_to_user((void __user *)pteg, &v, sizeof(v))) {
196 ret = H_FUNCTION;
197 break;
198 }
199
200 rb = compute_tlbie_rb(pte[0], pte[1],
201 tsh & H_BULK_REMOVE_PTEX);
202 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
203 tsh |= H_BULK_REMOVE_SUCCESS;
204 tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
205 }
206 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
207 }
208 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
209 kvmppc_set_gpr(vcpu, 3, ret);
210
211 return EMULATE_DONE;
212}
213
214static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
215{
216 unsigned long flags = kvmppc_get_gpr(vcpu, 4);
217 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
218 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
219 unsigned long rb, pteg, r, v;
220 unsigned long pte[2];
221 long int ret;
222
223 pteg = get_pteg_addr(vcpu, pte_index);
224 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
225 ret = H_FUNCTION;
226 if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
227 goto done;
228 pte[0] = be64_to_cpu((__force __be64)pte[0]);
229 pte[1] = be64_to_cpu((__force __be64)pte[1]);
230
231 ret = H_NOT_FOUND;
232 if ((pte[0] & HPTE_V_VALID) == 0 ||
233 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
234 goto done;
235
236 v = pte[0];
237 r = pte[1];
238 r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
239 HPTE_R_KEY_LO);
240 r |= (flags << 55) & HPTE_R_PP0;
241 r |= (flags << 48) & HPTE_R_KEY_HI;
242 r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
243
244 pte[1] = r;
245
246 rb = compute_tlbie_rb(v, r, pte_index);
247 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
248 pte[0] = (__force u64)cpu_to_be64(pte[0]);
249 pte[1] = (__force u64)cpu_to_be64(pte[1]);
250 ret = H_FUNCTION;
251 if (copy_to_user((void __user *)pteg, pte, sizeof(pte)))
252 goto done;
253 ret = H_SUCCESS;
254
255 done:
256 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
257 kvmppc_set_gpr(vcpu, 3, ret);
258
259 return EMULATE_DONE;
260}
261
262static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu)
263{
264 long rc;
265
266 rc = kvmppc_h_logical_ci_load(vcpu);
267 if (rc == H_TOO_HARD)
268 return EMULATE_FAIL;
269 kvmppc_set_gpr(vcpu, 3, rc);
270 return EMULATE_DONE;
271}
272
273static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu)
274{
275 long rc;
276
277 rc = kvmppc_h_logical_ci_store(vcpu);
278 if (rc == H_TOO_HARD)
279 return EMULATE_FAIL;
280 kvmppc_set_gpr(vcpu, 3, rc);
281 return EMULATE_DONE;
282}
283
284static int kvmppc_h_pr_set_mode(struct kvm_vcpu *vcpu)
285{
286 unsigned long mflags = kvmppc_get_gpr(vcpu, 4);
287 unsigned long resource = kvmppc_get_gpr(vcpu, 5);
288
289 if (resource == H_SET_MODE_RESOURCE_ADDR_TRANS_MODE) {
290 /* KVM PR does not provide AIL!=0 to guests */
291 if (mflags == 0)
292 kvmppc_set_gpr(vcpu, 3, H_SUCCESS);
293 else
294 kvmppc_set_gpr(vcpu, 3, H_UNSUPPORTED_FLAG_START - 63);
295 return EMULATE_DONE;
296 }
297 return EMULATE_FAIL;
298}
299
300#ifdef CONFIG_SPAPR_TCE_IOMMU
301static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
302{
303 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
304 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
305 unsigned long tce = kvmppc_get_gpr(vcpu, 6);
306 long rc;
307
308 rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
309 if (rc == H_TOO_HARD)
310 return EMULATE_FAIL;
311 kvmppc_set_gpr(vcpu, 3, rc);
312 return EMULATE_DONE;
313}
314
315static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
316{
317 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
318 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
319 unsigned long tce = kvmppc_get_gpr(vcpu, 6);
320 unsigned long npages = kvmppc_get_gpr(vcpu, 7);
321 long rc;
322
323 rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba,
324 tce, npages);
325 if (rc == H_TOO_HARD)
326 return EMULATE_FAIL;
327 kvmppc_set_gpr(vcpu, 3, rc);
328 return EMULATE_DONE;
329}
330
331static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
332{
333 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
334 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
335 unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
336 unsigned long npages = kvmppc_get_gpr(vcpu, 7);
337 long rc;
338
339 rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages);
340 if (rc == H_TOO_HARD)
341 return EMULATE_FAIL;
342 kvmppc_set_gpr(vcpu, 3, rc);
343 return EMULATE_DONE;
344}
345
346#else /* CONFIG_SPAPR_TCE_IOMMU */
347static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
348{
349 return EMULATE_FAIL;
350}
351
352static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
353{
354 return EMULATE_FAIL;
355}
356
357static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
358{
359 return EMULATE_FAIL;
360}
361#endif /* CONFIG_SPAPR_TCE_IOMMU */
362
363static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
364{
365 long rc = kvmppc_xics_hcall(vcpu, cmd);
366 kvmppc_set_gpr(vcpu, 3, rc);
367 return EMULATE_DONE;
368}
369
370int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
371{
372 int rc, idx;
373
374 if (cmd <= MAX_HCALL_OPCODE &&
375 !test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls))
376 return EMULATE_FAIL;
377
378 switch (cmd) {
379 case H_ENTER:
380 return kvmppc_h_pr_enter(vcpu);
381 case H_REMOVE:
382 return kvmppc_h_pr_remove(vcpu);
383 case H_PROTECT:
384 return kvmppc_h_pr_protect(vcpu);
385 case H_BULK_REMOVE:
386 return kvmppc_h_pr_bulk_remove(vcpu);
387 case H_PUT_TCE:
388 return kvmppc_h_pr_put_tce(vcpu);
389 case H_PUT_TCE_INDIRECT:
390 return kvmppc_h_pr_put_tce_indirect(vcpu);
391 case H_STUFF_TCE:
392 return kvmppc_h_pr_stuff_tce(vcpu);
393 case H_CEDE:
394 kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE);
395 kvm_vcpu_halt(vcpu);
396 vcpu->stat.generic.halt_wakeup++;
397 return EMULATE_DONE;
398 case H_LOGICAL_CI_LOAD:
399 return kvmppc_h_pr_logical_ci_load(vcpu);
400 case H_LOGICAL_CI_STORE:
401 return kvmppc_h_pr_logical_ci_store(vcpu);
402 case H_SET_MODE:
403 return kvmppc_h_pr_set_mode(vcpu);
404 case H_XIRR:
405 case H_CPPR:
406 case H_EOI:
407 case H_IPI:
408 case H_IPOLL:
409 case H_XIRR_X:
410 if (kvmppc_xics_enabled(vcpu))
411 return kvmppc_h_pr_xics_hcall(vcpu, cmd);
412 break;
413 case H_RTAS:
414 if (list_empty(&vcpu->kvm->arch.rtas_tokens))
415 break;
416 idx = srcu_read_lock(&vcpu->kvm->srcu);
417 rc = kvmppc_rtas_hcall(vcpu);
418 srcu_read_unlock(&vcpu->kvm->srcu, idx);
419 if (rc)
420 break;
421 kvmppc_set_gpr(vcpu, 3, 0);
422 return EMULATE_DONE;
423 }
424
425 return EMULATE_FAIL;
426}
427
428int kvmppc_hcall_impl_pr(unsigned long cmd)
429{
430 switch (cmd) {
431 case H_ENTER:
432 case H_REMOVE:
433 case H_PROTECT:
434 case H_BULK_REMOVE:
435#ifdef CONFIG_SPAPR_TCE_IOMMU
436 case H_GET_TCE:
437 case H_PUT_TCE:
438 case H_PUT_TCE_INDIRECT:
439 case H_STUFF_TCE:
440#endif
441 case H_CEDE:
442 case H_LOGICAL_CI_LOAD:
443 case H_LOGICAL_CI_STORE:
444 case H_SET_MODE:
445#ifdef CONFIG_KVM_XICS
446 case H_XIRR:
447 case H_CPPR:
448 case H_EOI:
449 case H_IPI:
450 case H_IPOLL:
451 case H_XIRR_X:
452#endif
453 return 1;
454 }
455 return 0;
456}
457
458/*
459 * List of hcall numbers to enable by default.
460 * For compatibility with old userspace, we enable by default
461 * all hcalls that were implemented before the hcall-enabling
462 * facility was added. Note this list should not include H_RTAS.
463 */
464static unsigned int default_hcall_list[] = {
465 H_ENTER,
466 H_REMOVE,
467 H_PROTECT,
468 H_BULK_REMOVE,
469#ifdef CONFIG_SPAPR_TCE_IOMMU
470 H_GET_TCE,
471 H_PUT_TCE,
472#endif
473 H_CEDE,
474 H_SET_MODE,
475#ifdef CONFIG_KVM_XICS
476 H_XIRR,
477 H_CPPR,
478 H_EOI,
479 H_IPI,
480 H_IPOLL,
481 H_XIRR_X,
482#endif
483 0
484};
485
486void kvmppc_pr_init_default_hcalls(struct kvm *kvm)
487{
488 int i;
489 unsigned int hcall;
490
491 for (i = 0; default_hcall_list[i]; ++i) {
492 hcall = default_hcall_list[i];
493 WARN_ON(!kvmppc_hcall_impl_pr(hcall));
494 __set_bit(hcall / 4, kvm->arch.enabled_hcalls);
495 }
496}
1/*
2 * Copyright (C) 2011. Freescale Inc. All rights reserved.
3 *
4 * Authors:
5 * Alexander Graf <agraf@suse.de>
6 * Paul Mackerras <paulus@samba.org>
7 *
8 * Description:
9 *
10 * Hypercall handling for running PAPR guests in PR KVM on Book 3S
11 * processors.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License, version 2, as
15 * published by the Free Software Foundation.
16 */
17
18#include <linux/anon_inodes.h>
19
20#include <asm/uaccess.h>
21#include <asm/kvm_ppc.h>
22#include <asm/kvm_book3s.h>
23
24#define HPTE_SIZE 16 /* bytes per HPT entry */
25
26static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
27{
28 struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
29 unsigned long pteg_addr;
30
31 pte_index <<= 4;
32 pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70;
33 pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
34 pteg_addr |= pte_index;
35
36 return pteg_addr;
37}
38
39static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
40{
41 long flags = kvmppc_get_gpr(vcpu, 4);
42 long pte_index = kvmppc_get_gpr(vcpu, 5);
43 __be64 pteg[2 * 8];
44 __be64 *hpte;
45 unsigned long pteg_addr, i;
46 long int ret;
47
48 i = pte_index & 7;
49 pte_index &= ~7UL;
50 pteg_addr = get_pteg_addr(vcpu, pte_index);
51
52 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
53 copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg));
54 hpte = pteg;
55
56 ret = H_PTEG_FULL;
57 if (likely((flags & H_EXACT) == 0)) {
58 for (i = 0; ; ++i) {
59 if (i == 8)
60 goto done;
61 if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
62 break;
63 hpte += 2;
64 }
65 } else {
66 hpte += i * 2;
67 if (*hpte & HPTE_V_VALID)
68 goto done;
69 }
70
71 hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
72 hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
73 pteg_addr += i * HPTE_SIZE;
74 copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE);
75 kvmppc_set_gpr(vcpu, 4, pte_index | i);
76 ret = H_SUCCESS;
77
78 done:
79 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
80 kvmppc_set_gpr(vcpu, 3, ret);
81
82 return EMULATE_DONE;
83}
84
85static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
86{
87 unsigned long flags= kvmppc_get_gpr(vcpu, 4);
88 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
89 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
90 unsigned long v = 0, pteg, rb;
91 unsigned long pte[2];
92 long int ret;
93
94 pteg = get_pteg_addr(vcpu, pte_index);
95 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
96 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
97 pte[0] = be64_to_cpu((__force __be64)pte[0]);
98 pte[1] = be64_to_cpu((__force __be64)pte[1]);
99
100 ret = H_NOT_FOUND;
101 if ((pte[0] & HPTE_V_VALID) == 0 ||
102 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
103 ((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
104 goto done;
105
106 copy_to_user((void __user *)pteg, &v, sizeof(v));
107
108 rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
109 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
110
111 ret = H_SUCCESS;
112 kvmppc_set_gpr(vcpu, 4, pte[0]);
113 kvmppc_set_gpr(vcpu, 5, pte[1]);
114
115 done:
116 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
117 kvmppc_set_gpr(vcpu, 3, ret);
118
119 return EMULATE_DONE;
120}
121
122/* Request defs for kvmppc_h_pr_bulk_remove() */
123#define H_BULK_REMOVE_TYPE 0xc000000000000000ULL
124#define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL
125#define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL
126#define H_BULK_REMOVE_END 0xc000000000000000ULL
127#define H_BULK_REMOVE_CODE 0x3000000000000000ULL
128#define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL
129#define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL
130#define H_BULK_REMOVE_PARM 0x2000000000000000ULL
131#define H_BULK_REMOVE_HW 0x3000000000000000ULL
132#define H_BULK_REMOVE_RC 0x0c00000000000000ULL
133#define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL
134#define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL
135#define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL
136#define H_BULK_REMOVE_AVPN 0x0200000000000000ULL
137#define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL
138#define H_BULK_REMOVE_MAX_BATCH 4
139
140static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
141{
142 int i;
143 int paramnr = 4;
144 int ret = H_SUCCESS;
145
146 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
147 for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
148 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
149 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
150 unsigned long pteg, rb, flags;
151 unsigned long pte[2];
152 unsigned long v = 0;
153
154 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
155 break; /* Exit success */
156 } else if ((tsh & H_BULK_REMOVE_TYPE) !=
157 H_BULK_REMOVE_REQUEST) {
158 ret = H_PARAMETER;
159 break; /* Exit fail */
160 }
161
162 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
163 tsh |= H_BULK_REMOVE_RESPONSE;
164
165 if ((tsh & H_BULK_REMOVE_ANDCOND) &&
166 (tsh & H_BULK_REMOVE_AVPN)) {
167 tsh |= H_BULK_REMOVE_PARM;
168 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
169 ret = H_PARAMETER;
170 break; /* Exit fail */
171 }
172
173 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
174 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
175 pte[0] = be64_to_cpu((__force __be64)pte[0]);
176 pte[1] = be64_to_cpu((__force __be64)pte[1]);
177
178 /* tsl = AVPN */
179 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;
180
181 if ((pte[0] & HPTE_V_VALID) == 0 ||
182 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
183 ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
184 tsh |= H_BULK_REMOVE_NOT_FOUND;
185 } else {
186 /* Splat the pteg in (userland) hpt */
187 copy_to_user((void __user *)pteg, &v, sizeof(v));
188
189 rb = compute_tlbie_rb(pte[0], pte[1],
190 tsh & H_BULK_REMOVE_PTEX);
191 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
192 tsh |= H_BULK_REMOVE_SUCCESS;
193 tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
194 }
195 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
196 }
197 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
198 kvmppc_set_gpr(vcpu, 3, ret);
199
200 return EMULATE_DONE;
201}
202
203static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
204{
205 unsigned long flags = kvmppc_get_gpr(vcpu, 4);
206 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
207 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
208 unsigned long rb, pteg, r, v;
209 unsigned long pte[2];
210 long int ret;
211
212 pteg = get_pteg_addr(vcpu, pte_index);
213 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
214 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
215 pte[0] = be64_to_cpu((__force __be64)pte[0]);
216 pte[1] = be64_to_cpu((__force __be64)pte[1]);
217
218 ret = H_NOT_FOUND;
219 if ((pte[0] & HPTE_V_VALID) == 0 ||
220 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
221 goto done;
222
223 v = pte[0];
224 r = pte[1];
225 r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
226 HPTE_R_KEY_LO);
227 r |= (flags << 55) & HPTE_R_PP0;
228 r |= (flags << 48) & HPTE_R_KEY_HI;
229 r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
230
231 pte[1] = r;
232
233 rb = compute_tlbie_rb(v, r, pte_index);
234 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
235 pte[0] = (__force u64)cpu_to_be64(pte[0]);
236 pte[1] = (__force u64)cpu_to_be64(pte[1]);
237 copy_to_user((void __user *)pteg, pte, sizeof(pte));
238 ret = H_SUCCESS;
239
240 done:
241 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
242 kvmppc_set_gpr(vcpu, 3, ret);
243
244 return EMULATE_DONE;
245}
246
247static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
248{
249 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
250 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
251 unsigned long tce = kvmppc_get_gpr(vcpu, 6);
252 long rc;
253
254 rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
255 if (rc == H_TOO_HARD)
256 return EMULATE_FAIL;
257 kvmppc_set_gpr(vcpu, 3, rc);
258 return EMULATE_DONE;
259}
260
261static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu)
262{
263 long rc;
264
265 rc = kvmppc_h_logical_ci_load(vcpu);
266 if (rc == H_TOO_HARD)
267 return EMULATE_FAIL;
268 kvmppc_set_gpr(vcpu, 3, rc);
269 return EMULATE_DONE;
270}
271
272static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu)
273{
274 long rc;
275
276 rc = kvmppc_h_logical_ci_store(vcpu);
277 if (rc == H_TOO_HARD)
278 return EMULATE_FAIL;
279 kvmppc_set_gpr(vcpu, 3, rc);
280 return EMULATE_DONE;
281}
282
283static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
284{
285 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
286 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
287 unsigned long tce = kvmppc_get_gpr(vcpu, 6);
288 unsigned long npages = kvmppc_get_gpr(vcpu, 7);
289 long rc;
290
291 rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba,
292 tce, npages);
293 if (rc == H_TOO_HARD)
294 return EMULATE_FAIL;
295 kvmppc_set_gpr(vcpu, 3, rc);
296 return EMULATE_DONE;
297}
298
299static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
300{
301 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
302 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
303 unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
304 unsigned long npages = kvmppc_get_gpr(vcpu, 7);
305 long rc;
306
307 rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages);
308 if (rc == H_TOO_HARD)
309 return EMULATE_FAIL;
310 kvmppc_set_gpr(vcpu, 3, rc);
311 return EMULATE_DONE;
312}
313
314static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
315{
316 long rc = kvmppc_xics_hcall(vcpu, cmd);
317 kvmppc_set_gpr(vcpu, 3, rc);
318 return EMULATE_DONE;
319}
320
321int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
322{
323 int rc, idx;
324
325 if (cmd <= MAX_HCALL_OPCODE &&
326 !test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls))
327 return EMULATE_FAIL;
328
329 switch (cmd) {
330 case H_ENTER:
331 return kvmppc_h_pr_enter(vcpu);
332 case H_REMOVE:
333 return kvmppc_h_pr_remove(vcpu);
334 case H_PROTECT:
335 return kvmppc_h_pr_protect(vcpu);
336 case H_BULK_REMOVE:
337 return kvmppc_h_pr_bulk_remove(vcpu);
338 case H_PUT_TCE:
339 return kvmppc_h_pr_put_tce(vcpu);
340 case H_PUT_TCE_INDIRECT:
341 return kvmppc_h_pr_put_tce_indirect(vcpu);
342 case H_STUFF_TCE:
343 return kvmppc_h_pr_stuff_tce(vcpu);
344 case H_CEDE:
345 kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE);
346 kvm_vcpu_block(vcpu);
347 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
348 vcpu->stat.halt_wakeup++;
349 return EMULATE_DONE;
350 case H_LOGICAL_CI_LOAD:
351 return kvmppc_h_pr_logical_ci_load(vcpu);
352 case H_LOGICAL_CI_STORE:
353 return kvmppc_h_pr_logical_ci_store(vcpu);
354 case H_XIRR:
355 case H_CPPR:
356 case H_EOI:
357 case H_IPI:
358 case H_IPOLL:
359 case H_XIRR_X:
360 if (kvmppc_xics_enabled(vcpu))
361 return kvmppc_h_pr_xics_hcall(vcpu, cmd);
362 break;
363 case H_RTAS:
364 if (list_empty(&vcpu->kvm->arch.rtas_tokens))
365 break;
366 idx = srcu_read_lock(&vcpu->kvm->srcu);
367 rc = kvmppc_rtas_hcall(vcpu);
368 srcu_read_unlock(&vcpu->kvm->srcu, idx);
369 if (rc)
370 break;
371 kvmppc_set_gpr(vcpu, 3, 0);
372 return EMULATE_DONE;
373 }
374
375 return EMULATE_FAIL;
376}
377
378int kvmppc_hcall_impl_pr(unsigned long cmd)
379{
380 switch (cmd) {
381 case H_ENTER:
382 case H_REMOVE:
383 case H_PROTECT:
384 case H_BULK_REMOVE:
385 case H_PUT_TCE:
386 case H_CEDE:
387 case H_LOGICAL_CI_LOAD:
388 case H_LOGICAL_CI_STORE:
389#ifdef CONFIG_KVM_XICS
390 case H_XIRR:
391 case H_CPPR:
392 case H_EOI:
393 case H_IPI:
394 case H_IPOLL:
395 case H_XIRR_X:
396#endif
397 return 1;
398 }
399 return 0;
400}
401
402/*
403 * List of hcall numbers to enable by default.
404 * For compatibility with old userspace, we enable by default
405 * all hcalls that were implemented before the hcall-enabling
406 * facility was added. Note this list should not include H_RTAS.
407 */
408static unsigned int default_hcall_list[] = {
409 H_ENTER,
410 H_REMOVE,
411 H_PROTECT,
412 H_BULK_REMOVE,
413 H_PUT_TCE,
414 H_CEDE,
415#ifdef CONFIG_KVM_XICS
416 H_XIRR,
417 H_CPPR,
418 H_EOI,
419 H_IPI,
420 H_IPOLL,
421 H_XIRR_X,
422#endif
423 0
424};
425
426void kvmppc_pr_init_default_hcalls(struct kvm *kvm)
427{
428 int i;
429 unsigned int hcall;
430
431 for (i = 0; default_hcall_list[i]; ++i) {
432 hcall = default_hcall_list[i];
433 WARN_ON(!kvmppc_hcall_impl_pr(hcall));
434 __set_bit(hcall / 4, kvm->arch.enabled_hcalls);
435 }
436}