xref: /openbmc/linux/virt/kvm/pfncache.c (revision 06e155c4)
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_gpc_check(struct gfn_to_pfn_cache * gpc,unsigned long len)79 bool kvm_gpc_check(struct gfn_to_pfn_cache *gpc, unsigned long len)
80 {
81 	struct kvm_memslots *slots = kvm_memslots(gpc->kvm);
82 
83 	if (!gpc->active)
84 		return false;
85 
86 	if ((gpc->gpa & ~PAGE_MASK) + len > PAGE_SIZE)
87 		return false;
88 
89 	if (gpc->generation != slots->generation || kvm_is_error_hva(gpc->uhva))
90 		return false;
91 
92 	if (!gpc->valid)
93 		return false;
94 
95 	return true;
96 }
97 EXPORT_SYMBOL_GPL(kvm_gpc_check);
98 
gpc_unmap_khva(kvm_pfn_t pfn,void * khva)99 static void gpc_unmap_khva(kvm_pfn_t pfn, void *khva)
100 {
101 	/* Unmap the old pfn/page if it was mapped before. */
102 	if (!is_error_noslot_pfn(pfn) && 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 
mmu_notifier_retry_cache(struct kvm * kvm,unsigned long mmu_seq)112 static inline bool mmu_notifier_retry_cache(struct kvm *kvm, unsigned long mmu_seq)
113 {
114 	/*
115 	 * mn_active_invalidate_count acts for all intents and purposes
116 	 * like mmu_invalidate_in_progress here; but the latter cannot
117 	 * be used here because the invalidation of caches in the
118 	 * mmu_notifier event occurs _before_ mmu_invalidate_in_progress
119 	 * is elevated.
120 	 *
121 	 * Note, it does not matter that mn_active_invalidate_count
122 	 * is not protected by gpc->lock.  It is guaranteed to
123 	 * be elevated before the mmu_notifier acquires gpc->lock, and
124 	 * isn't dropped until after mmu_invalidate_seq is updated.
125 	 */
126 	if (kvm->mn_active_invalidate_count)
127 		return true;
128 
129 	/*
130 	 * Ensure mn_active_invalidate_count is read before
131 	 * mmu_invalidate_seq.  This pairs with the smp_wmb() in
132 	 * mmu_notifier_invalidate_range_end() to guarantee either the
133 	 * old (non-zero) value of mn_active_invalidate_count or the
134 	 * new (incremented) value of mmu_invalidate_seq is observed.
135 	 */
136 	smp_rmb();
137 	return kvm->mmu_invalidate_seq != mmu_seq;
138 }
139 
hva_to_pfn_retry(struct gfn_to_pfn_cache * gpc)140 static kvm_pfn_t hva_to_pfn_retry(struct gfn_to_pfn_cache *gpc)
141 {
142 	/* Note, the new page offset may be different than the old! */
143 	void *old_khva = gpc->khva - offset_in_page(gpc->khva);
144 	kvm_pfn_t new_pfn = KVM_PFN_ERR_FAULT;
145 	void *new_khva = NULL;
146 	unsigned long mmu_seq;
147 
148 	lockdep_assert_held(&gpc->refresh_lock);
149 
150 	lockdep_assert_held_write(&gpc->lock);
151 
152 	/*
153 	 * Invalidate the cache prior to dropping gpc->lock, the gpa=>uhva
154 	 * assets have already been updated and so a concurrent check() from a
155 	 * different task may not fail the gpa/uhva/generation checks.
156 	 */
157 	gpc->valid = false;
158 
159 	do {
160 		mmu_seq = gpc->kvm->mmu_invalidate_seq;
161 		smp_rmb();
162 
163 		write_unlock_irq(&gpc->lock);
164 
165 		/*
166 		 * If the previous iteration "failed" due to an mmu_notifier
167 		 * event, release the pfn and unmap the kernel virtual address
168 		 * from the previous attempt.  Unmapping might sleep, so this
169 		 * needs to be done after dropping the lock.  Opportunistically
170 		 * check for resched while the lock isn't held.
171 		 */
172 		if (new_pfn != KVM_PFN_ERR_FAULT) {
173 			/*
174 			 * Keep the mapping if the previous iteration reused
175 			 * the existing mapping and didn't create a new one.
176 			 */
177 			if (new_khva != old_khva)
178 				gpc_unmap_khva(new_pfn, new_khva);
179 
180 			kvm_release_pfn_clean(new_pfn);
181 
182 			cond_resched();
183 		}
184 
185 		/* We always request a writeable mapping */
186 		new_pfn = hva_to_pfn(gpc->uhva, false, false, NULL, true, NULL);
187 		if (is_error_noslot_pfn(new_pfn))
188 			goto out_error;
189 
190 		/*
191 		 * Obtain a new kernel mapping if KVM itself will access the
192 		 * pfn.  Note, kmap() and memremap() can both sleep, so this
193 		 * too must be done outside of gpc->lock!
194 		 */
195 		if (gpc->usage & KVM_HOST_USES_PFN) {
196 			if (new_pfn == gpc->pfn) {
197 				new_khva = old_khva;
198 			} else if (pfn_valid(new_pfn)) {
199 				new_khva = kmap(pfn_to_page(new_pfn));
200 #ifdef CONFIG_HAS_IOMEM
201 			} else {
202 				new_khva = memremap(pfn_to_hpa(new_pfn), PAGE_SIZE, MEMREMAP_WB);
203 #endif
204 			}
205 			if (!new_khva) {
206 				kvm_release_pfn_clean(new_pfn);
207 				goto out_error;
208 			}
209 		}
210 
211 		write_lock_irq(&gpc->lock);
212 
213 		/*
214 		 * Other tasks must wait for _this_ refresh to complete before
215 		 * attempting to refresh.
216 		 */
217 		WARN_ON_ONCE(gpc->valid);
218 	} while (mmu_notifier_retry_cache(gpc->kvm, mmu_seq));
219 
220 	gpc->valid = true;
221 	gpc->pfn = new_pfn;
222 	gpc->khva = new_khva + (gpc->gpa & ~PAGE_MASK);
223 
224 	/*
225 	 * Put the reference to the _new_ pfn.  The pfn is now tracked by the
226 	 * cache and can be safely migrated, swapped, etc... as the cache will
227 	 * invalidate any mappings in response to relevant mmu_notifier events.
228 	 */
229 	kvm_release_pfn_clean(new_pfn);
230 
231 	return 0;
232 
233 out_error:
234 	write_lock_irq(&gpc->lock);
235 
236 	return -EFAULT;
237 }
238 
__kvm_gpc_refresh(struct gfn_to_pfn_cache * gpc,gpa_t gpa,unsigned long len)239 static int __kvm_gpc_refresh(struct gfn_to_pfn_cache *gpc, gpa_t gpa,
240 			     unsigned long len)
241 {
242 	struct kvm_memslots *slots = kvm_memslots(gpc->kvm);
243 	unsigned long page_offset = gpa & ~PAGE_MASK;
244 	bool unmap_old = false;
245 	unsigned long old_uhva;
246 	kvm_pfn_t old_pfn;
247 	void *old_khva;
248 	int ret;
249 
250 	/*
251 	 * If must fit within a single page. The 'len' argument is
252 	 * only to enforce that.
253 	 */
254 	if (page_offset + len > PAGE_SIZE)
255 		return -EINVAL;
256 
257 	/*
258 	 * If another task is refreshing the cache, wait for it to complete.
259 	 * There is no guarantee that concurrent refreshes will see the same
260 	 * gpa, memslots generation, etc..., so they must be fully serialized.
261 	 */
262 	mutex_lock(&gpc->refresh_lock);
263 
264 	write_lock_irq(&gpc->lock);
265 
266 	if (!gpc->active) {
267 		ret = -EINVAL;
268 		goto out_unlock;
269 	}
270 
271 	old_pfn = gpc->pfn;
272 	old_khva = gpc->khva - offset_in_page(gpc->khva);
273 	old_uhva = gpc->uhva;
274 
275 	/* If the userspace HVA is invalid, refresh that first */
276 	if (gpc->gpa != gpa || gpc->generation != slots->generation ||
277 	    kvm_is_error_hva(gpc->uhva)) {
278 		gfn_t gfn = gpa_to_gfn(gpa);
279 
280 		gpc->gpa = gpa;
281 		gpc->generation = slots->generation;
282 		gpc->memslot = __gfn_to_memslot(slots, gfn);
283 		gpc->uhva = gfn_to_hva_memslot(gpc->memslot, gfn);
284 
285 		if (kvm_is_error_hva(gpc->uhva)) {
286 			ret = -EFAULT;
287 			goto out;
288 		}
289 	}
290 
291 	/*
292 	 * If the userspace HVA changed or the PFN was already invalid,
293 	 * drop the lock and do the HVA to PFN lookup again.
294 	 */
295 	if (!gpc->valid || old_uhva != gpc->uhva) {
296 		ret = hva_to_pfn_retry(gpc);
297 	} else {
298 		/*
299 		 * If the HVA→PFN mapping was already valid, don't unmap it.
300 		 * But do update gpc->khva because the offset within the page
301 		 * may have changed.
302 		 */
303 		gpc->khva = old_khva + page_offset;
304 		ret = 0;
305 		goto out_unlock;
306 	}
307 
308  out:
309 	/*
310 	 * Invalidate the cache and purge the pfn/khva if the refresh failed.
311 	 * Some/all of the uhva, gpa, and memslot generation info may still be
312 	 * valid, leave it as is.
313 	 */
314 	if (ret) {
315 		gpc->valid = false;
316 		gpc->pfn = KVM_PFN_ERR_FAULT;
317 		gpc->khva = NULL;
318 	}
319 
320 	/* Detect a pfn change before dropping the lock! */
321 	unmap_old = (old_pfn != gpc->pfn);
322 
323 out_unlock:
324 	write_unlock_irq(&gpc->lock);
325 
326 	mutex_unlock(&gpc->refresh_lock);
327 
328 	if (unmap_old)
329 		gpc_unmap_khva(old_pfn, old_khva);
330 
331 	return ret;
332 }
333 
kvm_gpc_refresh(struct gfn_to_pfn_cache * gpc,unsigned long len)334 int kvm_gpc_refresh(struct gfn_to_pfn_cache *gpc, unsigned long len)
335 {
336 	return __kvm_gpc_refresh(gpc, gpc->gpa, len);
337 }
338 EXPORT_SYMBOL_GPL(kvm_gpc_refresh);
339 
kvm_gpc_init(struct gfn_to_pfn_cache * gpc,struct kvm * kvm,struct kvm_vcpu * vcpu,enum pfn_cache_usage usage)340 void kvm_gpc_init(struct gfn_to_pfn_cache *gpc, struct kvm *kvm,
341 		  struct kvm_vcpu *vcpu, enum pfn_cache_usage usage)
342 {
343 	WARN_ON_ONCE(!usage || (usage & KVM_GUEST_AND_HOST_USE_PFN) != usage);
344 	WARN_ON_ONCE((usage & KVM_GUEST_USES_PFN) && !vcpu);
345 
346 	rwlock_init(&gpc->lock);
347 	mutex_init(&gpc->refresh_lock);
348 
349 	gpc->kvm = kvm;
350 	gpc->vcpu = vcpu;
351 	gpc->usage = usage;
352 	gpc->pfn = KVM_PFN_ERR_FAULT;
353 	gpc->uhva = KVM_HVA_ERR_BAD;
354 }
355 EXPORT_SYMBOL_GPL(kvm_gpc_init);
356 
kvm_gpc_activate(struct gfn_to_pfn_cache * gpc,gpa_t gpa,unsigned long len)357 int kvm_gpc_activate(struct gfn_to_pfn_cache *gpc, gpa_t gpa, unsigned long len)
358 {
359 	struct kvm *kvm = gpc->kvm;
360 
361 	if (!gpc->active) {
362 		if (KVM_BUG_ON(gpc->valid, kvm))
363 			return -EIO;
364 
365 		spin_lock(&kvm->gpc_lock);
366 		list_add(&gpc->list, &kvm->gpc_list);
367 		spin_unlock(&kvm->gpc_lock);
368 
369 		/*
370 		 * Activate the cache after adding it to the list, a concurrent
371 		 * refresh must not establish a mapping until the cache is
372 		 * reachable by mmu_notifier events.
373 		 */
374 		write_lock_irq(&gpc->lock);
375 		gpc->active = true;
376 		write_unlock_irq(&gpc->lock);
377 	}
378 	return __kvm_gpc_refresh(gpc, gpa, len);
379 }
380 EXPORT_SYMBOL_GPL(kvm_gpc_activate);
381 
kvm_gpc_deactivate(struct gfn_to_pfn_cache * gpc)382 void kvm_gpc_deactivate(struct gfn_to_pfn_cache *gpc)
383 {
384 	struct kvm *kvm = gpc->kvm;
385 	kvm_pfn_t old_pfn;
386 	void *old_khva;
387 
388 	if (gpc->active) {
389 		/*
390 		 * Deactivate the cache before removing it from the list, KVM
391 		 * must stall mmu_notifier events until all users go away, i.e.
392 		 * until gpc->lock is dropped and refresh is guaranteed to fail.
393 		 */
394 		write_lock_irq(&gpc->lock);
395 		gpc->active = false;
396 		gpc->valid = false;
397 
398 		/*
399 		 * Leave the GPA => uHVA cache intact, it's protected by the
400 		 * memslot generation.  The PFN lookup needs to be redone every
401 		 * time as mmu_notifier protection is lost when the cache is
402 		 * removed from the VM's gpc_list.
403 		 */
404 		old_khva = gpc->khva - offset_in_page(gpc->khva);
405 		gpc->khva = NULL;
406 
407 		old_pfn = gpc->pfn;
408 		gpc->pfn = KVM_PFN_ERR_FAULT;
409 		write_unlock_irq(&gpc->lock);
410 
411 		spin_lock(&kvm->gpc_lock);
412 		list_del(&gpc->list);
413 		spin_unlock(&kvm->gpc_lock);
414 
415 		gpc_unmap_khva(old_pfn, old_khva);
416 	}
417 }
418 EXPORT_SYMBOL_GPL(kvm_gpc_deactivate);
419