projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
KVM: PPC: PR: Fill pvinfo hcall instructions in big endian
[linux-block.git] / arch / powerpc / kvm / book3s_pr_papr.c
CommitLineData
0254f074
AG		 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
f31e65e1
BH		 18#include <linux/anon_inodes.h>
19
0254f074
AG		 20#include <asm/uaccess.h>
21#include <asm/kvm_ppc.h>
22#include <asm/kvm_book3s.h>
23
5cd92a95
PM		 24#define HPTE_SIZE 16 /* bytes per HPT entry */
25
0254f074
AG		 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 unsigned long pteg[2 * 8];
44 unsigned long pteg_addr, i, *hpte;
5cd92a95 45 long int ret;
0254f074 46
5cd92a95 47 i = pte_index & 7;
0254f074
AG		 48 pte_index &= ~7UL;
49 pteg_addr = get_pteg_addr(vcpu, pte_index);
50
9308ab8e 51 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
0254f074
AG		 52 copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg));
53 hpte = pteg;
54
5cd92a95 55 ret = H_PTEG_FULL;
0254f074 56 if (likely((flags & H_EXACT) == 0)) {
0254f074
AG		 57 for (i = 0; ; ++i) {
58 if (i == 8)
5cd92a95 59 goto done;
1692aa3f 60 if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
0254f074
AG		 61 break;
62 hpte += 2;
63 }
64 } else {
0254f074 65 hpte += i * 2;
5cd92a95
PM		 66 if (*hpte & HPTE_V_VALID)
67 goto done;
0254f074
AG		 68 }
69
1692aa3f
AG		 70 hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
71 hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
5cd92a95
PM		 72 pteg_addr += i * HPTE_SIZE;
73 copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE);
0254f074 74 kvmppc_set_gpr(vcpu, 4, pte_index | i);
5cd92a95
PM		 75 ret = H_SUCCESS;
76
77 done:
9308ab8e 78 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
5cd92a95 79 kvmppc_set_gpr(vcpu, 3, ret);
0254f074
AG		 80
81 return EMULATE_DONE;
82}
83
84static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
85{
86 unsigned long flags= kvmppc_get_gpr(vcpu, 4);
87 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
88 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
89 unsigned long v = 0, pteg, rb;
90 unsigned long pte[2];
9308ab8e 91 long int ret;
0254f074
AG		 92
93 pteg = get_pteg_addr(vcpu, pte_index);
9308ab8e 94 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
0254f074 95 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
1692aa3f
AG		 96 pte[0] = be64_to_cpu(pte[0]);
97 pte[1] = be64_to_cpu(pte[1]);
0254f074 98
9308ab8e 99 ret = H_NOT_FOUND;
0254f074
AG		 100 if ((pte[0] & HPTE_V_VALID) == 0 ||
101 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
9308ab8e
PM		 102 ((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
103 goto done;
0254f074
AG		 104
105 copy_to_user((void __user *)pteg, &v, sizeof(v));
106
107 rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
108 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
109
9308ab8e 110 ret = H_SUCCESS;
0254f074
AG		 111 kvmppc_set_gpr(vcpu, 4, pte[0]);
112 kvmppc_set_gpr(vcpu, 5, pte[1]);
113
9308ab8e
PM		 114 done:
115 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
116 kvmppc_set_gpr(vcpu, 3, ret);
117
0254f074
AG		 118 return EMULATE_DONE;
119}
120
3aaefef2
ME		 121/* Request defs for kvmppc_h_pr_bulk_remove() */
122#define H_BULK_REMOVE_TYPE 0xc000000000000000ULL
123#define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL
124#define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL
125#define H_BULK_REMOVE_END 0xc000000000000000ULL
126#define H_BULK_REMOVE_CODE 0x3000000000000000ULL
127#define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL
128#define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL
129#define H_BULK_REMOVE_PARM 0x2000000000000000ULL
130#define H_BULK_REMOVE_HW 0x3000000000000000ULL
131#define H_BULK_REMOVE_RC 0x0c00000000000000ULL
132#define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL
133#define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL
134#define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL
135#define H_BULK_REMOVE_AVPN 0x0200000000000000ULL
136#define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL
137#define H_BULK_REMOVE_MAX_BATCH 4
138
139static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
140{
141 int i;
142 int paramnr = 4;
143 int ret = H_SUCCESS;
144
9308ab8e 145 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
3aaefef2
ME		 146 for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
147 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
148 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
149 unsigned long pteg, rb, flags;
150 unsigned long pte[2];
151 unsigned long v = 0;
152
153 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
154 break; /* Exit success */
155 } else if ((tsh & H_BULK_REMOVE_TYPE) !=
156 H_BULK_REMOVE_REQUEST) {
157 ret = H_PARAMETER;
158 break; /* Exit fail */
159 }
160
161 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
162 tsh |= H_BULK_REMOVE_RESPONSE;
163
164 if ((tsh & H_BULK_REMOVE_ANDCOND) &&
165 (tsh & H_BULK_REMOVE_AVPN)) {
166 tsh |= H_BULK_REMOVE_PARM;
167 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
168 ret = H_PARAMETER;
169 break; /* Exit fail */
170 }
171
172 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
173 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
1692aa3f
AG		 174 pte[0] = be64_to_cpu(pte[0]);
175 pte[1] = be64_to_cpu(pte[1]);
3aaefef2
ME		 176
177 /* tsl = AVPN */
178 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;
179
180 if ((pte[0] & HPTE_V_VALID) == 0 ||
181 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
182 ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
183 tsh |= H_BULK_REMOVE_NOT_FOUND;
184 } else {
185 /* Splat the pteg in (userland) hpt */
186 copy_to_user((void __user *)pteg, &v, sizeof(v));
187
188 rb = compute_tlbie_rb(pte[0], pte[1],
189 tsh & H_BULK_REMOVE_PTEX);
190 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
191 tsh |= H_BULK_REMOVE_SUCCESS;
192 tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
193 }
194 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
195 }
9308ab8e 196 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
3aaefef2
ME		 197 kvmppc_set_gpr(vcpu, 3, ret);
198
199 return EMULATE_DONE;
200}
201
0254f074
AG		 202static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
203{
204 unsigned long flags = kvmppc_get_gpr(vcpu, 4);
205 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
206 unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
207 unsigned long rb, pteg, r, v;
208 unsigned long pte[2];
9308ab8e 209 long int ret;
0254f074
AG		 210
211 pteg = get_pteg_addr(vcpu, pte_index);
9308ab8e 212 mutex_lock(&vcpu->kvm->arch.hpt_mutex);
0254f074 213 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
1692aa3f
AG		 214 pte[0] = be64_to_cpu(pte[0]);
215 pte[1] = be64_to_cpu(pte[1]);
0254f074 216
9308ab8e 217 ret = H_NOT_FOUND;
0254f074 218 if ((pte[0] & HPTE_V_VALID) == 0 ||
9308ab8e
PM		 219 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
220 goto done;
0254f074
AG		 221
222 v = pte[0];
223 r = pte[1];
224 r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
225 HPTE_R_KEY_LO);
226 r |= (flags << 55) & HPTE_R_PP0;
227 r |= (flags << 48) & HPTE_R_KEY_HI;
228 r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
229
230 pte[1] = r;
231
232 rb = compute_tlbie_rb(v, r, pte_index);
233 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
1692aa3f
AG		 234 pte[0] = cpu_to_be64(pte[0]);
235 pte[1] = cpu_to_be64(pte[1]);
0254f074 236 copy_to_user((void __user *)pteg, pte, sizeof(pte));
9308ab8e 237 ret = H_SUCCESS;
0254f074 238
9308ab8e
PM		 239 done:
240 mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
241 kvmppc_set_gpr(vcpu, 3, ret);
0254f074
AG		 242
243 return EMULATE_DONE;
244}
245
f31e65e1
BH		 246static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
247{
248 unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
249 unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
250 unsigned long tce = kvmppc_get_gpr(vcpu, 6);
251 long rc;
252
253 rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
254 if (rc == H_TOO_HARD)
255 return EMULATE_FAIL;
256 kvmppc_set_gpr(vcpu, 3, rc);
257 return EMULATE_DONE;
258}
259
bc5ad3f3
BH		 260static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
261{
262 long rc = kvmppc_xics_hcall(vcpu, cmd);
263 kvmppc_set_gpr(vcpu, 3, rc);
264 return EMULATE_DONE;
265}
266
0254f074
AG		 267int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
268{
269 switch (cmd) {
270 case H_ENTER:
271 return kvmppc_h_pr_enter(vcpu);
272 case H_REMOVE:
273 return kvmppc_h_pr_remove(vcpu);
274 case H_PROTECT:
275 return kvmppc_h_pr_protect(vcpu);
276 case H_BULK_REMOVE:
3aaefef2 277 return kvmppc_h_pr_bulk_remove(vcpu);
f31e65e1
BH		 278 case H_PUT_TCE:
279 return kvmppc_h_pr_put_tce(vcpu);
0254f074 280 case H_CEDE:
1dee7a3d 281 vcpu->arch.shared->msr |= MSR_EE;
0254f074 282 kvm_vcpu_block(vcpu);
966cd0f3 283 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
0254f074
AG		 284 vcpu->stat.halt_wakeup++;
285 return EMULATE_DONE;
bc5ad3f3
BH		 286 case H_XIRR:
287 case H_CPPR:
288 case H_EOI:
289 case H_IPI:
8e44ddc3
PM		 290 case H_IPOLL:
291 case H_XIRR_X:
bc5ad3f3
BH		 292 if (kvmppc_xics_enabled(vcpu))
293 return kvmppc_h_pr_xics_hcall(vcpu, cmd);
294 break;
8e591cb7
ME		 295 case H_RTAS:
296 if (list_empty(&vcpu->kvm->arch.rtas_tokens))
297 return RESUME_HOST;
298 if (kvmppc_rtas_hcall(vcpu))
299 break;
300 kvmppc_set_gpr(vcpu, 3, 0);
301 return EMULATE_DONE;
0254f074
AG		 302 }
303
304 return EMULATE_FAIL;
305}
Linux 6.x block layer and io_uring tree(s)