1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Kernel-based Virtual Machine driver for Linux
4 *
5 * This module enables kernel and guest-mode vCPU access to guest physical
6 * memory with suitable invalidation mechanisms.
7 *
8 * Copyright © 2021 Amazon.com, Inc. or its affiliates.
9 *
10 * Authors:
11 * David Woodhouse <dwmw2@infradead.org>
12 */
13
14 #include <linux/kvm_host.h>
15 #include <linux/kvm.h>
16 #include <linux/highmem.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19
20 #include "kvm_mm.h"
21
22 /*
23 * MMU notifier 'invalidate_range_start' hook.
24 */
gfn_to_pfn_cache_invalidate_start(struct kvm * kvm,unsigned long start,unsigned long end,bool may_block)25 void gfn_to_pfn_cache_invalidate_start(struct kvm *kvm, unsigned long start,
26 unsigned long end, bool may_block)
27 {
28 DECLARE_BITMAP(vcpu_bitmap, KVM_MAX_VCPUS);
29 struct gfn_to_pfn_cache *gpc;
30 bool evict_vcpus = false;
31
32 spin_lock(&kvm->gpc_lock);
33 list_for_each_entry(gpc, &kvm->gpc_list, list) {
34 write_lock_irq(&gpc->lock);
35
36 /* Only a single page so no need to care about length */
37 if (gpc->valid && !is_error_noslot_pfn(gpc->pfn) &&
38 gpc->uhva >= start && gpc->uhva < end) {
39 gpc->valid = false;
40
41 /*
42 * If a guest vCPU could be using the physical address,
43 * it needs to be forced out of guest mode.
44 */
45 if (gpc->usage & KVM_GUEST_USES_PFN) {
46 if (!evict_vcpus) {
47 evict_vcpus = true;
48 bitmap_zero(vcpu_bitmap, KVM_MAX_VCPUS);
49 }
50 __set_bit(gpc->vcpu->vcpu_idx, vcpu_bitmap);
51 }
52 }
53 write_unlock_irq(&gpc->lock);
54 }
55 spin_unlock(&kvm->gpc_lock);
56
57 if (evict_vcpus) {
58 /*
59 * KVM needs to ensure the vCPU is fully out of guest context
60 * before allowing the invalidation to continue.
61 */
62 unsigned int req = KVM_REQ_OUTSIDE_GUEST_MODE;
63 bool called;
64
65 /*
66 * If the OOM reaper is active, then all vCPUs should have
67 * been stopped already, so perform the request without
68 * KVM_REQUEST_WAIT and be sad if any needed to be IPI'd.
69 */
70 if (!may_block)
71 req &= ~KVM_REQUEST_WAIT;
72
73 called = kvm_make_vcpus_request_mask(kvm, req, vcpu_bitmap);
74
75 WARN_ON_ONCE(called && !may_block);
76 }
77 }
78
kvm_gfn_to_pfn_cache_check(struct kvm * kvm,struct gfn_to_pfn_cache * gpc,gpa_t gpa,unsigned long len)79 bool kvm_gfn_to_pfn_cache_check(struct kvm *kvm, struct gfn_to_pfn_cache *gpc,
80 gpa_t gpa, unsigned long len)
81 {
82 struct kvm_memslots *slots = kvm_memslots(kvm);
83
84 if ((gpa & ~PAGE_MASK) + len > PAGE_SIZE)
85 return false;
86
87 if (gpc->gpa != gpa || gpc->generation != slots->generation ||
88 kvm_is_error_hva(gpc->uhva))
89 return false;
90
91 if (!gpc->valid)
92 return false;
93
94 return true;
95 }
96 EXPORT_SYMBOL_GPL(kvm_gfn_to_pfn_cache_check);
97
gpc_release_pfn_and_khva(struct kvm * kvm,kvm_pfn_t pfn,void * khva)98 static void gpc_release_pfn_and_khva(struct kvm *kvm, kvm_pfn_t pfn, void *khva)
99 {
100 /* Unmap the old page if it was mapped before, and release it */
101 if (!is_error_noslot_pfn(pfn)) {
102 if (khva) {
103 if (pfn_valid(pfn))
104 kunmap(pfn_to_page(pfn));
105 #ifdef CONFIG_HAS_IOMEM
106 else
107 memunmap(khva);
108 #endif
109 }
110
111 kvm_release_pfn(pfn, false);
112 }
113 }
114
mmu_notifier_retry_cache(struct kvm * kvm,unsigned long mmu_seq)115 static inline bool mmu_notifier_retry_cache(struct kvm *kvm, unsigned long mmu_seq)
116 {
117 /*
118 * mn_active_invalidate_count acts for all intents and purposes
119 * like mmu_notifier_count here; but the latter cannot be used
120 * here because the invalidation of caches in the mmu_notifier
121 * event occurs _before_ mmu_notifier_count is elevated.
122 *
123 * Note, it does not matter that mn_active_invalidate_count
124 * is not protected by gpc->lock. It is guaranteed to
125 * be elevated before the mmu_notifier acquires gpc->lock, and
126 * isn't dropped until after mmu_notifier_seq is updated.
127 */
128 if (kvm->mn_active_invalidate_count)
129 return true;
130
131 /*
132 * Ensure mn_active_invalidate_count is read before
133 * mmu_notifier_seq. This pairs with the smp_wmb() in
134 * mmu_notifier_invalidate_range_end() to guarantee either the
135 * old (non-zero) value of mn_active_invalidate_count or the
136 * new (incremented) value of mmu_notifier_seq is observed.
137 */
138 smp_rmb();
139 return kvm->mmu_notifier_seq != mmu_seq;
140 }
141
hva_to_pfn_retry(struct kvm * kvm,struct gfn_to_pfn_cache * gpc)142 static kvm_pfn_t hva_to_pfn_retry(struct kvm *kvm, struct gfn_to_pfn_cache *gpc)
143 {
144 /* Note, the new page offset may be different than the old! */
145 void *old_khva = gpc->khva - offset_in_page(gpc->khva);
146 kvm_pfn_t new_pfn = KVM_PFN_ERR_FAULT;
147 void *new_khva = NULL;
148 unsigned long mmu_seq;
149
150 lockdep_assert_held(&gpc->refresh_lock);
151
152 lockdep_assert_held_write(&gpc->lock);
153
154 /*
155 * Invalidate the cache prior to dropping gpc->lock, the gpa=>uhva
156 * assets have already been updated and so a concurrent check() from a
157 * different task may not fail the gpa/uhva/generation checks.
158 */
159 gpc->valid = false;
160
161 do {
162 mmu_seq = kvm->mmu_notifier_seq;
163 smp_rmb();
164
165 write_unlock_irq(&gpc->lock);
166
167 /*
168 * If the previous iteration "failed" due to an mmu_notifier
169 * event, release the pfn and unmap the kernel virtual address
170 * from the previous attempt. Unmapping might sleep, so this
171 * needs to be done after dropping the lock. Opportunistically
172 * check for resched while the lock isn't held.
173 */
174 if (new_pfn != KVM_PFN_ERR_FAULT) {
175 /*
176 * Keep the mapping if the previous iteration reused
177 * the existing mapping and didn't create a new one.
178 */
179 if (new_khva == old_khva)
180 new_khva = NULL;
181
182 gpc_release_pfn_and_khva(kvm, new_pfn, new_khva);
183
184 cond_resched();
185 }
186
187 /* We always request a writeable mapping */
188 new_pfn = hva_to_pfn(gpc->uhva, false, NULL, true, NULL);
189 if (is_error_noslot_pfn(new_pfn))
190 goto out_error;
191
192 /*
193 * Obtain a new kernel mapping if KVM itself will access the
194 * pfn. Note, kmap() and memremap() can both sleep, so this
195 * too must be done outside of gpc->lock!
196 */
197 if (gpc->usage & KVM_HOST_USES_PFN) {
198 if (new_pfn == gpc->pfn) {
199 new_khva = old_khva;
200 } else if (pfn_valid(new_pfn)) {
201 new_khva = kmap(pfn_to_page(new_pfn));
202 #ifdef CONFIG_HAS_IOMEM
203 } else {
204 new_khva = memremap(pfn_to_hpa(new_pfn), PAGE_SIZE, MEMREMAP_WB);
205 #endif
206 }
207 if (!new_khva) {
208 kvm_release_pfn_clean(new_pfn);
209 goto out_error;
210 }
211 }
212
213 write_lock_irq(&gpc->lock);
214
215 /*
216 * Other tasks must wait for _this_ refresh to complete before
217 * attempting to refresh.
218 */
219 WARN_ON_ONCE(gpc->valid);
220 } while (mmu_notifier_retry_cache(kvm, mmu_seq));
221
222 gpc->valid = true;
223 gpc->pfn = new_pfn;
224 gpc->khva = new_khva + (gpc->gpa & ~PAGE_MASK);
225 return 0;
226
227 out_error:
228 write_lock_irq(&gpc->lock);
229
230 return -EFAULT;
231 }
232
kvm_gfn_to_pfn_cache_refresh(struct kvm * kvm,struct gfn_to_pfn_cache * gpc,gpa_t gpa,unsigned long len)233 int kvm_gfn_to_pfn_cache_refresh(struct kvm *kvm, struct gfn_to_pfn_cache *gpc,
234 gpa_t gpa, unsigned long len)
235 {
236 struct kvm_memslots *slots = kvm_memslots(kvm);
237 unsigned long page_offset = gpa & ~PAGE_MASK;
238 kvm_pfn_t old_pfn, new_pfn;
239 unsigned long old_uhva;
240 void *old_khva;
241 int ret = 0;
242
243 /*
244 * If must fit within a single page. The 'len' argument is
245 * only to enforce that.
246 */
247 if (page_offset + len > PAGE_SIZE)
248 return -EINVAL;
249
250 /*
251 * If another task is refreshing the cache, wait for it to complete.
252 * There is no guarantee that concurrent refreshes will see the same
253 * gpa, memslots generation, etc..., so they must be fully serialized.
254 */
255 mutex_lock(&gpc->refresh_lock);
256
257 write_lock_irq(&gpc->lock);
258
259 old_pfn = gpc->pfn;
260 old_khva = gpc->khva - offset_in_page(gpc->khva);
261 old_uhva = gpc->uhva;
262
263 /* If the userspace HVA is invalid, refresh that first */
264 if (gpc->gpa != gpa || gpc->generation != slots->generation ||
265 kvm_is_error_hva(gpc->uhva)) {
266 gfn_t gfn = gpa_to_gfn(gpa);
267
268 gpc->gpa = gpa;
269 gpc->generation = slots->generation;
270 gpc->memslot = __gfn_to_memslot(slots, gfn);
271 gpc->uhva = gfn_to_hva_memslot(gpc->memslot, gfn);
272
273 if (kvm_is_error_hva(gpc->uhva)) {
274 ret = -EFAULT;
275 goto out;
276 }
277 }
278
279 /*
280 * If the userspace HVA changed or the PFN was already invalid,
281 * drop the lock and do the HVA to PFN lookup again.
282 */
283 if (!gpc->valid || old_uhva != gpc->uhva) {
284 ret = hva_to_pfn_retry(kvm, gpc);
285 } else {
286 /* If the HVA→PFN mapping was already valid, don't unmap it. */
287 old_pfn = KVM_PFN_ERR_FAULT;
288 old_khva = NULL;
289 }
290
291 out:
292 /*
293 * Invalidate the cache and purge the pfn/khva if the refresh failed.
294 * Some/all of the uhva, gpa, and memslot generation info may still be
295 * valid, leave it as is.
296 */
297 if (ret) {
298 gpc->valid = false;
299 gpc->pfn = KVM_PFN_ERR_FAULT;
300 gpc->khva = NULL;
301 }
302
303 /* Snapshot the new pfn before dropping the lock! */
304 new_pfn = gpc->pfn;
305
306 write_unlock_irq(&gpc->lock);
307
308 mutex_unlock(&gpc->refresh_lock);
309
310 if (old_pfn != new_pfn)
311 gpc_release_pfn_and_khva(kvm, old_pfn, old_khva);
312
313 return ret;
314 }
315 EXPORT_SYMBOL_GPL(kvm_gfn_to_pfn_cache_refresh);
316
kvm_gfn_to_pfn_cache_unmap(struct kvm * kvm,struct gfn_to_pfn_cache * gpc)317 void kvm_gfn_to_pfn_cache_unmap(struct kvm *kvm, struct gfn_to_pfn_cache *gpc)
318 {
319 void *old_khva;
320 kvm_pfn_t old_pfn;
321
322 mutex_lock(&gpc->refresh_lock);
323 write_lock_irq(&gpc->lock);
324
325 gpc->valid = false;
326
327 old_khva = gpc->khva - offset_in_page(gpc->khva);
328 old_pfn = gpc->pfn;
329
330 /*
331 * We can leave the GPA → uHVA map cache intact but the PFN
332 * lookup will need to be redone even for the same page.
333 */
334 gpc->khva = NULL;
335 gpc->pfn = KVM_PFN_ERR_FAULT;
336
337 write_unlock_irq(&gpc->lock);
338 mutex_unlock(&gpc->refresh_lock);
339
340 gpc_release_pfn_and_khva(kvm, old_pfn, old_khva);
341 }
342 EXPORT_SYMBOL_GPL(kvm_gfn_to_pfn_cache_unmap);
343
344
kvm_gfn_to_pfn_cache_init(struct kvm * kvm,struct gfn_to_pfn_cache * gpc,struct kvm_vcpu * vcpu,enum pfn_cache_usage usage,gpa_t gpa,unsigned long len)345 int kvm_gfn_to_pfn_cache_init(struct kvm *kvm, struct gfn_to_pfn_cache *gpc,
346 struct kvm_vcpu *vcpu, enum pfn_cache_usage usage,
347 gpa_t gpa, unsigned long len)
348 {
349 WARN_ON_ONCE(!usage || (usage & KVM_GUEST_AND_HOST_USE_PFN) != usage);
350
351 if (!gpc->active) {
352 rwlock_init(&gpc->lock);
353 mutex_init(&gpc->refresh_lock);
354
355 gpc->khva = NULL;
356 gpc->pfn = KVM_PFN_ERR_FAULT;
357 gpc->uhva = KVM_HVA_ERR_BAD;
358 gpc->vcpu = vcpu;
359 gpc->usage = usage;
360 gpc->valid = false;
361 gpc->active = true;
362
363 spin_lock(&kvm->gpc_lock);
364 list_add(&gpc->list, &kvm->gpc_list);
365 spin_unlock(&kvm->gpc_lock);
366 }
367 return kvm_gfn_to_pfn_cache_refresh(kvm, gpc, gpa, len);
368 }
369 EXPORT_SYMBOL_GPL(kvm_gfn_to_pfn_cache_init);
370
kvm_gfn_to_pfn_cache_destroy(struct kvm * kvm,struct gfn_to_pfn_cache * gpc)371 void kvm_gfn_to_pfn_cache_destroy(struct kvm *kvm, struct gfn_to_pfn_cache *gpc)
372 {
373 if (gpc->active) {
374 spin_lock(&kvm->gpc_lock);
375 list_del(&gpc->list);
376 spin_unlock(&kvm->gpc_lock);
377
378 kvm_gfn_to_pfn_cache_unmap(kvm, gpc);
379 gpc->active = false;
380 }
381 }
382 EXPORT_SYMBOL_GPL(kvm_gfn_to_pfn_cache_destroy);
383