c086eb0fa992504be49d22d15f74978d0edd26c5
[linux-3.10.git] / arch / powerpc / kvm / book3s_hv_rm_mmu.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License, version 2, as
4  * published by the Free Software Foundation.
5  *
6  * Copyright 2010-2011 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
7  */
8
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/kvm.h>
12 #include <linux/kvm_host.h>
13 #include <linux/hugetlb.h>
14 #include <linux/module.h>
15
16 #include <asm/tlbflush.h>
17 #include <asm/kvm_ppc.h>
18 #include <asm/kvm_book3s.h>
19 #include <asm/mmu-hash64.h>
20 #include <asm/hvcall.h>
21 #include <asm/synch.h>
22 #include <asm/ppc-opcode.h>
23
24 /*
25  * Since this file is built in even if KVM is a module, we need
26  * a local copy of this function for the case where kvm_main.c is
27  * modular.
28  */
29 static struct kvm_memory_slot *builtin_gfn_to_memslot(struct kvm *kvm,
30                                                 gfn_t gfn)
31 {
32         struct kvm_memslots *slots;
33         struct kvm_memory_slot *memslot;
34
35         slots = kvm_memslots(kvm);
36         kvm_for_each_memslot(memslot, slots)
37                 if (gfn >= memslot->base_gfn &&
38                       gfn < memslot->base_gfn + memslot->npages)
39                         return memslot;
40         return NULL;
41 }
42
43 /* Translate address of a vmalloc'd thing to a linear map address */
44 static void *real_vmalloc_addr(void *x)
45 {
46         unsigned long addr = (unsigned long) x;
47         pte_t *p;
48
49         p = find_linux_pte(swapper_pg_dir, addr);
50         if (!p || !pte_present(*p))
51                 return NULL;
52         /* assume we don't have huge pages in vmalloc space... */
53         addr = (pte_pfn(*p) << PAGE_SHIFT) | (addr & ~PAGE_MASK);
54         return __va(addr);
55 }
56
57 long kvmppc_h_enter(struct kvm_vcpu *vcpu, unsigned long flags,
58                     long pte_index, unsigned long pteh, unsigned long ptel)
59 {
60         struct kvm *kvm = vcpu->kvm;
61         unsigned long i, pa, gpa, gfn, psize;
62         unsigned long slot_fn;
63         unsigned long *hpte;
64         struct revmap_entry *rev;
65         unsigned long g_ptel = ptel;
66         struct kvm_memory_slot *memslot;
67         unsigned long *physp, pte_size;
68         bool realmode = vcpu->arch.vcore->vcore_state == VCORE_RUNNING;
69
70         psize = hpte_page_size(pteh, ptel);
71         if (!psize)
72                 return H_PARAMETER;
73
74         /* Find the memslot (if any) for this address */
75         gpa = (ptel & HPTE_R_RPN) & ~(psize - 1);
76         gfn = gpa >> PAGE_SHIFT;
77         memslot = builtin_gfn_to_memslot(kvm, gfn);
78         if (!(memslot && !(memslot->flags & KVM_MEMSLOT_INVALID)))
79                 return H_PARAMETER;
80
81         /* Check if the requested page fits entirely in the memslot. */
82         if (!slot_is_aligned(memslot, psize))
83                 return H_PARAMETER;
84         slot_fn = gfn - memslot->base_gfn;
85
86         physp = kvm->arch.slot_phys[memslot->id];
87         if (!physp)
88                 return H_PARAMETER;
89         physp += slot_fn;
90         if (realmode)
91                 physp = real_vmalloc_addr(physp);
92         pa = *physp;
93         if (!pa)
94                 return H_TOO_HARD;
95         pte_size = PAGE_SIZE << (pa & KVMPPC_PAGE_ORDER_MASK);
96         pa &= PAGE_MASK;
97
98         if (pte_size < psize)
99                 return H_PARAMETER;
100         if (pa && pte_size > psize)
101                 pa |= gpa & (pte_size - 1);
102
103         ptel &= ~(HPTE_R_PP0 - psize);
104         ptel |= pa;
105
106         /* Check WIMG */
107         if ((ptel & HPTE_R_WIMG) != HPTE_R_M &&
108             (ptel & HPTE_R_WIMG) != (HPTE_R_W | HPTE_R_I | HPTE_R_M))
109                 return H_PARAMETER;
110         pteh &= ~0x60UL;
111         pteh |= HPTE_V_VALID;
112
113         if (pte_index >= HPT_NPTE)
114                 return H_PARAMETER;
115         if (likely((flags & H_EXACT) == 0)) {
116                 pte_index &= ~7UL;
117                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
118                 for (i = 0; i < 8; ++i) {
119                         if ((*hpte & HPTE_V_VALID) == 0 &&
120                             try_lock_hpte(hpte, HPTE_V_HVLOCK | HPTE_V_VALID))
121                                 break;
122                         hpte += 2;
123                 }
124                 if (i == 8) {
125                         /*
126                          * Since try_lock_hpte doesn't retry (not even stdcx.
127                          * failures), it could be that there is a free slot
128                          * but we transiently failed to lock it.  Try again,
129                          * actually locking each slot and checking it.
130                          */
131                         hpte -= 16;
132                         for (i = 0; i < 8; ++i) {
133                                 while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
134                                         cpu_relax();
135                                 if ((*hpte & HPTE_V_VALID) == 0)
136                                         break;
137                                 *hpte &= ~HPTE_V_HVLOCK;
138                                 hpte += 2;
139                         }
140                         if (i == 8)
141                                 return H_PTEG_FULL;
142                 }
143                 pte_index += i;
144         } else {
145                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
146                 if (!try_lock_hpte(hpte, HPTE_V_HVLOCK | HPTE_V_VALID)) {
147                         /* Lock the slot and check again */
148                         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
149                                 cpu_relax();
150                         if (*hpte & HPTE_V_VALID) {
151                                 *hpte &= ~HPTE_V_HVLOCK;
152                                 return H_PTEG_FULL;
153                         }
154                 }
155         }
156
157         /* Save away the guest's idea of the second HPTE dword */
158         rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
159         if (rev)
160                 rev->guest_rpte = g_ptel;
161         hpte[1] = ptel;
162         eieio();
163         hpte[0] = pteh;
164         asm volatile("ptesync" : : : "memory");
165         vcpu->arch.gpr[4] = pte_index;
166         return H_SUCCESS;
167 }
168 EXPORT_SYMBOL_GPL(kvmppc_h_enter);
169
170 #define LOCK_TOKEN      (*(u32 *)(&get_paca()->lock_token))
171
172 static inline int try_lock_tlbie(unsigned int *lock)
173 {
174         unsigned int tmp, old;
175         unsigned int token = LOCK_TOKEN;
176
177         asm volatile("1:lwarx   %1,0,%2\n"
178                      "  cmpwi   cr0,%1,0\n"
179                      "  bne     2f\n"
180                      "  stwcx.  %3,0,%2\n"
181                      "  bne-    1b\n"
182                      "  isync\n"
183                      "2:"
184                      : "=&r" (tmp), "=&r" (old)
185                      : "r" (lock), "r" (token)
186                      : "cc", "memory");
187         return old == 0;
188 }
189
190 long kvmppc_h_remove(struct kvm_vcpu *vcpu, unsigned long flags,
191                      unsigned long pte_index, unsigned long avpn,
192                      unsigned long va)
193 {
194         struct kvm *kvm = vcpu->kvm;
195         unsigned long *hpte;
196         unsigned long v, r, rb;
197
198         if (pte_index >= HPT_NPTE)
199                 return H_PARAMETER;
200         hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
201         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
202                 cpu_relax();
203         if ((hpte[0] & HPTE_V_VALID) == 0 ||
204             ((flags & H_AVPN) && (hpte[0] & ~0x7fUL) != avpn) ||
205             ((flags & H_ANDCOND) && (hpte[0] & avpn) != 0)) {
206                 hpte[0] &= ~HPTE_V_HVLOCK;
207                 return H_NOT_FOUND;
208         }
209         if (atomic_read(&kvm->online_vcpus) == 1)
210                 flags |= H_LOCAL;
211         vcpu->arch.gpr[4] = v = hpte[0] & ~HPTE_V_HVLOCK;
212         vcpu->arch.gpr[5] = r = hpte[1];
213         rb = compute_tlbie_rb(v, r, pte_index);
214         hpte[0] = 0;
215         if (!(flags & H_LOCAL)) {
216                 while(!try_lock_tlbie(&kvm->arch.tlbie_lock))
217                         cpu_relax();
218                 asm volatile("ptesync" : : : "memory");
219                 asm volatile(PPC_TLBIE(%1,%0)"; eieio; tlbsync"
220                              : : "r" (rb), "r" (kvm->arch.lpid));
221                 asm volatile("ptesync" : : : "memory");
222                 kvm->arch.tlbie_lock = 0;
223         } else {
224                 asm volatile("ptesync" : : : "memory");
225                 asm volatile("tlbiel %0" : : "r" (rb));
226                 asm volatile("ptesync" : : : "memory");
227         }
228         return H_SUCCESS;
229 }
230
231 long kvmppc_h_bulk_remove(struct kvm_vcpu *vcpu)
232 {
233         struct kvm *kvm = vcpu->kvm;
234         unsigned long *args = &vcpu->arch.gpr[4];
235         unsigned long *hp, tlbrb[4];
236         long int i, found;
237         long int n_inval = 0;
238         unsigned long flags, req, pte_index;
239         long int local = 0;
240         long int ret = H_SUCCESS;
241
242         if (atomic_read(&kvm->online_vcpus) == 1)
243                 local = 1;
244         for (i = 0; i < 4; ++i) {
245                 pte_index = args[i * 2];
246                 flags = pte_index >> 56;
247                 pte_index &= ((1ul << 56) - 1);
248                 req = flags >> 6;
249                 flags &= 3;
250                 if (req == 3)
251                         break;
252                 if (req != 1 || flags == 3 ||
253                     pte_index >= HPT_NPTE) {
254                         /* parameter error */
255                         args[i * 2] = ((0xa0 | flags) << 56) + pte_index;
256                         ret = H_PARAMETER;
257                         break;
258                 }
259                 hp = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
260                 while (!try_lock_hpte(hp, HPTE_V_HVLOCK))
261                         cpu_relax();
262                 found = 0;
263                 if (hp[0] & HPTE_V_VALID) {
264                         switch (flags & 3) {
265                         case 0:         /* absolute */
266                                 found = 1;
267                                 break;
268                         case 1:         /* andcond */
269                                 if (!(hp[0] & args[i * 2 + 1]))
270                                         found = 1;
271                                 break;
272                         case 2:         /* AVPN */
273                                 if ((hp[0] & ~0x7fUL) == args[i * 2 + 1])
274                                         found = 1;
275                                 break;
276                         }
277                 }
278                 if (!found) {
279                         hp[0] &= ~HPTE_V_HVLOCK;
280                         args[i * 2] = ((0x90 | flags) << 56) + pte_index;
281                         continue;
282                 }
283                 /* insert R and C bits from PTE */
284                 flags |= (hp[1] >> 5) & 0x0c;
285                 args[i * 2] = ((0x80 | flags) << 56) + pte_index;
286                 tlbrb[n_inval++] = compute_tlbie_rb(hp[0], hp[1], pte_index);
287                 hp[0] = 0;
288         }
289         if (n_inval == 0)
290                 return ret;
291
292         if (!local) {
293                 while(!try_lock_tlbie(&kvm->arch.tlbie_lock))
294                         cpu_relax();
295                 asm volatile("ptesync" : : : "memory");
296                 for (i = 0; i < n_inval; ++i)
297                         asm volatile(PPC_TLBIE(%1,%0)
298                                      : : "r" (tlbrb[i]), "r" (kvm->arch.lpid));
299                 asm volatile("eieio; tlbsync; ptesync" : : : "memory");
300                 kvm->arch.tlbie_lock = 0;
301         } else {
302                 asm volatile("ptesync" : : : "memory");
303                 for (i = 0; i < n_inval; ++i)
304                         asm volatile("tlbiel %0" : : "r" (tlbrb[i]));
305                 asm volatile("ptesync" : : : "memory");
306         }
307         return ret;
308 }
309
310 long kvmppc_h_protect(struct kvm_vcpu *vcpu, unsigned long flags,
311                       unsigned long pte_index, unsigned long avpn,
312                       unsigned long va)
313 {
314         struct kvm *kvm = vcpu->kvm;
315         unsigned long *hpte;
316         struct revmap_entry *rev;
317         unsigned long v, r, rb, mask, bits;
318
319         if (pte_index >= HPT_NPTE)
320                 return H_PARAMETER;
321         hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
322         while (!try_lock_hpte(hpte, HPTE_V_HVLOCK))
323                 cpu_relax();
324         if ((hpte[0] & HPTE_V_VALID) == 0 ||
325             ((flags & H_AVPN) && (hpte[0] & ~0x7fUL) != avpn)) {
326                 hpte[0] &= ~HPTE_V_HVLOCK;
327                 return H_NOT_FOUND;
328         }
329         if (atomic_read(&kvm->online_vcpus) == 1)
330                 flags |= H_LOCAL;
331         v = hpte[0];
332         bits = (flags << 55) & HPTE_R_PP0;
333         bits |= (flags << 48) & HPTE_R_KEY_HI;
334         bits |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
335
336         /* Update guest view of 2nd HPTE dword */
337         mask = HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N |
338                 HPTE_R_KEY_HI | HPTE_R_KEY_LO;
339         rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
340         if (rev) {
341                 r = (rev->guest_rpte & ~mask) | bits;
342                 rev->guest_rpte = r;
343         }
344         r = (hpte[1] & ~mask) | bits;
345
346         /* Update HPTE */
347         rb = compute_tlbie_rb(v, r, pte_index);
348         hpte[0] = v & ~HPTE_V_VALID;
349         if (!(flags & H_LOCAL)) {
350                 while(!try_lock_tlbie(&kvm->arch.tlbie_lock))
351                         cpu_relax();
352                 asm volatile("ptesync" : : : "memory");
353                 asm volatile(PPC_TLBIE(%1,%0)"; eieio; tlbsync"
354                              : : "r" (rb), "r" (kvm->arch.lpid));
355                 asm volatile("ptesync" : : : "memory");
356                 kvm->arch.tlbie_lock = 0;
357         } else {
358                 asm volatile("ptesync" : : : "memory");
359                 asm volatile("tlbiel %0" : : "r" (rb));
360                 asm volatile("ptesync" : : : "memory");
361         }
362         hpte[1] = r;
363         eieio();
364         hpte[0] = v & ~HPTE_V_HVLOCK;
365         asm volatile("ptesync" : : : "memory");
366         return H_SUCCESS;
367 }
368
369 long kvmppc_h_read(struct kvm_vcpu *vcpu, unsigned long flags,
370                    unsigned long pte_index)
371 {
372         struct kvm *kvm = vcpu->kvm;
373         unsigned long *hpte, r;
374         int i, n = 1;
375         struct revmap_entry *rev = NULL;
376
377         if (pte_index >= HPT_NPTE)
378                 return H_PARAMETER;
379         if (flags & H_READ_4) {
380                 pte_index &= ~3;
381                 n = 4;
382         }
383         if (flags & H_R_XLATE)
384                 rev = real_vmalloc_addr(&kvm->arch.revmap[pte_index]);
385         for (i = 0; i < n; ++i, ++pte_index) {
386                 hpte = (unsigned long *)(kvm->arch.hpt_virt + (pte_index << 4));
387                 r = hpte[1];
388                 if (hpte[0] & HPTE_V_VALID) {
389                         if (rev)
390                                 r = rev[i].guest_rpte;
391                         else
392                                 r = hpte[1] | HPTE_R_RPN;
393                 }
394                 vcpu->arch.gpr[4 + i * 2] = hpte[0];
395                 vcpu->arch.gpr[5 + i * 2] = r;
396         }
397         return H_SUCCESS;
398 }