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

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

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ 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.78 ] ~ [ 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.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  * 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 2016 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/anon_inodes.h>
 14 #include <linux/file.h>
 15 #include <linux/debugfs.h>
 16 
 17 #include <asm/kvm_ppc.h>
 18 #include <asm/kvm_book3s.h>
 19 #include <asm/page.h>
 20 #include <asm/mmu.h>
 21 #include <asm/pgtable.h>
 22 #include <asm/pgalloc.h>
 23 #include <asm/pte-walk.h>
 24 
 25 /*
 26  * Supported radix tree geometry.
 27  * Like p9, we support either 5 or 9 bits at the first (lowest) level,
 28  * for a page size of 64k or 4k.
 29  */
 30 static int p9_supported_radix_bits[4] = { 5, 9, 9, 13 };
 31 
 32 int kvmppc_mmu_walk_radix_tree(struct kvm_vcpu *vcpu, gva_t eaddr,
 33                                struct kvmppc_pte *gpte, u64 root,
 34                                u64 *pte_ret_p)
 35 {
 36         struct kvm *kvm = vcpu->kvm;
 37         int ret, level, ps;
 38         unsigned long rts, bits, offset, index;
 39         u64 pte, base, gpa;
 40         __be64 rpte;
 41 
 42         rts = ((root & RTS1_MASK) >> (RTS1_SHIFT - 3)) |
 43                 ((root & RTS2_MASK) >> RTS2_SHIFT);
 44         bits = root & RPDS_MASK;
 45         base = root & RPDB_MASK;
 46 
 47         offset = rts + 31;
 48 
 49         /* Current implementations only support 52-bit space */
 50         if (offset != 52)
 51                 return -EINVAL;
 52 
 53         /* Walk each level of the radix tree */
 54         for (level = 3; level >= 0; --level) {
 55                 u64 addr;
 56                 /* Check a valid size */
 57                 if (level && bits != p9_supported_radix_bits[level])
 58                         return -EINVAL;
 59                 if (level == 0 && !(bits == 5 || bits == 9))
 60                         return -EINVAL;
 61                 offset -= bits;
 62                 index = (eaddr >> offset) & ((1UL << bits) - 1);
 63                 /* Check that low bits of page table base are zero */
 64                 if (base & ((1UL << (bits + 3)) - 1))
 65                         return -EINVAL;
 66                 /* Read the entry from guest memory */
 67                 addr = base + (index * sizeof(rpte));
 68                 ret = kvm_read_guest(kvm, addr, &rpte, sizeof(rpte));
 69                 if (ret) {
 70                         if (pte_ret_p)
 71                                 *pte_ret_p = addr;
 72                         return ret;
 73                 }
 74                 pte = __be64_to_cpu(rpte);
 75                 if (!(pte & _PAGE_PRESENT))
 76                         return -ENOENT;
 77                 /* Check if a leaf entry */
 78                 if (pte & _PAGE_PTE)
 79                         break;
 80                 /* Get ready to walk the next level */
 81                 base = pte & RPDB_MASK;
 82                 bits = pte & RPDS_MASK;
 83         }
 84 
 85         /* Need a leaf at lowest level; 512GB pages not supported */
 86         if (level < 0 || level == 3)
 87                 return -EINVAL;
 88 
 89         /* We found a valid leaf PTE */
 90         /* Offset is now log base 2 of the page size */
 91         gpa = pte & 0x01fffffffffff000ul;
 92         if (gpa & ((1ul << offset) - 1))
 93                 return -EINVAL;
 94         gpa |= eaddr & ((1ul << offset) - 1);
 95         for (ps = MMU_PAGE_4K; ps < MMU_PAGE_COUNT; ++ps)
 96                 if (offset == mmu_psize_defs[ps].shift)
 97                         break;
 98         gpte->page_size = ps;
 99         gpte->page_shift = offset;
100 
101         gpte->eaddr = eaddr;
102         gpte->raddr = gpa;
103 
104         /* Work out permissions */
105         gpte->may_read = !!(pte & _PAGE_READ);
106         gpte->may_write = !!(pte & _PAGE_WRITE);
107         gpte->may_execute = !!(pte & _PAGE_EXEC);
108 
109         gpte->rc = pte & (_PAGE_ACCESSED | _PAGE_DIRTY);
110 
111         if (pte_ret_p)
112                 *pte_ret_p = pte;
113 
114         return 0;
115 }
116 
117 /*
118  * Used to walk a partition or process table radix tree in guest memory
119  * Note: We exploit the fact that a partition table and a process
120  * table have the same layout, a partition-scoped page table and a
121  * process-scoped page table have the same layout, and the 2nd
122  * doubleword of a partition table entry has the same layout as
123  * the PTCR register.
124  */
125 int kvmppc_mmu_radix_translate_table(struct kvm_vcpu *vcpu, gva_t eaddr,
126                                      struct kvmppc_pte *gpte, u64 table,
127                                      int table_index, u64 *pte_ret_p)
128 {
129         struct kvm *kvm = vcpu->kvm;
130         int ret;
131         unsigned long size, ptbl, root;
132         struct prtb_entry entry;
133 
134         if ((table & PRTS_MASK) > 24)
135                 return -EINVAL;
136         size = 1ul << ((table & PRTS_MASK) + 12);
137 
138         /* Is the table big enough to contain this entry? */
139         if ((table_index * sizeof(entry)) >= size)
140                 return -EINVAL;
141 
142         /* Read the table to find the root of the radix tree */
143         ptbl = (table & PRTB_MASK) + (table_index * sizeof(entry));
144         ret = kvm_read_guest(kvm, ptbl, &entry, sizeof(entry));
145         if (ret)
146                 return ret;
147 
148         /* Root is stored in the first double word */
149         root = be64_to_cpu(entry.prtb0);
150 
151         return kvmppc_mmu_walk_radix_tree(vcpu, eaddr, gpte, root, pte_ret_p);
152 }
153 
154 int kvmppc_mmu_radix_xlate(struct kvm_vcpu *vcpu, gva_t eaddr,
155                            struct kvmppc_pte *gpte, bool data, bool iswrite)
156 {
157         u32 pid;
158         u64 pte;
159         int ret;
160 
161         /* Work out effective PID */
162         switch (eaddr >> 62) {
163         case 0:
164                 pid = vcpu->arch.pid;
165                 break;
166         case 3:
167                 pid = 0;
168                 break;
169         default:
170                 return -EINVAL;
171         }
172 
173         ret = kvmppc_mmu_radix_translate_table(vcpu, eaddr, gpte,
174                                 vcpu->kvm->arch.process_table, pid, &pte);
175         if (ret)
176                 return ret;
177 
178         /* Check privilege (applies only to process scoped translations) */
179         if (kvmppc_get_msr(vcpu) & MSR_PR) {
180                 if (pte & _PAGE_PRIVILEGED) {
181                         gpte->may_read = 0;
182                         gpte->may_write = 0;
183                         gpte->may_execute = 0;
184                 }
185         } else {
186                 if (!(pte & _PAGE_PRIVILEGED)) {
187                         /* Check AMR/IAMR to see if strict mode is in force */
188                         if (vcpu->arch.amr & (1ul << 62))
189                                 gpte->may_read = 0;
190                         if (vcpu->arch.amr & (1ul << 63))
191                                 gpte->may_write = 0;
192                         if (vcpu->arch.iamr & (1ul << 62))
193                                 gpte->may_execute = 0;
194                 }
195         }
196 
197         return 0;
198 }
199 
200 static void kvmppc_radix_tlbie_page(struct kvm *kvm, unsigned long addr,
201                                     unsigned int pshift, unsigned int lpid)
202 {
203         unsigned long psize = PAGE_SIZE;
204         int psi;
205         long rc;
206         unsigned long rb;
207 
208         if (pshift)
209                 psize = 1UL << pshift;
210         else
211                 pshift = PAGE_SHIFT;
212 
213         addr &= ~(psize - 1);
214 
215         if (!kvmhv_on_pseries()) {
216                 radix__flush_tlb_lpid_page(lpid, addr, psize);
217                 return;
218         }
219 
220         psi = shift_to_mmu_psize(pshift);
221         rb = addr | (mmu_get_ap(psi) << PPC_BITLSHIFT(58));
222         rc = plpar_hcall_norets(H_TLB_INVALIDATE, H_TLBIE_P1_ENC(0, 0, 1),
223                                 lpid, rb);
224         if (rc)
225                 pr_err("KVM: TLB page invalidation hcall failed, rc=%ld\n", rc);
226 }
227 
228 static void kvmppc_radix_flush_pwc(struct kvm *kvm, unsigned int lpid)
229 {
230         long rc;
231 
232         if (!kvmhv_on_pseries()) {
233                 radix__flush_pwc_lpid(lpid);
234                 return;
235         }
236 
237         rc = plpar_hcall_norets(H_TLB_INVALIDATE, H_TLBIE_P1_ENC(1, 0, 1),
238                                 lpid, TLBIEL_INVAL_SET_LPID);
239         if (rc)
240                 pr_err("KVM: TLB PWC invalidation hcall failed, rc=%ld\n", rc);
241 }
242 
243 static unsigned long kvmppc_radix_update_pte(struct kvm *kvm, pte_t *ptep,
244                                       unsigned long clr, unsigned long set,
245                                       unsigned long addr, unsigned int shift)
246 {
247         return __radix_pte_update(ptep, clr, set);
248 }
249 
250 void kvmppc_radix_set_pte_at(struct kvm *kvm, unsigned long addr,
251                              pte_t *ptep, pte_t pte)
252 {
253         radix__set_pte_at(kvm->mm, addr, ptep, pte, 0);
254 }
255 
256 static struct kmem_cache *kvm_pte_cache;
257 static struct kmem_cache *kvm_pmd_cache;
258 
259 static pte_t *kvmppc_pte_alloc(void)
260 {
261         return kmem_cache_alloc(kvm_pte_cache, GFP_KERNEL);
262 }
263 
264 static void kvmppc_pte_free(pte_t *ptep)
265 {
266         kmem_cache_free(kvm_pte_cache, ptep);
267 }
268 
269 /* Like pmd_huge() and pmd_large(), but works regardless of config options */
270 static inline int pmd_is_leaf(pmd_t pmd)
271 {
272         return !!(pmd_val(pmd) & _PAGE_PTE);
273 }
274 
275 static pmd_t *kvmppc_pmd_alloc(void)
276 {
277         return kmem_cache_alloc(kvm_pmd_cache, GFP_KERNEL);
278 }
279 
280 static void kvmppc_pmd_free(pmd_t *pmdp)
281 {
282         kmem_cache_free(kvm_pmd_cache, pmdp);
283 }
284 
285 /* Called with kvm->mmu_lock held */
286 void kvmppc_unmap_pte(struct kvm *kvm, pte_t *pte, unsigned long gpa,
287                       unsigned int shift, struct kvm_memory_slot *memslot,
288                       unsigned int lpid)
289 
290 {
291         unsigned long old;
292         unsigned long gfn = gpa >> PAGE_SHIFT;
293         unsigned long page_size = PAGE_SIZE;
294         unsigned long hpa;
295 
296         old = kvmppc_radix_update_pte(kvm, pte, ~0UL, 0, gpa, shift);
297         kvmppc_radix_tlbie_page(kvm, gpa, shift, lpid);
298 
299         /* The following only applies to L1 entries */
300         if (lpid != kvm->arch.lpid)
301                 return;
302 
303         if (!memslot) {
304                 memslot = gfn_to_memslot(kvm, gfn);
305                 if (!memslot)
306                         return;
307         }
308         if (shift)
309                 page_size = 1ul << shift;
310 
311         gpa &= ~(page_size - 1);
312         hpa = old & PTE_RPN_MASK;
313         kvmhv_remove_nest_rmap_range(kvm, memslot, gpa, hpa, page_size);
314 
315         if ((old & _PAGE_DIRTY) && memslot->dirty_bitmap)
316                 kvmppc_update_dirty_map(memslot, gfn, page_size);
317 }
318 
319 /*
320  * kvmppc_free_p?d are used to free existing page tables, and recursively
321  * descend and clear and free children.
322  * Callers are responsible for flushing the PWC.
323  *
324  * When page tables are being unmapped/freed as part of page fault path
325  * (full == false), ptes are not expected. There is code to unmap them
326  * and emit a warning if encountered, but there may already be data
327  * corruption due to the unexpected mappings.
328  */
329 static void kvmppc_unmap_free_pte(struct kvm *kvm, pte_t *pte, bool full,
330                                   unsigned int lpid)
331 {
332         if (full) {
333                 memset(pte, 0, sizeof(long) << PTE_INDEX_SIZE);
334         } else {
335                 pte_t *p = pte;
336                 unsigned long it;
337 
338                 for (it = 0; it < PTRS_PER_PTE; ++it, ++p) {
339                         if (pte_val(*p) == 0)
340                                 continue;
341                         WARN_ON_ONCE(1);
342                         kvmppc_unmap_pte(kvm, p,
343                                          pte_pfn(*p) << PAGE_SHIFT,
344                                          PAGE_SHIFT, NULL, lpid);
345                 }
346         }
347 
348         kvmppc_pte_free(pte);
349 }
350 
351 static void kvmppc_unmap_free_pmd(struct kvm *kvm, pmd_t *pmd, bool full,
352                                   unsigned int lpid)
353 {
354         unsigned long im;
355         pmd_t *p = pmd;
356 
357         for (im = 0; im < PTRS_PER_PMD; ++im, ++p) {
358                 if (!pmd_present(*p))
359                         continue;
360                 if (pmd_is_leaf(*p)) {
361                         if (full) {
362                                 pmd_clear(p);
363                         } else {
364                                 WARN_ON_ONCE(1);
365                                 kvmppc_unmap_pte(kvm, (pte_t *)p,
366                                          pte_pfn(*(pte_t *)p) << PAGE_SHIFT,
367                                          PMD_SHIFT, NULL, lpid);
368                         }
369                 } else {
370                         pte_t *pte;
371 
372                         pte = pte_offset_map(p, 0);
373                         kvmppc_unmap_free_pte(kvm, pte, full, lpid);
374                         pmd_clear(p);
375                 }
376         }
377         kvmppc_pmd_free(pmd);
378 }
379 
380 static void kvmppc_unmap_free_pud(struct kvm *kvm, pud_t *pud,
381                                   unsigned int lpid)
382 {
383         unsigned long iu;
384         pud_t *p = pud;
385 
386         for (iu = 0; iu < PTRS_PER_PUD; ++iu, ++p) {
387                 if (!pud_present(*p))
388                         continue;
389                 if (pud_huge(*p)) {
390                         pud_clear(p);
391                 } else {
392                         pmd_t *pmd;
393 
394                         pmd = pmd_offset(p, 0);
395                         kvmppc_unmap_free_pmd(kvm, pmd, true, lpid);
396                         pud_clear(p);
397                 }
398         }
399         pud_free(kvm->mm, pud);
400 }
401 
402 void kvmppc_free_pgtable_radix(struct kvm *kvm, pgd_t *pgd, unsigned int lpid)
403 {
404         unsigned long ig;
405 
406         for (ig = 0; ig < PTRS_PER_PGD; ++ig, ++pgd) {
407                 pud_t *pud;
408 
409                 if (!pgd_present(*pgd))
410                         continue;
411                 pud = pud_offset(pgd, 0);
412                 kvmppc_unmap_free_pud(kvm, pud, lpid);
413                 pgd_clear(pgd);
414         }
415 }
416 
417 void kvmppc_free_radix(struct kvm *kvm)
418 {
419         if (kvm->arch.pgtable) {
420                 kvmppc_free_pgtable_radix(kvm, kvm->arch.pgtable,
421                                           kvm->arch.lpid);
422                 pgd_free(kvm->mm, kvm->arch.pgtable);
423                 kvm->arch.pgtable = NULL;
424         }
425 }
426 
427 static void kvmppc_unmap_free_pmd_entry_table(struct kvm *kvm, pmd_t *pmd,
428                                         unsigned long gpa, unsigned int lpid)
429 {
430         pte_t *pte = pte_offset_kernel(pmd, 0);
431 
432         /*
433          * Clearing the pmd entry then flushing the PWC ensures that the pte
434          * page no longer be cached by the MMU, so can be freed without
435          * flushing the PWC again.
436          */
437         pmd_clear(pmd);
438         kvmppc_radix_flush_pwc(kvm, lpid);
439 
440         kvmppc_unmap_free_pte(kvm, pte, false, lpid);
441 }
442 
443 static void kvmppc_unmap_free_pud_entry_table(struct kvm *kvm, pud_t *pud,
444                                         unsigned long gpa, unsigned int lpid)
445 {
446         pmd_t *pmd = pmd_offset(pud, 0);
447 
448         /*
449          * Clearing the pud entry then flushing the PWC ensures that the pmd
450          * page and any children pte pages will no longer be cached by the MMU,
451          * so can be freed without flushing the PWC again.
452          */
453         pud_clear(pud);
454         kvmppc_radix_flush_pwc(kvm, lpid);
455 
456         kvmppc_unmap_free_pmd(kvm, pmd, false, lpid);
457 }
458 
459 /*
460  * There are a number of bits which may differ between different faults to
461  * the same partition scope entry. RC bits, in the course of cleaning and
462  * aging. And the write bit can change, either the access could have been
463  * upgraded, or a read fault could happen concurrently with a write fault
464  * that sets those bits first.
465  */
466 #define PTE_BITS_MUST_MATCH (~(_PAGE_WRITE | _PAGE_DIRTY | _PAGE_ACCESSED))
467 
468 int kvmppc_create_pte(struct kvm *kvm, pgd_t *pgtable, pte_t pte,
469                       unsigned long gpa, unsigned int level,
470                       unsigned long mmu_seq, unsigned int lpid,
471                       unsigned long *rmapp, struct rmap_nested **n_rmap)
472 {
473         pgd_t *pgd;
474         pud_t *pud, *new_pud = NULL;
475         pmd_t *pmd, *new_pmd = NULL;
476         pte_t *ptep, *new_ptep = NULL;
477         int ret;
478 
479         /* Traverse the guest's 2nd-level tree, allocate new levels needed */
480         pgd = pgtable + pgd_index(gpa);
481         pud = NULL;
482         if (pgd_present(*pgd))
483                 pud = pud_offset(pgd, gpa);
484         else
485                 new_pud = pud_alloc_one(kvm->mm, gpa);
486 
487         pmd = NULL;
488         if (pud && pud_present(*pud) && !pud_huge(*pud))
489                 pmd = pmd_offset(pud, gpa);
490         else if (level <= 1)
491                 new_pmd = kvmppc_pmd_alloc();
492 
493         if (level == 0 && !(pmd && pmd_present(*pmd) && !pmd_is_leaf(*pmd)))
494                 new_ptep = kvmppc_pte_alloc();
495 
496         /* Check if we might have been invalidated; let the guest retry if so */
497         spin_lock(&kvm->mmu_lock);
498         ret = -EAGAIN;
499         if (mmu_notifier_retry(kvm, mmu_seq))
500                 goto out_unlock;
501 
502         /* Now traverse again under the lock and change the tree */
503         ret = -ENOMEM;
504         if (pgd_none(*pgd)) {
505                 if (!new_pud)
506                         goto out_unlock;
507                 pgd_populate(kvm->mm, pgd, new_pud);
508                 new_pud = NULL;
509         }
510         pud = pud_offset(pgd, gpa);
511         if (pud_huge(*pud)) {
512                 unsigned long hgpa = gpa & PUD_MASK;
513 
514                 /* Check if we raced and someone else has set the same thing */
515                 if (level == 2) {
516                         if (pud_raw(*pud) == pte_raw(pte)) {
517                                 ret = 0;
518                                 goto out_unlock;
519                         }
520                         /* Valid 1GB page here already, add our extra bits */
521                         WARN_ON_ONCE((pud_val(*pud) ^ pte_val(pte)) &
522                                                         PTE_BITS_MUST_MATCH);
523                         kvmppc_radix_update_pte(kvm, (pte_t *)pud,
524                                               0, pte_val(pte), hgpa, PUD_SHIFT);
525                         ret = 0;
526                         goto out_unlock;
527                 }
528                 /*
529                  * If we raced with another CPU which has just put
530                  * a 1GB pte in after we saw a pmd page, try again.
531                  */
532                 if (!new_pmd) {
533                         ret = -EAGAIN;
534                         goto out_unlock;
535                 }
536                 /* Valid 1GB page here already, remove it */
537                 kvmppc_unmap_pte(kvm, (pte_t *)pud, hgpa, PUD_SHIFT, NULL,
538                                  lpid);
539         }
540         if (level == 2) {
541                 if (!pud_none(*pud)) {
542                         /*
543                          * There's a page table page here, but we wanted to
544                          * install a large page, so remove and free the page
545                          * table page.
546                          */
547                         kvmppc_unmap_free_pud_entry_table(kvm, pud, gpa, lpid);
548                 }
549                 kvmppc_radix_set_pte_at(kvm, gpa, (pte_t *)pud, pte);
550                 if (rmapp && n_rmap)
551                         kvmhv_insert_nest_rmap(kvm, rmapp, n_rmap);
552                 ret = 0;
553                 goto out_unlock;
554         }
555         if (pud_none(*pud)) {
556                 if (!new_pmd)
557                         goto out_unlock;
558                 pud_populate(kvm->mm, pud, new_pmd);
559                 new_pmd = NULL;
560         }
561         pmd = pmd_offset(pud, gpa);
562         if (pmd_is_leaf(*pmd)) {
563                 unsigned long lgpa = gpa & PMD_MASK;
564 
565                 /* Check if we raced and someone else has set the same thing */
566                 if (level == 1) {
567                         if (pmd_raw(*pmd) == pte_raw(pte)) {
568                                 ret = 0;
569                                 goto out_unlock;
570                         }
571                         /* Valid 2MB page here already, add our extra bits */
572                         WARN_ON_ONCE((pmd_val(*pmd) ^ pte_val(pte)) &
573                                                         PTE_BITS_MUST_MATCH);
574                         kvmppc_radix_update_pte(kvm, pmdp_ptep(pmd),
575                                         0, pte_val(pte), lgpa, PMD_SHIFT);
576                         ret = 0;
577                         goto out_unlock;
578                 }
579 
580                 /*
581                  * If we raced with another CPU which has just put
582                  * a 2MB pte in after we saw a pte page, try again.
583                  */
584                 if (!new_ptep) {
585                         ret = -EAGAIN;
586                         goto out_unlock;
587                 }
588                 /* Valid 2MB page here already, remove it */
589                 kvmppc_unmap_pte(kvm, pmdp_ptep(pmd), lgpa, PMD_SHIFT, NULL,
590                                  lpid);
591         }
592         if (level == 1) {
593                 if (!pmd_none(*pmd)) {
594                         /*
595                          * There's a page table page here, but we wanted to
596                          * install a large page, so remove and free the page
597                          * table page.
598                          */
599                         kvmppc_unmap_free_pmd_entry_table(kvm, pmd, gpa, lpid);
600                 }
601                 kvmppc_radix_set_pte_at(kvm, gpa, pmdp_ptep(pmd), pte);
602                 if (rmapp && n_rmap)
603                         kvmhv_insert_nest_rmap(kvm, rmapp, n_rmap);
604                 ret = 0;
605                 goto out_unlock;
606         }
607         if (pmd_none(*pmd)) {
608                 if (!new_ptep)
609                         goto out_unlock;
610                 pmd_populate(kvm->mm, pmd, new_ptep);
611                 new_ptep = NULL;
612         }
613         ptep = pte_offset_kernel(pmd, gpa);
614         if (pte_present(*ptep)) {
615                 /* Check if someone else set the same thing */
616                 if (pte_raw(*ptep) == pte_raw(pte)) {
617                         ret = 0;
618                         goto out_unlock;
619                 }
620                 /* Valid page here already, add our extra bits */
621                 WARN_ON_ONCE((pte_val(*ptep) ^ pte_val(pte)) &
622                                                         PTE_BITS_MUST_MATCH);
623                 kvmppc_radix_update_pte(kvm, ptep, 0, pte_val(pte), gpa, 0);
624                 ret = 0;
625                 goto out_unlock;
626         }
627         kvmppc_radix_set_pte_at(kvm, gpa, ptep, pte);
628         if (rmapp && n_rmap)
629                 kvmhv_insert_nest_rmap(kvm, rmapp, n_rmap);
630         ret = 0;
631 
632  out_unlock:
633         spin_unlock(&kvm->mmu_lock);
634         if (new_pud)
635                 pud_free(kvm->mm, new_pud);
636         if (new_pmd)
637                 kvmppc_pmd_free(new_pmd);
638         if (new_ptep)
639                 kvmppc_pte_free(new_ptep);
640         return ret;
641 }
642 
643 bool kvmppc_hv_handle_set_rc(struct kvm *kvm, pgd_t *pgtable, bool writing,
644                              unsigned long gpa, unsigned int lpid)
645 {
646         unsigned long pgflags;
647         unsigned int shift;
648         pte_t *ptep;
649 
650         /*
651          * Need to set an R or C bit in the 2nd-level tables;
652          * since we are just helping out the hardware here,
653          * it is sufficient to do what the hardware does.
654          */
655         pgflags = _PAGE_ACCESSED;
656         if (writing)
657                 pgflags |= _PAGE_DIRTY;
658         /*
659          * We are walking the secondary (partition-scoped) page table here.
660          * We can do this without disabling irq because the Linux MM
661          * subsystem doesn't do THP splits and collapses on this tree.
662          */
663         ptep = __find_linux_pte(pgtable, gpa, NULL, &shift);
664         if (ptep && pte_present(*ptep) && (!writing || pte_write(*ptep))) {
665                 kvmppc_radix_update_pte(kvm, ptep, 0, pgflags, gpa, shift);
666                 return true;
667         }
668         return false;
669 }
670 
671 int kvmppc_book3s_instantiate_page(struct kvm_vcpu *vcpu,
672                                    unsigned long gpa,
673                                    struct kvm_memory_slot *memslot,
674                                    bool writing, bool kvm_ro,
675                                    pte_t *inserted_pte, unsigned int *levelp)
676 {
677         struct kvm *kvm = vcpu->kvm;
678         struct page *page = NULL;
679         unsigned long mmu_seq;
680         unsigned long hva, gfn = gpa >> PAGE_SHIFT;
681         bool upgrade_write = false;
682         bool *upgrade_p = &upgrade_write;
683         pte_t pte, *ptep;
684         unsigned int shift, level;
685         int ret;
686 
687         /* used to check for invalidations in progress */
688         mmu_seq = kvm->mmu_notifier_seq;
689         smp_rmb();
690 
691         /*
692          * Do a fast check first, since __gfn_to_pfn_memslot doesn't
693          * do it with !atomic && !async, which is how we call it.
694          * We always ask for write permission since the common case
695          * is that the page is writable.
696          */
697         hva = gfn_to_hva_memslot(memslot, gfn);
698         if (!kvm_ro && __get_user_pages_fast(hva, 1, 1, &page) == 1) {
699                 upgrade_write = true;
700         } else {
701                 unsigned long pfn;
702 
703                 /* Call KVM generic code to do the slow-path check */
704                 pfn = __gfn_to_pfn_memslot(memslot, gfn, false, NULL,
705                                            writing, upgrade_p);
706                 if (is_error_noslot_pfn(pfn))
707                         return -EFAULT;
708                 page = NULL;
709                 if (pfn_valid(pfn)) {
710                         page = pfn_to_page(pfn);
711                         if (PageReserved(page))
712                                 page = NULL;
713                 }
714         }
715 
716         /*
717          * Read the PTE from the process' radix tree and use that
718          * so we get the shift and attribute bits.
719          */
720         local_irq_disable();
721         ptep = __find_linux_pte(vcpu->arch.pgdir, hva, NULL, &shift);
722         /*
723          * If the PTE disappeared temporarily due to a THP
724          * collapse, just return and let the guest try again.
725          */
726         if (!ptep) {
727                 local_irq_enable();
728                 if (page)
729                         put_page(page);
730                 return RESUME_GUEST;
731         }
732         pte = *ptep;
733         local_irq_enable();
734 
735         /* Get pte level from shift/size */
736         if (shift == PUD_SHIFT &&
737             (gpa & (PUD_SIZE - PAGE_SIZE)) ==
738             (hva & (PUD_SIZE - PAGE_SIZE))) {
739                 level = 2;
740         } else if (shift == PMD_SHIFT &&
741                    (gpa & (PMD_SIZE - PAGE_SIZE)) ==
742                    (hva & (PMD_SIZE - PAGE_SIZE))) {
743                 level = 1;
744         } else {
745                 level = 0;
746                 if (shift > PAGE_SHIFT) {
747                         /*
748                          * If the pte maps more than one page, bring over
749                          * bits from the virtual address to get the real
750                          * address of the specific single page we want.
751                          */
752                         unsigned long rpnmask = (1ul << shift) - PAGE_SIZE;
753                         pte = __pte(pte_val(pte) | (hva & rpnmask));
754                 }
755         }
756 
757         pte = __pte(pte_val(pte) | _PAGE_EXEC | _PAGE_ACCESSED);
758         if (writing || upgrade_write) {
759                 if (pte_val(pte) & _PAGE_WRITE)
760                         pte = __pte(pte_val(pte) | _PAGE_DIRTY);
761         } else {
762                 pte = __pte(pte_val(pte) & ~(_PAGE_WRITE | _PAGE_DIRTY));
763         }
764 
765         /* Allocate space in the tree and write the PTE */
766         ret = kvmppc_create_pte(kvm, kvm->arch.pgtable, pte, gpa, level,
767                                 mmu_seq, kvm->arch.lpid, NULL, NULL);
768         if (inserted_pte)
769                 *inserted_pte = pte;
770         if (levelp)
771                 *levelp = level;
772 
773         if (page) {
774                 if (!ret && (pte_val(pte) & _PAGE_WRITE))
775                         set_page_dirty_lock(page);
776                 put_page(page);
777         }
778 
779         return ret;
780 }
781 
782 int kvmppc_book3s_radix_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,
783                                    unsigned long ea, unsigned long dsisr)
784 {
785         struct kvm *kvm = vcpu->kvm;
786         unsigned long gpa, gfn;
787         struct kvm_memory_slot *memslot;
788         long ret;
789         bool writing = !!(dsisr & DSISR_ISSTORE);
790         bool kvm_ro = false;
791 
792         /* Check for unusual errors */
793         if (dsisr & DSISR_UNSUPP_MMU) {
794                 pr_err("KVM: Got unsupported MMU fault\n");
795                 return -EFAULT;
796         }
797         if (dsisr & DSISR_BADACCESS) {
798                 /* Reflect to the guest as DSI */
799                 pr_err("KVM: Got radix HV page fault with DSISR=%lx\n", dsisr);
800                 kvmppc_core_queue_data_storage(vcpu, ea, dsisr);
801                 return RESUME_GUEST;
802         }
803 
804         /* Translate the logical address */
805         gpa = vcpu->arch.fault_gpa & ~0xfffUL;
806         gpa &= ~0xF000000000000000ul;
807         gfn = gpa >> PAGE_SHIFT;
808         if (!(dsisr & DSISR_PRTABLE_FAULT))
809                 gpa |= ea & 0xfff;
810 
811         /* Get the corresponding memslot */
812         memslot = gfn_to_memslot(kvm, gfn);
813 
814         /* No memslot means it's an emulated MMIO region */
815         if (!memslot || (memslot->flags & KVM_MEMSLOT_INVALID)) {
816                 if (dsisr & (DSISR_PRTABLE_FAULT | DSISR_BADACCESS |
817                              DSISR_SET_RC)) {
818                         /*
819                          * Bad address in guest page table tree, or other
820                          * unusual error - reflect it to the guest as DSI.
821                          */
822                         kvmppc_core_queue_data_storage(vcpu, ea, dsisr);
823                         return RESUME_GUEST;
824                 }
825                 return kvmppc_hv_emulate_mmio(run, vcpu, gpa, ea, writing);
826         }
827 
828         if (memslot->flags & KVM_MEM_READONLY) {
829                 if (writing) {
830                         /* give the guest a DSI */
831                         kvmppc_core_queue_data_storage(vcpu, ea, DSISR_ISSTORE |
832                                                        DSISR_PROTFAULT);
833                         return RESUME_GUEST;
834                 }
835                 kvm_ro = true;
836         }
837 
838         /* Failed to set the reference/change bits */
839         if (dsisr & DSISR_SET_RC) {
840                 spin_lock(&kvm->mmu_lock);
841                 if (kvmppc_hv_handle_set_rc(kvm, kvm->arch.pgtable,
842                                             writing, gpa, kvm->arch.lpid))
843                         dsisr &= ~DSISR_SET_RC;
844                 spin_unlock(&kvm->mmu_lock);
845 
846                 if (!(dsisr & (DSISR_BAD_FAULT_64S | DSISR_NOHPTE |
847                                DSISR_PROTFAULT | DSISR_SET_RC)))
848                         return RESUME_GUEST;
849         }
850 
851         /* Try to insert a pte */
852         ret = kvmppc_book3s_instantiate_page(vcpu, gpa, memslot, writing,
853                                              kvm_ro, NULL, NULL);
854 
855         if (ret == 0 || ret == -EAGAIN)
856                 ret = RESUME_GUEST;
857         return ret;
858 }
859 
860 /* Called with kvm->lock held */
861 int kvm_unmap_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,
862                     unsigned long gfn)
863 {
864         pte_t *ptep;
865         unsigned long gpa = gfn << PAGE_SHIFT;
866         unsigned int shift;
867 
868         ptep = __find_linux_pte(kvm->arch.pgtable, gpa, NULL, &shift);
869         if (ptep && pte_present(*ptep))
870                 kvmppc_unmap_pte(kvm, ptep, gpa, shift, memslot,
871                                  kvm->arch.lpid);
872         return 0;                               
873 }
874 
875 /* Called with kvm->lock held */
876 int kvm_age_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,
877                   unsigned long gfn)
878 {
879         pte_t *ptep;
880         unsigned long gpa = gfn << PAGE_SHIFT;
881         unsigned int shift;
882         int ref = 0;
883 
884         ptep = __find_linux_pte(kvm->arch.pgtable, gpa, NULL, &shift);
885         if (ptep && pte_present(*ptep) && pte_young(*ptep)) {
886                 kvmppc_radix_update_pte(kvm, ptep, _PAGE_ACCESSED, 0,
887                                         gpa, shift);
888                 /* XXX need to flush tlb here? */
889                 ref = 1;
890         }
891         return ref;
892 }
893 
894 /* Called with kvm->lock held */
895 int kvm_test_age_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,
896                        unsigned long gfn)
897 {
898         pte_t *ptep;
899         unsigned long gpa = gfn << PAGE_SHIFT;
900         unsigned int shift;
901         int ref = 0;
902 
903         ptep = __find_linux_pte(kvm->arch.pgtable, gpa, NULL, &shift);
904         if (ptep && pte_present(*ptep) && pte_young(*ptep))
905                 ref = 1;
906         return ref;
907 }
908 
909 /* Returns the number of PAGE_SIZE pages that are dirty */
910 static int kvm_radix_test_clear_dirty(struct kvm *kvm,
911                                 struct kvm_memory_slot *memslot, int pagenum)
912 {
913         unsigned long gfn = memslot->base_gfn + pagenum;
914         unsigned long gpa = gfn << PAGE_SHIFT;
915         pte_t *ptep;
916         unsigned int shift;
917         int ret = 0;
918 
919         ptep = __find_linux_pte(kvm->arch.pgtable, gpa, NULL, &shift);
920         if (ptep && pte_present(*ptep) && pte_dirty(*ptep)) {
921                 ret = 1;
922                 if (shift)
923                         ret = 1 << (shift - PAGE_SHIFT);
924                 kvmppc_radix_update_pte(kvm, ptep, _PAGE_DIRTY, 0,
925                                         gpa, shift);
926                 kvmppc_radix_tlbie_page(kvm, gpa, shift, kvm->arch.lpid);
927         }
928         return ret;
929 }
930 
931 long kvmppc_hv_get_dirty_log_radix(struct kvm *kvm,
932                         struct kvm_memory_slot *memslot, unsigned long *map)
933 {
934         unsigned long i, j;
935         int npages;
936 
937         for (i = 0; i < memslot->npages; i = j) {
938                 npages = kvm_radix_test_clear_dirty(kvm, memslot, i);
939 
940                 /*
941                  * Note that if npages > 0 then i must be a multiple of npages,
942                  * since huge pages are only used to back the guest at guest
943                  * real addresses that are a multiple of their size.
944                  * Since we have at most one PTE covering any given guest
945                  * real address, if npages > 1 we can skip to i + npages.
946                  */
947                 j = i + 1;
948                 if (npages) {
949                         set_dirty_bits(map, i, npages);
950                         j = i + npages;
951                 }
952         }
953         return 0;
954 }
955 
956 static void add_rmmu_ap_encoding(struct kvm_ppc_rmmu_info *info,
957                                  int psize, int *indexp)
958 {
959         if (!mmu_psize_defs[psize].shift)
960                 return;
961         info->ap_encodings[*indexp] = mmu_psize_defs[psize].shift |
962                 (mmu_psize_defs[psize].ap << 29);
963         ++(*indexp);
964 }
965 
966 int kvmhv_get_rmmu_info(struct kvm *kvm, struct kvm_ppc_rmmu_info *info)
967 {
968         int i;
969 
970         if (!radix_enabled())
971                 return -EINVAL;
972         memset(info, 0, sizeof(*info));
973 
974         /* 4k page size */
975         info->geometries[0].page_shift = 12;
976         info->geometries[0].level_bits[0] = 9;
977         for (i = 1; i < 4; ++i)
978                 info->geometries[0].level_bits[i] = p9_supported_radix_bits[i];
979         /* 64k page size */
980         info->geometries[1].page_shift = 16;
981         for (i = 0; i < 4; ++i)
982                 info->geometries[1].level_bits[i] = p9_supported_radix_bits[i];
983 
984         i = 0;
985         add_rmmu_ap_encoding(info, MMU_PAGE_4K, &i);
986         add_rmmu_ap_encoding(info, MMU_PAGE_64K, &i);
987         add_rmmu_ap_encoding(info, MMU_PAGE_2M, &i);
988         add_rmmu_ap_encoding(info, MMU_PAGE_1G, &i);
989 
990         return 0;
991 }
992 
993 int kvmppc_init_vm_radix(struct kvm *kvm)
994 {
995         kvm->arch.pgtable = pgd_alloc(kvm->mm);
996         if (!kvm->arch.pgtable)
997                 return -ENOMEM;
998         return 0;
999 }
1000 
1001 static void pte_ctor(void *addr)
1002 {
1003         memset(addr, 0, RADIX_PTE_TABLE_SIZE);
1004 }
1005 
1006 static void pmd_ctor(void *addr)
1007 {
1008         memset(addr, 0, RADIX_PMD_TABLE_SIZE);
1009 }
1010 
1011 struct debugfs_radix_state {
1012         struct kvm      *kvm;
1013         struct mutex    mutex;
1014         unsigned long   gpa;
1015         int             lpid;
1016         int             chars_left;
1017         int             buf_index;
1018         char            buf[128];
1019         u8              hdr;
1020 };
1021 
1022 static int debugfs_radix_open(struct inode *inode, struct file *file)
1023 {
1024         struct kvm *kvm = inode->i_private;
1025         struct debugfs_radix_state *p;
1026 
1027         p = kzalloc(sizeof(*p), GFP_KERNEL);
1028         if (!p)
1029                 return -ENOMEM;
1030 
1031         kvm_get_kvm(kvm);
1032         p->kvm = kvm;
1033         mutex_init(&p->mutex);
1034         file->private_data = p;
1035 
1036         return nonseekable_open(inode, file);
1037 }
1038 
1039 static int debugfs_radix_release(struct inode *inode, struct file *file)
1040 {
1041         struct debugfs_radix_state *p = file->private_data;
1042 
1043         kvm_put_kvm(p->kvm);
1044         kfree(p);
1045         return 0;
1046 }
1047 
1048 static ssize_t debugfs_radix_read(struct file *file, char __user *buf,
1049                                  size_t len, loff_t *ppos)
1050 {
1051         struct debugfs_radix_state *p = file->private_data;
1052         ssize_t ret, r;
1053         unsigned long n;
1054         struct kvm *kvm;
1055         unsigned long gpa;
1056         pgd_t *pgt;
1057         struct kvm_nested_guest *nested;
1058         pgd_t pgd, *pgdp;
1059         pud_t pud, *pudp;
1060         pmd_t pmd, *pmdp;
1061         pte_t *ptep;
1062         int shift;
1063         unsigned long pte;
1064 
1065         kvm = p->kvm;
1066         if (!kvm_is_radix(kvm))
1067                 return 0;
1068 
1069         ret = mutex_lock_interruptible(&p->mutex);
1070         if (ret)
1071                 return ret;
1072 
1073         if (p->chars_left) {
1074                 n = p->chars_left;
1075                 if (n > len)
1076                         n = len;
1077                 r = copy_to_user(buf, p->buf + p->buf_index, n);
1078                 n -= r;
1079                 p->chars_left -= n;
1080                 p->buf_index += n;
1081                 buf += n;
1082                 len -= n;
1083                 ret = n;
1084                 if (r) {
1085                         if (!n)
1086                                 ret = -EFAULT;
1087                         goto out;
1088                 }
1089         }
1090 
1091         gpa = p->gpa;
1092         nested = NULL;
1093         pgt = NULL;
1094         while (len != 0 && p->lpid >= 0) {
1095                 if (gpa >= RADIX_PGTABLE_RANGE) {
1096                         gpa = 0;
1097                         pgt = NULL;
1098                         if (nested) {
1099                                 kvmhv_put_nested(nested);
1100                                 nested = NULL;
1101                         }
1102                         p->lpid = kvmhv_nested_next_lpid(kvm, p->lpid);
1103                         p->hdr = 0;
1104                         if (p->lpid < 0)
1105                                 break;
1106                 }
1107                 if (!pgt) {
1108                         if (p->lpid == 0) {
1109                                 pgt = kvm->arch.pgtable;
1110                         } else {
1111                                 nested = kvmhv_get_nested(kvm, p->lpid, false);
1112                                 if (!nested) {
1113                                         gpa = RADIX_PGTABLE_RANGE;
1114                                         continue;
1115                                 }
1116                                 pgt = nested->shadow_pgtable;
1117                         }
1118                 }
1119                 n = 0;
1120                 if (!p->hdr) {
1121                         if (p->lpid > 0)
1122                                 n = scnprintf(p->buf, sizeof(p->buf),
1123                                               "\nNested LPID %d: ", p->lpid);
1124                         n += scnprintf(p->buf + n, sizeof(p->buf) - n,
1125                                       "pgdir: %lx\n", (unsigned long)pgt);
1126                         p->hdr = 1;
1127                         goto copy;
1128                 }
1129 
1130                 pgdp = pgt + pgd_index(gpa);
1131                 pgd = READ_ONCE(*pgdp);
1132                 if (!(pgd_val(pgd) & _PAGE_PRESENT)) {
1133                         gpa = (gpa & PGDIR_MASK) + PGDIR_SIZE;
1134                         continue;
1135                 }
1136 
1137                 pudp = pud_offset(&pgd, gpa);
1138                 pud = READ_ONCE(*pudp);
1139                 if (!(pud_val(pud) & _PAGE_PRESENT)) {
1140                         gpa = (gpa & PUD_MASK) + PUD_SIZE;
1141                         continue;
1142                 }
1143                 if (pud_val(pud) & _PAGE_PTE) {
1144                         pte = pud_val(pud);
1145                         shift = PUD_SHIFT;
1146                         goto leaf;
1147                 }
1148 
1149                 pmdp = pmd_offset(&pud, gpa);
1150                 pmd = READ_ONCE(*pmdp);
1151                 if (!(pmd_val(pmd) & _PAGE_PRESENT)) {
1152                         gpa = (gpa & PMD_MASK) + PMD_SIZE;
1153                         continue;
1154                 }
1155                 if (pmd_val(pmd) & _PAGE_PTE) {
1156                         pte = pmd_val(pmd);
1157                         shift = PMD_SHIFT;
1158                         goto leaf;
1159                 }
1160 
1161                 ptep = pte_offset_kernel(&pmd, gpa);
1162                 pte = pte_val(READ_ONCE(*ptep));
1163                 if (!(pte & _PAGE_PRESENT)) {
1164                         gpa += PAGE_SIZE;
1165                         continue;
1166                 }
1167                 shift = PAGE_SHIFT;
1168         leaf:
1169                 n = scnprintf(p->buf, sizeof(p->buf),
1170                               " %lx: %lx %d\n", gpa, pte, shift);
1171                 gpa += 1ul << shift;
1172         copy:
1173                 p->chars_left = n;
1174                 if (n > len)
1175                         n = len;
1176                 r = copy_to_user(buf, p->buf, n);
1177                 n -= r;
1178                 p->chars_left -= n;
1179                 p->buf_index = n;
1180                 buf += n;
1181                 len -= n;
1182                 ret += n;
1183                 if (r) {
1184                         if (!ret)
1185                                 ret = -EFAULT;
1186                         break;
1187                 }
1188         }
1189         p->gpa = gpa;
1190         if (nested)
1191                 kvmhv_put_nested(nested);
1192 
1193  out:
1194         mutex_unlock(&p->mutex);
1195         return ret;
1196 }
1197 
1198 static ssize_t debugfs_radix_write(struct file *file, const char __user *buf,
1199                            size_t len, loff_t *ppos)
1200 {
1201         return -EACCES;
1202 }
1203 
1204 static const struct file_operations debugfs_radix_fops = {
1205         .owner   = THIS_MODULE,
1206         .open    = debugfs_radix_open,
1207         .release = debugfs_radix_release,
1208         .read    = debugfs_radix_read,
1209         .write   = debugfs_radix_write,
1210         .llseek  = generic_file_llseek,
1211 };
1212 
1213 void kvmhv_radix_debugfs_init(struct kvm *kvm)
1214 {
1215         kvm->arch.radix_dentry = debugfs_create_file("radix", 0400,
1216                                                      kvm->arch.debugfs_dir, kvm,
1217                                                      &debugfs_radix_fops);
1218 }
1219 
1220 int kvmppc_radix_init(void)
1221 {
1222         unsigned long size = sizeof(void *) << RADIX_PTE_INDEX_SIZE;
1223 
1224         kvm_pte_cache = kmem_cache_create("kvm-pte", size, size, 0, pte_ctor);
1225         if (!kvm_pte_cache)
1226                 return -ENOMEM;
1227 
1228         size = sizeof(void *) << RADIX_PMD_INDEX_SIZE;
1229 
1230         kvm_pmd_cache = kmem_cache_create("kvm-pmd", size, size, 0, pmd_ctor);
1231         if (!kvm_pmd_cache) {
1232                 kmem_cache_destroy(kvm_pte_cache);
1233                 return -ENOMEM;
1234         }
1235 
1236         return 0;
1237 }
1238 
1239 void kvmppc_radix_exit(void)
1240 {
1241         kmem_cache_destroy(kvm_pte_cache);
1242         kmem_cache_destroy(kvm_pmd_cache);
1243 }
1244 

~ [ 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