~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kvm/book3s_pr_papr.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <linux/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 
 26 static 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 
 39 static 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 
 85 static 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 
140 static 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 
203 static 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 
247 static 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 
261 static 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 
272 static 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 
283 static 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 
299 static 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 
314 static 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 
321 int 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 
378 int 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  */
408 static 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 
426 void 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 }
437 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp