mmu.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833
  1. /*
  2. * Copyright (C) 2012 - Virtual Open Systems and Columbia University
  3. * Author: Christoffer Dall <c.dall@virtualopensystems.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License, version 2, as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17. */
  18. #include <linux/mman.h>
  19. #include <linux/kvm_host.h>
  20. #include <linux/io.h>
  21. #include <trace/events/kvm.h>
  22. #include <asm/pgalloc.h>
  23. #include <asm/cacheflush.h>
  24. #include <asm/kvm_arm.h>
  25. #include <asm/kvm_mmu.h>
  26. #include <asm/kvm_mmio.h>
  27. #include <asm/kvm_asm.h>
  28. #include <asm/kvm_emulate.h>
  29. #include "trace.h"
  30. extern char __hyp_idmap_text_start[], __hyp_idmap_text_end[];
  31. static pgd_t *boot_hyp_pgd;
  32. static pgd_t *hyp_pgd;
  33. static DEFINE_MUTEX(kvm_hyp_pgd_mutex);
  34. static void *init_bounce_page;
  35. static unsigned long hyp_idmap_start;
  36. static unsigned long hyp_idmap_end;
  37. static phys_addr_t hyp_idmap_vector;
  38. static void kvm_tlb_flush_vmid_ipa(struct kvm *kvm, phys_addr_t ipa)
  39. {
  40. kvm_call_hyp(__kvm_tlb_flush_vmid_ipa, kvm, ipa);
  41. }
  42. static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache,
  43. int min, int max)
  44. {
  45. void *page;
  46. BUG_ON(max > KVM_NR_MEM_OBJS);
  47. if (cache->nobjs >= min)
  48. return 0;
  49. while (cache->nobjs < max) {
  50. page = (void *)__get_free_page(PGALLOC_GFP);
  51. if (!page)
  52. return -ENOMEM;
  53. cache->objects[cache->nobjs++] = page;
  54. }
  55. return 0;
  56. }
  57. static void mmu_free_memory_cache(struct kvm_mmu_memory_cache *mc)
  58. {
  59. while (mc->nobjs)
  60. free_page((unsigned long)mc->objects[--mc->nobjs]);
  61. }
  62. static void *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc)
  63. {
  64. void *p;
  65. BUG_ON(!mc || !mc->nobjs);
  66. p = mc->objects[--mc->nobjs];
  67. return p;
  68. }
  69. static void clear_pud_entry(pud_t *pud)
  70. {
  71. pmd_t *pmd_table = pmd_offset(pud, 0);
  72. pud_clear(pud);
  73. pmd_free(NULL, pmd_table);
  74. put_page(virt_to_page(pud));
  75. }
  76. static void clear_pmd_entry(pmd_t *pmd)
  77. {
  78. pte_t *pte_table = pte_offset_kernel(pmd, 0);
  79. pmd_clear(pmd);
  80. pte_free_kernel(NULL, pte_table);
  81. put_page(virt_to_page(pmd));
  82. }
  83. static bool pmd_empty(pmd_t *pmd)
  84. {
  85. struct page *pmd_page = virt_to_page(pmd);
  86. return page_count(pmd_page) == 1;
  87. }
  88. static void clear_pte_entry(pte_t *pte)
  89. {
  90. if (pte_present(*pte)) {
  91. kvm_set_pte(pte, __pte(0));
  92. put_page(virt_to_page(pte));
  93. }
  94. }
  95. static bool pte_empty(pte_t *pte)
  96. {
  97. struct page *pte_page = virt_to_page(pte);
  98. return page_count(pte_page) == 1;
  99. }
  100. static void unmap_range(pgd_t *pgdp, unsigned long long start, u64 size)
  101. {
  102. pgd_t *pgd;
  103. pud_t *pud;
  104. pmd_t *pmd;
  105. pte_t *pte;
  106. unsigned long long addr = start, end = start + size;
  107. u64 range;
  108. while (addr < end) {
  109. pgd = pgdp + pgd_index(addr);
  110. pud = pud_offset(pgd, addr);
  111. if (pud_none(*pud)) {
  112. addr += PUD_SIZE;
  113. continue;
  114. }
  115. pmd = pmd_offset(pud, addr);
  116. if (pmd_none(*pmd)) {
  117. addr += PMD_SIZE;
  118. continue;
  119. }
  120. pte = pte_offset_kernel(pmd, addr);
  121. clear_pte_entry(pte);
  122. range = PAGE_SIZE;
  123. /* If we emptied the pte, walk back up the ladder */
  124. if (pte_empty(pte)) {
  125. clear_pmd_entry(pmd);
  126. range = PMD_SIZE;
  127. if (pmd_empty(pmd)) {
  128. clear_pud_entry(pud);
  129. range = PUD_SIZE;
  130. }
  131. }
  132. addr += range;
  133. }
  134. }
  135. /**
  136. * free_boot_hyp_pgd - free HYP boot page tables
  137. *
  138. * Free the HYP boot page tables. The bounce page is also freed.
  139. */
  140. void free_boot_hyp_pgd(void)
  141. {
  142. mutex_lock(&kvm_hyp_pgd_mutex);
  143. if (boot_hyp_pgd) {
  144. unmap_range(boot_hyp_pgd, hyp_idmap_start, PAGE_SIZE);
  145. unmap_range(boot_hyp_pgd, TRAMPOLINE_VA, PAGE_SIZE);
  146. kfree(boot_hyp_pgd);
  147. boot_hyp_pgd = NULL;
  148. }
  149. if (hyp_pgd)
  150. unmap_range(hyp_pgd, TRAMPOLINE_VA, PAGE_SIZE);
  151. kfree(init_bounce_page);
  152. init_bounce_page = NULL;
  153. mutex_unlock(&kvm_hyp_pgd_mutex);
  154. }
  155. /**
  156. * free_hyp_pgds - free Hyp-mode page tables
  157. *
  158. * Assumes hyp_pgd is a page table used strictly in Hyp-mode and
  159. * therefore contains either mappings in the kernel memory area (above
  160. * PAGE_OFFSET), or device mappings in the vmalloc range (from
  161. * VMALLOC_START to VMALLOC_END).
  162. *
  163. * boot_hyp_pgd should only map two pages for the init code.
  164. */
  165. void free_hyp_pgds(void)
  166. {
  167. unsigned long addr;
  168. free_boot_hyp_pgd();
  169. mutex_lock(&kvm_hyp_pgd_mutex);
  170. if (hyp_pgd) {
  171. for (addr = PAGE_OFFSET; virt_addr_valid(addr); addr += PGDIR_SIZE)
  172. unmap_range(hyp_pgd, KERN_TO_HYP(addr), PGDIR_SIZE);
  173. for (addr = VMALLOC_START; is_vmalloc_addr((void*)addr); addr += PGDIR_SIZE)
  174. unmap_range(hyp_pgd, KERN_TO_HYP(addr), PGDIR_SIZE);
  175. kfree(hyp_pgd);
  176. hyp_pgd = NULL;
  177. }
  178. mutex_unlock(&kvm_hyp_pgd_mutex);
  179. }
  180. static void create_hyp_pte_mappings(pmd_t *pmd, unsigned long start,
  181. unsigned long end, unsigned long pfn,
  182. pgprot_t prot)
  183. {
  184. pte_t *pte;
  185. unsigned long addr;
  186. addr = start;
  187. do {
  188. pte = pte_offset_kernel(pmd, addr);
  189. kvm_set_pte(pte, pfn_pte(pfn, prot));
  190. get_page(virt_to_page(pte));
  191. kvm_flush_dcache_to_poc(pte, sizeof(*pte));
  192. pfn++;
  193. } while (addr += PAGE_SIZE, addr != end);
  194. }
  195. static int create_hyp_pmd_mappings(pud_t *pud, unsigned long start,
  196. unsigned long end, unsigned long pfn,
  197. pgprot_t prot)
  198. {
  199. pmd_t *pmd;
  200. pte_t *pte;
  201. unsigned long addr, next;
  202. addr = start;
  203. do {
  204. pmd = pmd_offset(pud, addr);
  205. BUG_ON(pmd_sect(*pmd));
  206. if (pmd_none(*pmd)) {
  207. pte = pte_alloc_one_kernel(NULL, addr);
  208. if (!pte) {
  209. kvm_err("Cannot allocate Hyp pte\n");
  210. return -ENOMEM;
  211. }
  212. pmd_populate_kernel(NULL, pmd, pte);
  213. get_page(virt_to_page(pmd));
  214. kvm_flush_dcache_to_poc(pmd, sizeof(*pmd));
  215. }
  216. next = pmd_addr_end(addr, end);
  217. create_hyp_pte_mappings(pmd, addr, next, pfn, prot);
  218. pfn += (next - addr) >> PAGE_SHIFT;
  219. } while (addr = next, addr != end);
  220. return 0;
  221. }
  222. static int __create_hyp_mappings(pgd_t *pgdp,
  223. unsigned long start, unsigned long end,
  224. unsigned long pfn, pgprot_t prot)
  225. {
  226. pgd_t *pgd;
  227. pud_t *pud;
  228. pmd_t *pmd;
  229. unsigned long addr, next;
  230. int err = 0;
  231. mutex_lock(&kvm_hyp_pgd_mutex);
  232. addr = start & PAGE_MASK;
  233. end = PAGE_ALIGN(end);
  234. do {
  235. pgd = pgdp + pgd_index(addr);
  236. pud = pud_offset(pgd, addr);
  237. if (pud_none_or_clear_bad(pud)) {
  238. pmd = pmd_alloc_one(NULL, addr);
  239. if (!pmd) {
  240. kvm_err("Cannot allocate Hyp pmd\n");
  241. err = -ENOMEM;
  242. goto out;
  243. }
  244. pud_populate(NULL, pud, pmd);
  245. get_page(virt_to_page(pud));
  246. kvm_flush_dcache_to_poc(pud, sizeof(*pud));
  247. }
  248. next = pgd_addr_end(addr, end);
  249. err = create_hyp_pmd_mappings(pud, addr, next, pfn, prot);
  250. if (err)
  251. goto out;
  252. pfn += (next - addr) >> PAGE_SHIFT;
  253. } while (addr = next, addr != end);
  254. out:
  255. mutex_unlock(&kvm_hyp_pgd_mutex);
  256. return err;
  257. }
  258. /**
  259. * create_hyp_mappings - duplicate a kernel virtual address range in Hyp mode
  260. * @from: The virtual kernel start address of the range
  261. * @to: The virtual kernel end address of the range (exclusive)
  262. *
  263. * The same virtual address as the kernel virtual address is also used
  264. * in Hyp-mode mapping (modulo HYP_PAGE_OFFSET) to the same underlying
  265. * physical pages.
  266. */
  267. int create_hyp_mappings(void *from, void *to)
  268. {
  269. unsigned long phys_addr = virt_to_phys(from);
  270. unsigned long start = KERN_TO_HYP((unsigned long)from);
  271. unsigned long end = KERN_TO_HYP((unsigned long)to);
  272. /* Check for a valid kernel memory mapping */
  273. if (!virt_addr_valid(from) || !virt_addr_valid(to - 1))
  274. return -EINVAL;
  275. return __create_hyp_mappings(hyp_pgd, start, end,
  276. __phys_to_pfn(phys_addr), PAGE_HYP);
  277. }
  278. /**
  279. * create_hyp_io_mappings - duplicate a kernel IO mapping into Hyp mode
  280. * @from: The kernel start VA of the range
  281. * @to: The kernel end VA of the range (exclusive)
  282. * @phys_addr: The physical start address which gets mapped
  283. *
  284. * The resulting HYP VA is the same as the kernel VA, modulo
  285. * HYP_PAGE_OFFSET.
  286. */
  287. int create_hyp_io_mappings(void *from, void *to, phys_addr_t phys_addr)
  288. {
  289. unsigned long start = KERN_TO_HYP((unsigned long)from);
  290. unsigned long end = KERN_TO_HYP((unsigned long)to);
  291. /* Check for a valid kernel IO mapping */
  292. if (!is_vmalloc_addr(from) || !is_vmalloc_addr(to - 1))
  293. return -EINVAL;
  294. return __create_hyp_mappings(hyp_pgd, start, end,
  295. __phys_to_pfn(phys_addr), PAGE_HYP_DEVICE);
  296. }
  297. /**
  298. * kvm_alloc_stage2_pgd - allocate level-1 table for stage-2 translation.
  299. * @kvm: The KVM struct pointer for the VM.
  300. *
  301. * Allocates the 1st level table only of size defined by S2_PGD_ORDER (can
  302. * support either full 40-bit input addresses or limited to 32-bit input
  303. * addresses). Clears the allocated pages.
  304. *
  305. * Note we don't need locking here as this is only called when the VM is
  306. * created, which can only be done once.
  307. */
  308. int kvm_alloc_stage2_pgd(struct kvm *kvm)
  309. {
  310. pgd_t *pgd;
  311. if (kvm->arch.pgd != NULL) {
  312. kvm_err("kvm_arch already initialized?\n");
  313. return -EINVAL;
  314. }
  315. pgd = (pgd_t *)__get_free_pages(GFP_KERNEL, S2_PGD_ORDER);
  316. if (!pgd)
  317. return -ENOMEM;
  318. /* stage-2 pgd must be aligned to its size */
  319. VM_BUG_ON((unsigned long)pgd & (S2_PGD_SIZE - 1));
  320. memset(pgd, 0, PTRS_PER_S2_PGD * sizeof(pgd_t));
  321. kvm_clean_pgd(pgd);
  322. kvm->arch.pgd = pgd;
  323. return 0;
  324. }
  325. /**
  326. * unmap_stage2_range -- Clear stage2 page table entries to unmap a range
  327. * @kvm: The VM pointer
  328. * @start: The intermediate physical base address of the range to unmap
  329. * @size: The size of the area to unmap
  330. *
  331. * Clear a range of stage-2 mappings, lowering the various ref-counts. Must
  332. * be called while holding mmu_lock (unless for freeing the stage2 pgd before
  333. * destroying the VM), otherwise another faulting VCPU may come in and mess
  334. * with things behind our backs.
  335. */
  336. static void unmap_stage2_range(struct kvm *kvm, phys_addr_t start, u64 size)
  337. {
  338. unmap_range(kvm->arch.pgd, start, size);
  339. }
  340. /**
  341. * kvm_free_stage2_pgd - free all stage-2 tables
  342. * @kvm: The KVM struct pointer for the VM.
  343. *
  344. * Walks the level-1 page table pointed to by kvm->arch.pgd and frees all
  345. * underlying level-2 and level-3 tables before freeing the actual level-1 table
  346. * and setting the struct pointer to NULL.
  347. *
  348. * Note we don't need locking here as this is only called when the VM is
  349. * destroyed, which can only be done once.
  350. */
  351. void kvm_free_stage2_pgd(struct kvm *kvm)
  352. {
  353. if (kvm->arch.pgd == NULL)
  354. return;
  355. unmap_stage2_range(kvm, 0, KVM_PHYS_SIZE);
  356. free_pages((unsigned long)kvm->arch.pgd, S2_PGD_ORDER);
  357. kvm->arch.pgd = NULL;
  358. }
  359. static int stage2_set_pte(struct kvm *kvm, struct kvm_mmu_memory_cache *cache,
  360. phys_addr_t addr, const pte_t *new_pte, bool iomap)
  361. {
  362. pgd_t *pgd;
  363. pud_t *pud;
  364. pmd_t *pmd;
  365. pte_t *pte, old_pte;
  366. /* Create 2nd stage page table mapping - Level 1 */
  367. pgd = kvm->arch.pgd + pgd_index(addr);
  368. pud = pud_offset(pgd, addr);
  369. if (pud_none(*pud)) {
  370. if (!cache)
  371. return 0; /* ignore calls from kvm_set_spte_hva */
  372. pmd = mmu_memory_cache_alloc(cache);
  373. pud_populate(NULL, pud, pmd);
  374. get_page(virt_to_page(pud));
  375. }
  376. pmd = pmd_offset(pud, addr);
  377. /* Create 2nd stage page table mapping - Level 2 */
  378. if (pmd_none(*pmd)) {
  379. if (!cache)
  380. return 0; /* ignore calls from kvm_set_spte_hva */
  381. pte = mmu_memory_cache_alloc(cache);
  382. kvm_clean_pte(pte);
  383. pmd_populate_kernel(NULL, pmd, pte);
  384. get_page(virt_to_page(pmd));
  385. }
  386. pte = pte_offset_kernel(pmd, addr);
  387. if (iomap && pte_present(*pte))
  388. return -EFAULT;
  389. /* Create 2nd stage page table mapping - Level 3 */
  390. old_pte = *pte;
  391. kvm_set_pte(pte, *new_pte);
  392. if (pte_present(old_pte))
  393. kvm_tlb_flush_vmid_ipa(kvm, addr);
  394. else
  395. get_page(virt_to_page(pte));
  396. return 0;
  397. }
  398. /**
  399. * kvm_phys_addr_ioremap - map a device range to guest IPA
  400. *
  401. * @kvm: The KVM pointer
  402. * @guest_ipa: The IPA at which to insert the mapping
  403. * @pa: The physical address of the device
  404. * @size: The size of the mapping
  405. */
  406. int kvm_phys_addr_ioremap(struct kvm *kvm, phys_addr_t guest_ipa,
  407. phys_addr_t pa, unsigned long size)
  408. {
  409. phys_addr_t addr, end;
  410. int ret = 0;
  411. unsigned long pfn;
  412. struct kvm_mmu_memory_cache cache = { 0, };
  413. end = (guest_ipa + size + PAGE_SIZE - 1) & PAGE_MASK;
  414. pfn = __phys_to_pfn(pa);
  415. for (addr = guest_ipa; addr < end; addr += PAGE_SIZE) {
  416. pte_t pte = pfn_pte(pfn, PAGE_S2_DEVICE);
  417. kvm_set_s2pte_writable(&pte);
  418. ret = mmu_topup_memory_cache(&cache, 2, 2);
  419. if (ret)
  420. goto out;
  421. spin_lock(&kvm->mmu_lock);
  422. ret = stage2_set_pte(kvm, &cache, addr, &pte, true);
  423. spin_unlock(&kvm->mmu_lock);
  424. if (ret)
  425. goto out;
  426. pfn++;
  427. }
  428. out:
  429. mmu_free_memory_cache(&cache);
  430. return ret;
  431. }
  432. static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,
  433. gfn_t gfn, struct kvm_memory_slot *memslot,
  434. unsigned long fault_status)
  435. {
  436. pte_t new_pte;
  437. pfn_t pfn;
  438. int ret;
  439. bool write_fault, writable;
  440. unsigned long mmu_seq;
  441. struct kvm_mmu_memory_cache *memcache = &vcpu->arch.mmu_page_cache;
  442. write_fault = kvm_is_write_fault(kvm_vcpu_get_hsr(vcpu));
  443. if (fault_status == FSC_PERM && !write_fault) {
  444. kvm_err("Unexpected L2 read permission error\n");
  445. return -EFAULT;
  446. }
  447. /* We need minimum second+third level pages */
  448. ret = mmu_topup_memory_cache(memcache, 2, KVM_NR_MEM_OBJS);
  449. if (ret)
  450. return ret;
  451. mmu_seq = vcpu->kvm->mmu_notifier_seq;
  452. /*
  453. * Ensure the read of mmu_notifier_seq happens before we call
  454. * gfn_to_pfn_prot (which calls get_user_pages), so that we don't risk
  455. * the page we just got a reference to gets unmapped before we have a
  456. * chance to grab the mmu_lock, which ensure that if the page gets
  457. * unmapped afterwards, the call to kvm_unmap_hva will take it away
  458. * from us again properly. This smp_rmb() interacts with the smp_wmb()
  459. * in kvm_mmu_notifier_invalidate_<page|range_end>.
  460. */
  461. smp_rmb();
  462. pfn = gfn_to_pfn_prot(vcpu->kvm, gfn, write_fault, &writable);
  463. if (is_error_pfn(pfn))
  464. return -EFAULT;
  465. new_pte = pfn_pte(pfn, PAGE_S2);
  466. coherent_icache_guest_page(vcpu->kvm, gfn);
  467. spin_lock(&vcpu->kvm->mmu_lock);
  468. if (mmu_notifier_retry(vcpu->kvm, mmu_seq))
  469. goto out_unlock;
  470. if (writable) {
  471. kvm_set_s2pte_writable(&new_pte);
  472. kvm_set_pfn_dirty(pfn);
  473. }
  474. stage2_set_pte(vcpu->kvm, memcache, fault_ipa, &new_pte, false);
  475. out_unlock:
  476. spin_unlock(&vcpu->kvm->mmu_lock);
  477. kvm_release_pfn_clean(pfn);
  478. return 0;
  479. }
  480. /**
  481. * kvm_handle_guest_abort - handles all 2nd stage aborts
  482. * @vcpu: the VCPU pointer
  483. * @run: the kvm_run structure
  484. *
  485. * Any abort that gets to the host is almost guaranteed to be caused by a
  486. * missing second stage translation table entry, which can mean that either the
  487. * guest simply needs more memory and we must allocate an appropriate page or it
  488. * can mean that the guest tried to access I/O memory, which is emulated by user
  489. * space. The distinction is based on the IPA causing the fault and whether this
  490. * memory region has been registered as standard RAM by user space.
  491. */
  492. int kvm_handle_guest_abort(struct kvm_vcpu *vcpu, struct kvm_run *run)
  493. {
  494. unsigned long fault_status;
  495. phys_addr_t fault_ipa;
  496. struct kvm_memory_slot *memslot;
  497. bool is_iabt;
  498. gfn_t gfn;
  499. int ret, idx;
  500. is_iabt = kvm_vcpu_trap_is_iabt(vcpu);
  501. fault_ipa = kvm_vcpu_get_fault_ipa(vcpu);
  502. trace_kvm_guest_fault(*vcpu_pc(vcpu), kvm_vcpu_get_hsr(vcpu),
  503. kvm_vcpu_get_hfar(vcpu), fault_ipa);
  504. /* Check the stage-2 fault is trans. fault or write fault */
  505. fault_status = kvm_vcpu_trap_get_fault(vcpu);
  506. if (fault_status != FSC_FAULT && fault_status != FSC_PERM) {
  507. kvm_err("Unsupported fault status: EC=%#x DFCS=%#lx\n",
  508. kvm_vcpu_trap_get_class(vcpu), fault_status);
  509. return -EFAULT;
  510. }
  511. idx = srcu_read_lock(&vcpu->kvm->srcu);
  512. gfn = fault_ipa >> PAGE_SHIFT;
  513. if (!kvm_is_visible_gfn(vcpu->kvm, gfn)) {
  514. if (is_iabt) {
  515. /* Prefetch Abort on I/O address */
  516. kvm_inject_pabt(vcpu, kvm_vcpu_get_hfar(vcpu));
  517. ret = 1;
  518. goto out_unlock;
  519. }
  520. if (fault_status != FSC_FAULT) {
  521. kvm_err("Unsupported fault status on io memory: %#lx\n",
  522. fault_status);
  523. ret = -EFAULT;
  524. goto out_unlock;
  525. }
  526. /*
  527. * The IPA is reported as [MAX:12], so we need to
  528. * complement it with the bottom 12 bits from the
  529. * faulting VA. This is always 12 bits, irrespective
  530. * of the page size.
  531. */
  532. fault_ipa |= kvm_vcpu_get_hfar(vcpu) & ((1 << 12) - 1);
  533. ret = io_mem_abort(vcpu, run, fault_ipa);
  534. goto out_unlock;
  535. }
  536. memslot = gfn_to_memslot(vcpu->kvm, gfn);
  537. ret = user_mem_abort(vcpu, fault_ipa, gfn, memslot, fault_status);
  538. if (ret == 0)
  539. ret = 1;
  540. out_unlock:
  541. srcu_read_unlock(&vcpu->kvm->srcu, idx);
  542. return ret;
  543. }
  544. static void handle_hva_to_gpa(struct kvm *kvm,
  545. unsigned long start,
  546. unsigned long end,
  547. void (*handler)(struct kvm *kvm,
  548. gpa_t gpa, void *data),
  549. void *data)
  550. {
  551. struct kvm_memslots *slots;
  552. struct kvm_memory_slot *memslot;
  553. slots = kvm_memslots(kvm);
  554. /* we only care about the pages that the guest sees */
  555. kvm_for_each_memslot(memslot, slots) {
  556. unsigned long hva_start, hva_end;
  557. gfn_t gfn, gfn_end;
  558. hva_start = max(start, memslot->userspace_addr);
  559. hva_end = min(end, memslot->userspace_addr +
  560. (memslot->npages << PAGE_SHIFT));
  561. if (hva_start >= hva_end)
  562. continue;
  563. /*
  564. * {gfn(page) | page intersects with [hva_start, hva_end)} =
  565. * {gfn_start, gfn_start+1, ..., gfn_end-1}.
  566. */
  567. gfn = hva_to_gfn_memslot(hva_start, memslot);
  568. gfn_end = hva_to_gfn_memslot(hva_end + PAGE_SIZE - 1, memslot);
  569. for (; gfn < gfn_end; ++gfn) {
  570. gpa_t gpa = gfn << PAGE_SHIFT;
  571. handler(kvm, gpa, data);
  572. }
  573. }
  574. }
  575. static void kvm_unmap_hva_handler(struct kvm *kvm, gpa_t gpa, void *data)
  576. {
  577. unmap_stage2_range(kvm, gpa, PAGE_SIZE);
  578. kvm_tlb_flush_vmid_ipa(kvm, gpa);
  579. }
  580. int kvm_unmap_hva(struct kvm *kvm, unsigned long hva)
  581. {
  582. unsigned long end = hva + PAGE_SIZE;
  583. if (!kvm->arch.pgd)
  584. return 0;
  585. trace_kvm_unmap_hva(hva);
  586. handle_hva_to_gpa(kvm, hva, end, &kvm_unmap_hva_handler, NULL);
  587. return 0;
  588. }
  589. int kvm_unmap_hva_range(struct kvm *kvm,
  590. unsigned long start, unsigned long end)
  591. {
  592. if (!kvm->arch.pgd)
  593. return 0;
  594. trace_kvm_unmap_hva_range(start, end);
  595. handle_hva_to_gpa(kvm, start, end, &kvm_unmap_hva_handler, NULL);
  596. return 0;
  597. }
  598. static void kvm_set_spte_handler(struct kvm *kvm, gpa_t gpa, void *data)
  599. {
  600. pte_t *pte = (pte_t *)data;
  601. stage2_set_pte(kvm, NULL, gpa, pte, false);
  602. }
  603. void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte)
  604. {
  605. unsigned long end = hva + PAGE_SIZE;
  606. pte_t stage2_pte;
  607. if (!kvm->arch.pgd)
  608. return;
  609. trace_kvm_set_spte_hva(hva);
  610. stage2_pte = pfn_pte(pte_pfn(pte), PAGE_S2);
  611. handle_hva_to_gpa(kvm, hva, end, &kvm_set_spte_handler, &stage2_pte);
  612. }
  613. void kvm_mmu_free_memory_caches(struct kvm_vcpu *vcpu)
  614. {
  615. mmu_free_memory_cache(&vcpu->arch.mmu_page_cache);
  616. }
  617. phys_addr_t kvm_mmu_get_httbr(void)
  618. {
  619. return virt_to_phys(hyp_pgd);
  620. }
  621. phys_addr_t kvm_mmu_get_boot_httbr(void)
  622. {
  623. return virt_to_phys(boot_hyp_pgd);
  624. }
  625. phys_addr_t kvm_get_idmap_vector(void)
  626. {
  627. return hyp_idmap_vector;
  628. }
  629. int kvm_mmu_init(void)
  630. {
  631. int err;
  632. hyp_idmap_start = virt_to_phys(__hyp_idmap_text_start);
  633. hyp_idmap_end = virt_to_phys(__hyp_idmap_text_end);
  634. hyp_idmap_vector = virt_to_phys(__kvm_hyp_init);
  635. if ((hyp_idmap_start ^ hyp_idmap_end) & PAGE_MASK) {
  636. /*
  637. * Our init code is crossing a page boundary. Allocate
  638. * a bounce page, copy the code over and use that.
  639. */
  640. size_t len = __hyp_idmap_text_end - __hyp_idmap_text_start;
  641. phys_addr_t phys_base;
  642. init_bounce_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
  643. if (!init_bounce_page) {
  644. kvm_err("Couldn't allocate HYP init bounce page\n");
  645. err = -ENOMEM;
  646. goto out;
  647. }
  648. memcpy(init_bounce_page, __hyp_idmap_text_start, len);
  649. /*
  650. * Warning: the code we just copied to the bounce page
  651. * must be flushed to the point of coherency.
  652. * Otherwise, the data may be sitting in L2, and HYP
  653. * mode won't be able to observe it as it runs with
  654. * caches off at that point.
  655. */
  656. kvm_flush_dcache_to_poc(init_bounce_page, len);
  657. phys_base = virt_to_phys(init_bounce_page);
  658. hyp_idmap_vector += phys_base - hyp_idmap_start;
  659. hyp_idmap_start = phys_base;
  660. hyp_idmap_end = phys_base + len;
  661. kvm_info("Using HYP init bounce page @%lx\n",
  662. (unsigned long)phys_base);
  663. }
  664. hyp_pgd = kzalloc(PTRS_PER_PGD * sizeof(pgd_t), GFP_KERNEL);
  665. boot_hyp_pgd = kzalloc(PTRS_PER_PGD * sizeof(pgd_t), GFP_KERNEL);
  666. if (!hyp_pgd || !boot_hyp_pgd) {
  667. kvm_err("Hyp mode PGD not allocated\n");
  668. err = -ENOMEM;
  669. goto out;
  670. }
  671. /* Create the idmap in the boot page tables */
  672. err = __create_hyp_mappings(boot_hyp_pgd,
  673. hyp_idmap_start, hyp_idmap_end,
  674. __phys_to_pfn(hyp_idmap_start),
  675. PAGE_HYP);
  676. if (err) {
  677. kvm_err("Failed to idmap %lx-%lx\n",
  678. hyp_idmap_start, hyp_idmap_end);
  679. goto out;
  680. }
  681. /* Map the very same page at the trampoline VA */
  682. err = __create_hyp_mappings(boot_hyp_pgd,
  683. TRAMPOLINE_VA, TRAMPOLINE_VA + PAGE_SIZE,
  684. __phys_to_pfn(hyp_idmap_start),
  685. PAGE_HYP);
  686. if (err) {
  687. kvm_err("Failed to map trampoline @%lx into boot HYP pgd\n",
  688. TRAMPOLINE_VA);
  689. goto out;
  690. }
  691. /* Map the same page again into the runtime page tables */
  692. err = __create_hyp_mappings(hyp_pgd,
  693. TRAMPOLINE_VA, TRAMPOLINE_VA + PAGE_SIZE,
  694. __phys_to_pfn(hyp_idmap_start),
  695. PAGE_HYP);
  696. if (err) {
  697. kvm_err("Failed to map trampoline @%lx into runtime HYP pgd\n",
  698. TRAMPOLINE_VA);
  699. goto out;
  700. }
  701. return 0;
  702. out:
  703. free_hyp_pgds();
  704. return err;
  705. }