KVM: Cleanup and unify kvm_mmu_memory_cache usage
v2 cover KVM: Cleanup and unify kvm_mmu_memory_cache usage
Note, patch 18 will conflict with the p4d rework in 5.8. I originally stated I would send v2 only after that got pulled into Paolo's tree, but I got my timing wrong, i.e. I was thinking that would have already happened. I'll send v3 if necessary. I wanted to get v2 out there now that I actually compile tested other architectures.
Marc, I interpreted your "nothing caught fire" as Tested-by for the arm64 patches, let me know if that's not what you intended.
This series resurrects Christoffer Dall's series[1] to provide a common MMU memory cache implementation that can be shared by x86, arm64 and MIPS.
It also picks up a suggested change from Ben Gardon[2] to clear shadow page tables during initial allocation so as to avoid clearing entire pages while holding mmu_lock.
The front half of the patches do house cleaning on x86's memory cache implementation in preparation for moving it to common code, along with a fair bit of cleanup on the usage. The middle chunk moves the patches to common KVM, and the last two chunks convert arm64 and MIPS to the common implementation.
Fully tested on x86 only. Compile tested patches 14-21 on arm64, MIPS, s390 and PowerPC.
v2:
- Rebase to kvm-5.8-2, commit 49b3deaad345 ("Merge tag ...").
- Use an asm-generic kvm_types.h for s390 and PowerPC instead of an empty arch-specific file. [Marc]
- Explicit document "GFP_PGTABLE_USER == GFP_KERNEL_ACCOUNT | GFP_ZERO" in the arm64 conversion patch. [Marc]
- Collect review tags. [Ben]
[1] https://lkml.kernel.org/r/20191105110357.8607-1-christoffer.dall@arm
[2] https://lkml.kernel.org/r/[email protected]
Sean Christopherson (21):
KVM: x86/mmu: Track the associated kmem_cache in the MMU caches
KVM: x86/mmu: Consolidate "page" variant of memory cache helpers
KVM: x86/mmu: Use consistent "mc" name for kvm_mmu_memory_cache locals
KVM: x86/mmu: Remove superfluous gotos from mmu_topup_memory_caches()
KVM: x86/mmu: Try to avoid crashing KVM if a MMU memory cache is empty
KVM: x86/mmu: Move fast_page_fault() call above
mmu_topup_memory_caches()
KVM: x86/mmu: Topup memory caches after walking GVA->GPA
KVM: x86/mmu: Clean up the gorilla math in mmu_topup_memory_caches()
KVM: x86/mmu: Separate the memory caches for shadow pages and gfn
arrays
KVM: x86/mmu: Make __GFP_ZERO a property of the memory cache
KVM: x86/mmu: Zero allocate shadow pages (outside of mmu_lock)
KVM: x86/mmu: Skip filling the gfn cache for guaranteed direct MMU
topups
KVM: x86/mmu: Prepend "kvm_" to memory cache helpers that will be
global
KVM: Move x86's version of struct kvm_mmu_memory_cache to common code
KVM: Move x86's MMU memory cache helpers to common KVM code
KVM: arm64: Drop @max param from mmu_topup_memory_cache()
KVM: arm64: Use common code's approach for __GFP_ZERO with memory
caches
KVM: arm64: Use common KVM implementation of MMU memory caches
KVM: MIPS: Drop @max param from mmu_topup_memory_cache()
KVM: MIPS: Account pages used for GPA page tables
KVM: MIPS: Use common KVM implementation of MMU memory caches
arch/arm64/include/asm/kvm_host.h | 11 --- arch/arm64/include/asm/kvm_types.h | 8 ++ arch/arm64/kvm/arm.c | 2 + arch/arm64/kvm/mmu.c | 54 +++--------- arch/mips/include/asm/kvm_host.h | 11 --- arch/mips/include/asm/kvm_types.h | 7 ++ arch/mips/kvm/mmu.c | 44 ++-------- arch/powerpc/include/asm/Kbuild | 1 + arch/s390/include/asm/Kbuild | 1 + arch/x86/include/asm/kvm_host.h | 14 +--- arch/x86/include/asm/kvm_types.h | 7 ++ arch/x86/kvm/mmu/mmu.c | 129 +++++++++-------------------- arch/x86/kvm/mmu/paging_tmpl.h | 10 +-- include/asm-generic/kvm_types.h | 5 ++ include/linux/kvm_host.h | 7 ++ include/linux/kvm_types.h | 19 +++++ virt/kvm/kvm_main.c | 55 ++++++++++++ 17 files changed, 175 insertions(+), 210 deletions(-) create mode 100644 arch/arm64/include/asm/kvm_types.h create mode 100644 arch/mips/include/asm/kvm_types.h create mode 100644 arch/x86/include/asm/kvm_types.h create mode 100644 include/asm-generic/kvm_types.h
Signature · 1 line
2.26.0
PATCH v2 1/21 KVM: x86/mmu: Track the associated kmem_cache in the MMU caches
Track the kmem_cache used for non-page KVM MMU memory caches instead of passing in the associated kmem_cache when filling the cache. This will allow consolidating code and other cleanups.
No functional change intended.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/mmu/mmu.c | 24 +++++++++++------------- 2 files changed, 12 insertions(+), 13 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -251,6 +251,7 @@ struct kvm_kernel_irq_routing_entry;*/ struct kvm_mmu_memory_cache {int nobjs; +struct kmem_cache *kmem_cache;void *objects[KVM_NR_MEM_OBJS ]; };
arch/x86/kvm/mmu/mmu.c +11 -13
@@ -1060,15 +1060,14 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)local_irq_enable (); } -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache, -struct kmem_cache *base_cache,int min) +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache,int min) {void *obj;if (cache->nobjs >= min)return 0 ;while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - obj =kmem_cache_zalloc (base_cache,GFP_KERNEL_ACCOUNT ); + obj =kmem_cache_zalloc (cache->kmem_cache,GFP_KERNEL_ACCOUNT );if (!obj)return cache->nobjs >= min ?0 : -ENOMEM ; cache->objects[cache->nobjs++] = obj;
@@ -1081,11 +1080,10 @@ static int mmu_memory_cache_free_objects(struct kvm_mmu_memory_cache *cache)return cache->nobjs; } -static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc, -struct kmem_cache *cache) +static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) {while (mc->nobjs) -kmem_cache_free (cache, mc->objects[--mc->nobjs]); +kmem_cache_free (mc->kmem_cache, mc->objects[--mc->nobjs]); } static int mmu_topup_memory_cache_page(struct kvm_mmu_memory_cache *cache,
@@ -1115,25 +1113,22 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu)int r; r =mmu_topup_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache, - pte_list_desc_cache,8 +PTE_PREFETCH_NUM ); +8 +PTE_PREFETCH_NUM );if (r) goto out; r =mmu_topup_memory_cache_page (&vcpu->arch.mmu_page_cache,8 );if (r) goto out; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache, - mmu_page_header_cache,4 ); + r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,4 ); out:return r; }static void mmu_free_memory_caches (struct kvm_vcpu *vcpu) { -mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache, - pte_list_desc_cache); +mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache);mmu_free_memory_cache_page (&vcpu->arch.mmu_page_cache); -mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache, - mmu_page_header_cache); +mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); }static void *mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc)
@@ -5684,6 +5679,9 @@ int kvm_mmu_create(struct kvm_vcpu *vcpu)uint i;int ret; + vcpu->arch.mmu_pte_list_desc_cache.kmem_cache = pte_list_desc_cache; + vcpu->arch.mmu_page_header_cache.kmem_cache = mmu_page_header_cache; + vcpu->arch.mmu = &vcpu->arch.root_mmu; vcpu->arch.walk_mmu = &vcpu->arch.root_mmu;
Signature · 1 line
2.26.0
PATCH v2 2/21 KVM: x86/mmu: Consolidate "page" variant of memory cache helpers
In reply to Sean ChristophersonDrop the "page" variants of the topup/free memory cache helpers, using the existence of an associated kmem_cache to select the correct alloc or free routine.
No functional change intended.
--- arch/x86/kvm/mmu/mmu.c | 37 +++++++++++-------------------------- 1 file changed, 11 insertions(+), 26 deletions(-)
arch/x86/kvm/mmu/mmu.c +11 -26
@@ -1067,7 +1067,10 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache, int min)if (cache->nobjs >= min)return 0 ;while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - obj =kmem_cache_zalloc (cache->kmem_cache,GFP_KERNEL_ACCOUNT ); +if (cache->kmem_cache) + obj =kmem_cache_zalloc (cache->kmem_cache,GFP_KERNEL_ACCOUNT ); +else + obj = (void *)__get_free_page (GFP_KERNEL_ACCOUNT );if (!obj)return cache->nobjs >= min ?0 : -ENOMEM ; cache->objects[cache->nobjs++] = obj;
@@ -1082,30 +1085,12 @@ static int mmu_memory_cache_free_objects(struct kvm_mmu_memory_cache *cache)static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) { -while (mc->nobjs) -kmem_cache_free (mc->kmem_cache, mc->objects[--mc->nobjs]); -} - -static int mmu_topup_memory_cache_page (struct kvm_mmu_memory_cache *cache, -int min) -{ -void *page; - -if (cache->nobjs >= min) -return 0 ; -while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - page = (void *)__get_free_page (GFP_KERNEL_ACCOUNT ); -if (!page) -return cache->nobjs >= min ?0 : -ENOMEM ; - cache->objects[cache->nobjs++] = page; +while (mc->nobjs) { +if (mc->kmem_cache) +kmem_cache_free (mc->kmem_cache, mc->objects[--mc->nobjs]); +else +free_page ((unsigned long )mc->objects[--mc->nobjs]); } -return 0 ; -} - -static void mmu_free_memory_cache_page (struct kvm_mmu_memory_cache *mc) -{ -while (mc->nobjs) -free_page ((unsigned long )mc->objects[--mc->nobjs]); }static int mmu_topup_memory_caches (struct kvm_vcpu *vcpu)
@@ -1116,7 +1101,7 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu) 8 + PTE_PREFETCH_NUM);if (r) goto out; - r =mmu_topup_memory_cache_page (&vcpu->arch.mmu_page_cache,8 ); + r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_cache,8 );if (r) goto out; r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,4 );
@@ -1127,7 +1112,7 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu)static void mmu_free_memory_caches (struct kvm_vcpu *vcpu) {mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache); -mmu_free_memory_cache_page (&vcpu->arch.mmu_page_cache); +mmu_free_memory_cache (&vcpu->arch.mmu_page_cache);mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); }
Signature · 1 line
2.26.0
PATCH v2 3/21 KVM: x86/mmu: Use consistent "mc" name for kvm_mmu_memory_cache locals
In reply to Sean ChristophersonUse "mc" for local variables to shorten line lengths and provide consistent names, which will be especially helpful when some of the helpers are moved to common KVM code in future patches.
No functional change intended.
--- arch/x86/kvm/mmu/mmu.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
arch/x86/kvm/mmu/mmu.c +12 -12
@@ -1060,27 +1060,27 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)local_irq_enable (); } -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache,int min) +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) {void *obj; -if (cache->nobjs >= min) +if (mc->nobjs >= min)return 0 ; -while (cache->nobjs <ARRAY_SIZE (cache->objects)) { -if (cache->kmem_cache) - obj =kmem_cache_zalloc (cache->kmem_cache,GFP_KERNEL_ACCOUNT ); +while (mc->nobjs <ARRAY_SIZE (mc->objects)) { +if (mc->kmem_cache) + obj =kmem_cache_zalloc (mc->kmem_cache,GFP_KERNEL_ACCOUNT );else obj = (void *)__get_free_page (GFP_KERNEL_ACCOUNT );if (!obj) -return cache->nobjs >= min ?0 : -ENOMEM ; - cache->objects[cache->nobjs++] = obj; +return mc->nobjs >= min ?0 : -ENOMEM ; + mc->objects[mc->nobjs++] = obj; }return 0 ; } -static int mmu_memory_cache_free_objects (struct kvm_mmu_memory_cache *cache) +static int mmu_memory_cache_free_objects (struct kvm_mmu_memory_cache *mc) { -return cache->nobjs; +return mc->nobjs; }static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc)
@@ -1395,10 +1395,10 @@ static struct kvm_rmap_head *gfn_to_rmap(struct kvm *kvm, gfn_t gfn,static bool rmap_can_add (struct kvm_vcpu *vcpu) { -struct kvm_mmu_memory_cache *cache; +struct kvm_mmu_memory_cache *mc; - cache = &vcpu->arch.mmu_pte_list_desc_cache; -return mmu_memory_cache_free_objects (cache); + mc = &vcpu->arch.mmu_pte_list_desc_cache; +return mmu_memory_cache_free_objects (mc); }static int rmap_add (struct kvm_vcpu *vcpu,u64 *spte,gfn_t gfn)
Signature · 1 line
2.26.0
PATCH v2 4/21 KVM: x86/mmu: Remove superfluous gotos from mmu_topup_memory_caches()
In reply to Sean ChristophersonReturn errors directly from mmu_topup_memory_caches() instead of branching to a label that does the same.
No functional change intended.
--- arch/x86/kvm/mmu/mmu.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
arch/x86/kvm/mmu/mmu.c +3 -5
@@ -1100,13 +1100,11 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu) r =mmu_topup_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache,8 +PTE_PREFETCH_NUM );if (r) - goto out; +return r; r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_cache,8 );if (r) - goto out; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,4 ); -out: -return r; +return r; +return mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,4 ); }static void mmu_free_memory_caches (struct kvm_vcpu *vcpu)
Signature · 1 line
2.26.0
PATCH v2 5/21 KVM: x86/mmu: Try to avoid crashing KVM if a MMU memory cache is empty
In reply to Sean ChristophersonAttempt to allocate a new object instead of crashing KVM (and likely the kernel) if a memory cache is unexpectedly empty. Use GFP_ATOMIC for the allocation as the caches are used while holding mmu_lock. The immediate BUG_ON() makes the code unnecessarily explosive and led to confusing minimums being used in the past, e.g. allocating 4 objects where 1 would suffice.
--- arch/x86/kvm/mmu/mmu.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-)
arch/x86/kvm/mmu/mmu.c +15 -6
@@ -1060,6 +1060,15 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)local_irq_enable (); } +static inline void *mmu_memory_cache_alloc_obj (struct kvm_mmu_memory_cache *mc, +gfp_t gfp_flags) +{ +if (mc->kmem_cache) +return kmem_cache_zalloc (mc->kmem_cache, gfp_flags); +else +return (void *)__get_free_page (gfp_flags); +} +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) {void *obj;
@@ -1067,10 +1076,7 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *mc, int min)if (mc->nobjs >= min)return 0 ;while (mc->nobjs <ARRAY_SIZE (mc->objects)) { -if (mc->kmem_cache) - obj =kmem_cache_zalloc (mc->kmem_cache,GFP_KERNEL_ACCOUNT ); -else - obj = (void *)__get_free_page (GFP_KERNEL_ACCOUNT ); + obj =mmu_memory_cache_alloc_obj (mc,GFP_KERNEL_ACCOUNT );if (!obj)return mc->nobjs >= min ?0 : -ENOMEM ; mc->objects[mc->nobjs++] = obj;
@@ -1118,8 +1124,11 @@ static void *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc) {void *p; -BUG_ON (!mc->nobjs); - p = mc->objects[--mc->nobjs]; +if (WARN_ON (!mc->nobjs)) + p =mmu_memory_cache_alloc_obj (mc,GFP_ATOMIC | __GFP_ACCOUNT); +else + p = mc->objects[--mc->nobjs]; +BUG_ON (!p);return p; }
Signature · 1 line
2.26.0
Re: [PATCH v2 05/21] KVM: x86/mmu: Try to avoid crashing KVM if a MMU memory cache is empty
Quoted 8 lines · Sean Christopherson
Attempt to allocate a new object instead of crashing KVM (and likely the kernel) if a memory cache is unexpectedly empty. Use
GFP_ATOMICfor the allocation as the caches are used while holdingmmu_lock. The immediateBUG_ON()makes the code unnecessarily explosive and led to confusing minimums being used in the past, e.g. allocating 4 objects where 1 would suffice.
Quoted 54 lines
Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/kvm/mmu/mmu.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-)arch/x86/kvm/mmu/mmu.c +15
-7@@ -1060,6 +1060,15 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)local_irq_enable (); } +static inline void *mmu_memory_cache_alloc_obj (struct kvm_mmu_memory_cache *mc, +gfp_t gfp_flags) +{ +if (mc->kmem_cache) +return kmem_cache_zalloc (mc->kmem_cache, gfp_flags); +else +return (void *)__get_free_page (gfp_flags); +} +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) {void *obj;@@ -1067,10 +1076,7 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *mc, int min)if (mc->nobjs >= min)return 0 ;while (mc->nobjs <ARRAY_SIZE (mc->objects)) { -if (mc->kmem_cache) - obj =kmem_cache_zalloc (mc->kmem_cache,GFP_KERNEL_ACCOUNT ); -else - obj = (void *)__get_free_page (GFP_KERNEL_ACCOUNT ); + obj =mmu_memory_cache_alloc_obj (mc,GFP_KERNEL_ACCOUNT );if (!obj)return mc->nobjs >= min ?0 : -ENOMEM ; mc->objects[mc->nobjs++] = obj;@@ -1118,8 +1124,11 @@ static void *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc) {void *p; -BUG_ON (!mc->nobjs); - p = mc->objects[--mc->nobjs]; +if (WARN_ON (!mc->nobjs)) + p =mmu_memory_cache_alloc_obj (mc,GFP_ATOMIC | __GFP_ACCOUNT); +else + p = mc->objects[--mc->nobjs]; +BUG_ON (!p);return p; } --2.26.0
PATCH v2 6/21 KVM: x86/mmu: Move fast_page_fault() call above mmu_topup_memory_caches()
In reply to Sean ChristophersonAvoid refilling the memory caches and potentially slow reclaim/swap when handling a fast page fault, which does not need to allocate any new objects.
--- arch/x86/kvm/mmu/mmu.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/x86/kvm/mmu/mmu.c +3 -3
@@ -4095,6 +4095,9 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,if (page_fault_handle_page_track (vcpu, error_code, gfn))return RET_PF_EMULATE ; +if (fast_page_fault (vcpu, gpa, error_code)) +return RET_PF_RETRY ; + r =mmu_topup_memory_caches (vcpu);if (r)return r;
@@ -4102,9 +4105,6 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,if (lpage_disallowed) max_level =PG_LEVEL_4K ; -if (fast_page_fault (vcpu, gpa, error_code)) -return RET_PF_RETRY ; - mmu_seq = vcpu->kvm->mmu_notifier_seq;smp_rmb ();
Signature · 1 line
2.26.0
PATCH v2 7/21 KVM: x86/mmu: Topup memory caches after walking GVA->GPA
In reply to Sean ChristophersonTopup memory caches after walking the GVA->GPA translation during a shadow page fault, there is no need to ensure the caches are full when walking the GVA. As of commit f5a1e9f89504f ("KVM: MMU: remove call to kvm_mmu_pte_write from walk_addr"), the FNAME(walk_addr) flow no longer add rmaps via kvm_mmu_pte_write().
This avoids allocating memory in the case that the GVA is unmapped in the guest, and also provides a paper trail of why/when the memory caches need to be filled.
--- arch/x86/kvm/mmu/paging_tmpl.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
arch/x86/kvm/mmu/paging_tmpl.h +4 -4
@@ -791,10 +791,6 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,pgprintk ("%s: addr %lx err %x\n" , __func__, addr, error_code); - r =mmu_topup_memory_caches (vcpu); -if (r) -return r; -/* * If PFEC.RSVD is set, this is a shadow page fault. * The bit needs to be cleared before walking guest page tables.
@@ -822,6 +818,10 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,return RET_PF_EMULATE ; } + r =mmu_topup_memory_caches (vcpu); +if (r) +return r; + vcpu->arch.write_fault_to_shadow_pgtable = false; is_self_change_mapping = FNAME(is_self_change_mapping)(vcpu,
Signature · 1 line
2.26.0
PATCH v2 8/21 KVM: x86/mmu: Clean up the gorilla math in mmu_topup_memory_caches()
In reply to Sean ChristophersonClean up the minimums in mmu_topup_memory_caches() to document the driving mechanisms behind the minimums. Now that encountering an empty cache is unlikely to trigger BUG_ON(), it is less dangerous to be more precise when defining the minimums.
For rmaps, the logic is 1 parent PTE per level, plus a single rmap, and prefetched rmaps. The extra objects in the current '8 + PREFETCH' minimum came about due to an abundance of paranoia in commit c41ef344de212 ("KVM: MMU: increase per-vcpu rmap cache alloc size"), i.e. it could have increased the minimum to 2 rmaps. Furthermore, the unexpected extra rmap case was killed off entirely by commits f759e2b4c728c ("KVM: MMU: avoid pte_list_desc running out in kvm_mmu_pte_write") and f5a1e9f89504f ("KVM: MMU: remove call to kvm_mmu_pte_write from walk_addr").
For the so called page cache, replace '8' with 2*PT64_ROOT_MAX_LEVEL. The 2x multiplier is needed because the cache is used for both shadow pages and gfn arrays for indirect MMUs.
And finally, for page headers, replace '4' with PT64_ROOT_MAX_LEVEL.
Note, KVM now supports 5-level paging, i.e. the old minimums that used a baseline derived from 4-level paging were technically wrong. But, KVM always allocates roots in a separate flow, e.g. it's impossible in the current implementation to actually need 5 new shadow pages in a single flow. Use PT64_ROOT_MAX_LEVEL unmodified instead of subtracting 1, as the direct usage is likely more intuitive to uninformed readers, and the inflated minimum is unlikely to affect functionality in practice.
--- arch/x86/kvm/mmu/mmu.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
arch/x86/kvm/mmu/mmu.c +6 -3
@@ -1103,14 +1103,17 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu) {int r; +/* 1 rmap, 1 parent PTE per level, and the prefetched rmaps. */ r =mmu_topup_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache, -8 +PTE_PREFETCH_NUM ); +1 +PT64_ROOT_MAX_LEVEL +PTE_PREFETCH_NUM );if (r)return r; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_cache,8 ); + r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_cache, +2 *PT64_ROOT_MAX_LEVEL );if (r)return r; -return mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,4 ); +return mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache, +PT64_ROOT_MAX_LEVEL ); }static void mmu_free_memory_caches (struct kvm_vcpu *vcpu)
Signature · 1 line
2.26.0
PATCH v2 9/21 KVM: x86/mmu: Separate the memory caches for shadow pages and gfn arrays
In reply to Sean ChristophersonUse separate caches for allocating shadow pages versus gfn arrays. This sets the stage for specifying __GFP_ZERO when allocating shadow pages without incurring extra cost for gfn arrays.
No functional change intended.
--- arch/x86/include/asm/kvm_host.h | 3 ++- arch/x86/kvm/mmu/mmu.c | 15 ++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-)
arch/x86/include/asm/kvm_host.h +2 -1
@@ -636,7 +636,8 @@ struct kvm_vcpu_arch {struct kvm_mmu *walk_mmu;struct kvm_mmu_memory_cache mmu_pte_list_desc_cache; -struct kvm_mmu_memory_cache mmu_page_cache; +struct kvm_mmu_memory_cache mmu_shadow_page_cache; +struct kvm_mmu_memory_cache mmu_gfn_array_cache;struct kvm_mmu_memory_cache mmu_page_header_cache;/*
arch/x86/kvm/mmu/mmu.c +10 -5
@@ -1108,8 +1108,12 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu) 1 + PT64_ROOT_MAX_LEVEL + PTE_PREFETCH_NUM);if (r)return r; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_page_cache, -2 *PT64_ROOT_MAX_LEVEL ); + r =mmu_topup_memory_cache (&vcpu->arch.mmu_shadow_page_cache, +PT64_ROOT_MAX_LEVEL ); +if (r) +return r; + r =mmu_topup_memory_cache (&vcpu->arch.mmu_gfn_array_cache, +PT64_ROOT_MAX_LEVEL );if (r)return r; return mmu_topup_memory_cache(&vcpu->arch.mmu_page_header_cache,
@@ -1119,7 +1123,8 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu)static void mmu_free_memory_caches (struct kvm_vcpu *vcpu) {mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache); -mmu_free_memory_cache (&vcpu->arch.mmu_page_cache); +mmu_free_memory_cache (&vcpu->arch.mmu_shadow_page_cache); +mmu_free_memory_cache (&vcpu->arch.mmu_gfn_array_cache);mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); }
@@ -2096,9 +2101,9 @@ static struct kvm_mmu_page *kvm_mmu_alloc_page(struct kvm_vcpu *vcpu, int directstruct kvm_mmu_page *sp; sp =mmu_memory_cache_alloc (&vcpu->arch.mmu_page_header_cache); - sp->spt =mmu_memory_cache_alloc (&vcpu->arch.mmu_page_cache); + sp->spt =mmu_memory_cache_alloc (&vcpu->arch.mmu_shadow_page_cache);if (!direct) - sp->gfns =mmu_memory_cache_alloc (&vcpu->arch.mmu_page_cache); + sp->gfns =mmu_memory_cache_alloc (&vcpu->arch.mmu_gfn_array_cache);set_page_private (virt_to_page (sp->spt), (unsigned long )sp);/*
Signature · 1 line
2.26.0
PATCH v2 10/21 KVM: x86/mmu: Make __GFP_ZERO a property of the memory cache
In reply to Sean ChristophersonAdd a gfp_zero flag to 'struct kvm_mmu_memory_cache' and use it to control __GFP_ZERO instead of hardcoding a call to kmem_cache_zalloc(). A future patch needs such a flag for the __get_free_page() path, as gfn arrays do not need/want the allocator to zero the memory. Convert the kmem_cache paths to __GFP_ZERO now so as to avoid a weird and inconsistent API in the future.
No functional change intended.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/mmu/mmu.c | 7 ++++++- 2 files changed, 7 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -251,6 +251,7 @@ struct kvm_kernel_irq_routing_entry;*/ struct kvm_mmu_memory_cache {int nobjs; +gfp_t gfp_zero;struct kmem_cache *kmem_cache;void *objects[KVM_NR_MEM_OBJS ]; };
arch/x86/kvm/mmu/mmu.c +6 -1
@@ -1063,8 +1063,10 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)static inline void *mmu_memory_cache_alloc_obj (struct kvm_mmu_memory_cache *mc,gfp_t gfp_flags) { + gfp_flags |= mc->gfp_zero; +if (mc->kmem_cache) -return kmem_cache_zalloc (mc->kmem_cache, gfp_flags); +return kmem_cache_alloc (mc->kmem_cache, gfp_flags);else return (void *)__get_free_page (gfp_flags); }
@@ -5680,7 +5682,10 @@ int kvm_mmu_create(struct kvm_vcpu *vcpu)int ret; vcpu->arch.mmu_pte_list_desc_cache.kmem_cache = pte_list_desc_cache; + vcpu->arch.mmu_pte_list_desc_cache.gfp_zero = __GFP_ZERO; + vcpu->arch.mmu_page_header_cache.kmem_cache = mmu_page_header_cache; + vcpu->arch.mmu_page_header_cache.gfp_zero = __GFP_ZERO; vcpu->arch.mmu = &vcpu->arch.root_mmu; vcpu->arch.walk_mmu = &vcpu->arch.root_mmu;
Signature · 1 line
2.26.0
PATCH v2 11/21 KVM: x86/mmu: Zero allocate shadow pages (outside of mmu_lock)
In reply to Sean ChristophersonSet __GFP_ZERO for the shadow page memory cache and drop the explicit clear_page() from kvm_mmu_get_page(). This moves the cost of zeroing a page to the allocation time of the physical page, i.e. when topping up the memory caches, and thus avoids having to zero out an entire page while holding mmu_lock.
--- arch/x86/kvm/mmu/mmu.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/x86/kvm/mmu/mmu.c +2 -1
@@ -2545,7 +2545,6 @@ static struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu,if (level >PG_LEVEL_4K && need_sync) flush |=kvm_sync_pages (vcpu, gfn, &invalid_list); } -clear_page (sp->spt);trace_kvm_mmu_get_page (sp, true);kvm_mmu_flush_or_zap (vcpu, &invalid_list, false, flush);
@@ -5687,6 +5686,8 @@ int kvm_mmu_create(struct kvm_vcpu *vcpu) vcpu->arch.mmu_page_header_cache.kmem_cache = mmu_page_header_cache; vcpu->arch.mmu_page_header_cache.gfp_zero = __GFP_ZERO; + vcpu->arch.mmu_shadow_page_cache.gfp_zero = __GFP_ZERO; + vcpu->arch.mmu = &vcpu->arch.root_mmu; vcpu->arch.walk_mmu = &vcpu->arch.root_mmu;
Signature · 1 line
2.26.0
PATCH v2 12/21 KVM: x86/mmu: Skip filling the gfn cache for guaranteed direct MMU topups
In reply to Sean ChristophersonDon't bother filling the gfn array cache when the caller is a fully direct MMU, i.e. won't need a gfn array for shadow pages.
--- arch/x86/kvm/mmu/mmu.c | 18 ++++++++++-------- arch/x86/kvm/mmu/paging_tmpl.h | 4 ++-- 2 files changed, 12 insertions(+), 10 deletions(-)
arch/x86/kvm/mmu/mmu.c +10 -8
@@ -1101,7 +1101,7 @@ static void mmu_free_memory_cache(struct kvm_mmu_memory_cache *mc) } } -static int mmu_topup_memory_caches (struct kvm_vcpu *vcpu) +static int mmu_topup_memory_caches (struct kvm_vcpu *vcpu,bool maybe_indirect) {int r;
@@ -1114,10 +1114,12 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu) PT64_ROOT_MAX_LEVEL);if (r)return r; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_gfn_array_cache, -PT64_ROOT_MAX_LEVEL ); -if (r) -return r; +if (maybe_indirect) { + r =mmu_topup_memory_cache (&vcpu->arch.mmu_gfn_array_cache, +PT64_ROOT_MAX_LEVEL ); +if (r) +return r; + }return mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache,PT64_ROOT_MAX_LEVEL ); }
@@ -4107,7 +4109,7 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,if (fast_page_fault (vcpu, gpa, error_code))return RET_PF_RETRY ; - r =mmu_topup_memory_caches (vcpu); + r =mmu_topup_memory_caches (vcpu, false);if (r)return r;
@@ -5147,7 +5149,7 @@ int kvm_mmu_load(struct kvm_vcpu *vcpu) {int r; - r =mmu_topup_memory_caches (vcpu); + r =mmu_topup_memory_caches (vcpu, !vcpu->arch.mmu->direct_map);if (r) goto out; r =mmu_alloc_roots (vcpu);
@@ -5341,7 +5343,7 @@ static void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,* or not since pte prefetch is skiped if it does not have * enough objects in the cache. */ -mmu_topup_memory_caches (vcpu); +mmu_topup_memory_caches (vcpu, true);spin_lock (&vcpu->kvm->mmu_lock);
arch/x86/kvm/mmu/paging_tmpl.h +2 -2
@@ -818,7 +818,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,return RET_PF_EMULATE ; } - r =mmu_topup_memory_caches (vcpu); + r =mmu_topup_memory_caches (vcpu, true);if (r)return r;
@@ -905,7 +905,7 @@ static void FNAME(invlpg)(struct kvm_vcpu *vcpu, gva_t gva, hpa_t root_hpa)* No need to check return value here, rmap_can_add() can * help us to skip pte prefetch later. */ -mmu_topup_memory_caches (vcpu); +mmu_topup_memory_caches (vcpu, true);if (!VALID_PAGE (root_hpa)) {WARN_ON (1 );
Signature · 1 line
2.26.0
PATCH v2 13/21 KVM: x86/mmu: Prepend "kvm_" to memory cache helpers that will be global
In reply to Sean ChristophersonRename the memory helpers that will soon be moved to common code and be made globaly available via linux/kvm_host.h. "mmu" alone is not a sufficient namespace for globally available KVM symbols.
Opportunistically add "nr_" in mmu_memory_cache_free_objects() to make it clear the function returns the number of free objects, as opposed to freeing existing objects.
--- arch/x86/kvm/mmu/mmu.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-)
arch/x86/kvm/mmu/mmu.c +21 -21
@@ -1071,7 +1071,7 @@ static inline void *mmu_memory_cache_alloc_obj(struct kvm_mmu_memory_cache *mc,return (void *)__get_free_page (gfp_flags); } -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) +static int kvm_mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) {void *obj;
@@ -1086,12 +1086,12 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *mc, int min)return 0 ; } -static int mmu_memory_cache_free_objects (struct kvm_mmu_memory_cache *mc) +static int kvm_mmu_memory_cache_nr_free_objects (struct kvm_mmu_memory_cache *mc) {return mc->nobjs; } -static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) +static void kvm_mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) {while (mc->nobjs) {if (mc->kmem_cache)
@@ -1106,33 +1106,33 @@ static int mmu_topup_memory_caches(struct kvm_vcpu *vcpu, bool maybe_indirect)int r;/* 1 rmap, 1 parent PTE per level, and the prefetched rmaps. */ - r =mmu_topup_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache, -1 +PT64_ROOT_MAX_LEVEL +PTE_PREFETCH_NUM ); + r =kvm_mmu_topup_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache, +1 +PT64_ROOT_MAX_LEVEL +PTE_PREFETCH_NUM );if (r)return r; - r =mmu_topup_memory_cache (&vcpu->arch.mmu_shadow_page_cache, -PT64_ROOT_MAX_LEVEL ); + r =kvm_mmu_topup_memory_cache (&vcpu->arch.mmu_shadow_page_cache, +PT64_ROOT_MAX_LEVEL );if (r)return r;if (maybe_indirect) { - r =mmu_topup_memory_cache (&vcpu->arch.mmu_gfn_array_cache, -PT64_ROOT_MAX_LEVEL ); + r =kvm_mmu_topup_memory_cache (&vcpu->arch.mmu_gfn_array_cache, +PT64_ROOT_MAX_LEVEL );if (r)return r; } -return mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache, -PT64_ROOT_MAX_LEVEL ); +return kvm_mmu_topup_memory_cache (&vcpu->arch.mmu_page_header_cache, +PT64_ROOT_MAX_LEVEL ); }static void mmu_free_memory_caches (struct kvm_vcpu *vcpu) { -mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache); -mmu_free_memory_cache (&vcpu->arch.mmu_shadow_page_cache); -mmu_free_memory_cache (&vcpu->arch.mmu_gfn_array_cache); -mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); +kvm_mmu_free_memory_cache (&vcpu->arch.mmu_pte_list_desc_cache); +kvm_mmu_free_memory_cache (&vcpu->arch.mmu_shadow_page_cache); +kvm_mmu_free_memory_cache (&vcpu->arch.mmu_gfn_array_cache); +kvm_mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); } -static void *mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc) +static void *kvm_mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc) {void *p;
@@ -1146,7 +1146,7 @@ static void *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc)static struct pte_list_desc *mmu_alloc_pte_list_desc (struct kvm_vcpu *vcpu) { -return mmu_memory_cache_alloc (&vcpu->arch.mmu_pte_list_desc_cache); +return kvm_mmu_memory_cache_alloc (&vcpu->arch.mmu_pte_list_desc_cache); }static void mmu_free_pte_list_desc (struct pte_list_desc *pte_list_desc)
@@ -1417,7 +1417,7 @@ static bool rmap_can_add(struct kvm_vcpu *vcpu)struct kvm_mmu_memory_cache *mc; mc = &vcpu->arch.mmu_pte_list_desc_cache; -return mmu_memory_cache_free_objects (mc); +return kvm_mmu_memory_cache_nr_free_objects (mc); }static int rmap_add (struct kvm_vcpu *vcpu,u64 *spte,gfn_t gfn)
@@ -2104,10 +2104,10 @@ static struct kvm_mmu_page *kvm_mmu_alloc_page(struct kvm_vcpu *vcpu, int direct {struct kvm_mmu_page *sp; - sp =mmu_memory_cache_alloc (&vcpu->arch.mmu_page_header_cache); - sp->spt =mmu_memory_cache_alloc (&vcpu->arch.mmu_shadow_page_cache); + sp =kvm_mmu_memory_cache_alloc (&vcpu->arch.mmu_page_header_cache); + sp->spt =kvm_mmu_memory_cache_alloc (&vcpu->arch.mmu_shadow_page_cache);if (!direct) - sp->gfns =mmu_memory_cache_alloc (&vcpu->arch.mmu_gfn_array_cache); + sp->gfns =kvm_mmu_memory_cache_alloc (&vcpu->arch.mmu_gfn_array_cache);set_page_private (virt_to_page (sp->spt), (unsigned long )sp);/*
Signature · 1 line
2.26.0
PATCH v2 14/21 KVM: Move x86's version of struct kvm_mmu_memory_cache to common code
In reply to Sean ChristophersonMove x86's 'struct kvm_mmu_memory_cache' to common code in anticipation of moving the entire x86 implementation code to common KVM and reusing it for arm64 and MIPS. Add a new architecture specific asm/kvm_types.h to control the existence and parameters of the struct. The new header is needed to avoid a chicken-and-egg problem with asm/kvm_host.h as all architectures define instances of the struct in their vCPU structs.
Add an asm-generic version of kvm_types.h to avoid having empty files on PPC and s390 in the long term, and for arm64 and mips in the short term.
--- arch/arm64/include/asm/Kbuild | 1 + arch/mips/include/asm/Kbuild | 1 + arch/powerpc/include/asm/Kbuild | 1 + arch/s390/include/asm/Kbuild | 1 + arch/x86/include/asm/kvm_host.h | 13 ------------- arch/x86/include/asm/kvm_types.h | 7 +++++++ include/asm-generic/kvm_types.h | 5 +++++ include/linux/kvm_types.h | 19 +++++++++++++++++++ 8 files changed, 35 insertions(+), 13 deletions(-) create mode 100644 arch/x86/include/asm/kvm_types.h create mode 100644 include/asm-generic/kvm_types.h
arch/arm64/include/asm/Kbuild +1 -0
@@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 generic-y += early_ioremap.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += qrwlock.h
arch/mips/include/asm/Kbuild +1 -0
@@ -5,6 +5,7 @@ generated-y += syscall_table_64_n32.h generated-y += syscall_table_64_n64.h generated-y += syscall_table_64_o32.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += parport.h
arch/powerpc/include/asm/Kbuild +1 -0
@@ -4,6 +4,7 @@ generated-y += syscall_table_64.h generated-y += syscall_table_c32.h generated-y += syscall_table_spu.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += vtime.h
arch/s390/include/asm/Kbuild +1 -0
@@ -6,5 +6,6 @@ generated-y += unistd_nr.h generic-y += asm-offsets.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h
arch/x86/include/asm/kvm_host.h +0 -13
@@ -193,8 +193,6 @@ struct x86_exception;enum x86_intercept ;enum x86_intercept_stage ; -#define KVM_NR_MEM_OBJS 40 -#define KVM_NR_DB_REGS 4#define DR6_BD (1 << 13)
@@ -245,17 +243,6 @@ enum x86_intercept_stage;struct kvm_kernel_irq_routing_entry ; -/* -* We don't want allocation failures within the mmu code, so we preallocate -* enough memory for a single page fault in a cache. -*/ -struct kvm_mmu_memory_cache { -int nobjs; -gfp_t gfp_zero; -struct kmem_cache *kmem_cache; -void *objects[KVM_NR_MEM_OBJS ]; -}; -/* * the pages used as guest page table on soft mmu are tracked by * kvm_memory_slot.arch.gfn_track which is 16 bits, so the role bits used
arch/x86/include/asm/kvm_types.h new file +7 -0
@@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_KVM_TYPES_H +#define _ASM_X86_KVM_TYPES_H + +#define KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE 40 + +#endif /* _ASM_X86_KVM_TYPES_H */
include/asm-generic/kvm_types.h new file +5 -0
@@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_GENERIC_KVM_TYPES_H +#define _ASM_GENERIC_KVM_TYPES_H + +#endif
include/linux/kvm_types.h +19 -0
@@ -20,6 +20,8 @@ enum kvm_mr_change;#include <linux/types.h> +#include <asm/kvm_types.h> +/* * Address types: *
@@ -58,4 +60,21 @@ struct gfn_to_pfn_cache { bool dirty; }; +#ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE +/* +* Memory caches are used to preallocate memory ahead of various MMU flows, +* e.g. page fault handlers. Gracefully handling allocation failures deep in +* MMU flows is problematic, as is triggering reclaim, I/O, etc... while +* holding MMU locks. Note, these caches act more like prefetch buffers than +* classical caches, i.e. objects are not returned to the cache on being freed. +*/ +struct kvm_mmu_memory_cache { +int nobjs; +gfp_t gfp_zero; +struct kmem_cache *kmem_cache; +void *objects[KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE ]; +}; +#endif + +#endif /* __KVM_TYPES_H__ */
Signature · 1 line
2.26.0
Re: [PATCH v2 14/21] KVM: Move x86's version of struct kvm_mmu_memory_cache to common code
Quoted 8 lines · Sean Christopherson
Move x86's 'struct
kvm_mmu_memory_cache' to common code in anticipation of moving the entire x86 implementation code to common KVM and reusing it for arm64 and MIPS. Add a new architecture specificasm/kvm_types.hto control the existence and parameters of the struct. The new header is needed to avoid a chicken-and-egg problem withasm/kvm_host.has all architectures define instances of the struct in their vCPU structs.
Quoted 4 lines
Add an asm-generic version of
kvm_types.hto avoid having empty files on PPC and s390 in the long term, and for arm64 and mips in the short term.Suggested-by Christoffer Dall <[email protected]>
Quoted 153 lines
Signed-off-by Sean Christopherson <[email protected]>--- arch/arm64/include/asm/Kbuild | 1 + arch/mips/include/asm/Kbuild | 1 + arch/powerpc/include/asm/Kbuild | 1 + arch/s390/include/asm/Kbuild | 1 + arch/x86/include/asm/kvm_host.h | 13 ------------- arch/x86/include/asm/kvm_types.h | 7 +++++++ include/asm-generic/kvm_types.h | 5 +++++ include/linux/kvm_types.h | 19 +++++++++++++++++++ 8 files changed, 35 insertions(+), 13 deletions(-) create mode 100644 arch/x86/include/asm/kvm_types.h create mode 100644 include/asm-generic/kvm_types.harch/arm64/include/asm/Kbuild +1
-0@@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 generic-y += early_ioremap.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += qrwlock.harch/mips/include/asm/Kbuild +1
-0@@ -5,6 +5,7 @@ generated-y += syscall_table_64_n32.h generated-y += syscall_table_64_n64.h generated-y += syscall_table_64_o32.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += parport.harch/powerpc/include/asm/Kbuild +1
-0@@ -4,6 +4,7 @@ generated-y += syscall_table_64.h generated-y += syscall_table_c32.h generated-y += syscall_table_spu.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += vtime.harch/s390/include/asm/Kbuild +1
-0@@ -6,5 +6,6 @@ generated-y += unistd_nr.h generic-y += asm-offsets.h generic-y += export.h +generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.harch/x86/include/asm/kvm_host.h +0
-13@@ -193,8 +193,6 @@ struct x86_exception;enum x86_intercept ;enum x86_intercept_stage ; -#define KVM_NR_MEM_OBJS 40 -#define KVM_NR_DB_REGS 4#define DR6_BD (1 << 13)@@ -245,17 +243,6 @@ enum x86_intercept_stage;struct kvm_kernel_irq_routing_entry ; -/* -* We don't want allocation failures within the mmu code, so we preallocate -* enough memory for a single page fault in a cache. -*/ -struct kvm_mmu_memory_cache { -int nobjs; -gfp_t gfp_zero; -struct kmem_cache *kmem_cache; -void *objects[KVM_NR_MEM_OBJS ]; -}; -/* * the pages used as guest page table on soft mmu are tracked by * kvm_memory_slot.arch.gfn_track which is 16 bits, so the role bits used arch/x86/include/asm/kvm_types.h new file +7
-0@@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_KVM_TYPES_H +#define _ASM_X86_KVM_TYPES_H + +#define KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE 40 + +#endif /* _ASM_X86_KVM_TYPES_H */ include/asm-generic/kvm_types.h new file +5
-0@@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_GENERIC_KVM_TYPES_H +#define _ASM_GENERIC_KVM_TYPES_H + +#endif include/linux/kvm_types.h +19
-1@@ -20,6 +20,8 @@ enum kvm_mr_change;#include <linux/types.h> +#include <asm/kvm_types.h> +/* * Address types: * @@ -58,4 +60,21 @@ struct gfn_to_pfn_cache { bool dirty; }; +#ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE +/* +* Memory caches are used to preallocate memory ahead of various MMU flows, +* e.g. page fault handlers. Gracefully handling allocation failures deep in +* MMU flows is problematic, as is triggering reclaim, I/O, etc... while +* holding MMU locks. Note, these caches act more like prefetch buffers than +* classical caches, i.e. objects are not returned to the cache on being freed. +*/ +struct kvm_mmu_memory_cache { +int nobjs; +gfp_t gfp_zero; +struct kmem_cache *kmem_cache; +void *objects[KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE ]; +}; +#endif + +#endif /* __KVM_TYPES_H__ */ --2.26.0
PATCH v2 15/21 KVM: Move x86's MMU memory cache helpers to common KVM code
In reply to Sean ChristophersonMove x86's memory cache helpers to common KVM code so that they can be reused by arm64 and MIPS in future patches.
--- arch/x86/kvm/mmu/mmu.c | 53 -------------------------------------- include/linux/kvm_host.h | 7 +++++ virt/kvm/kvm_main.c | 55 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+), 53 deletions(-)
arch/x86/kvm/mmu/mmu.c +0 -53
@@ -1060,47 +1060,6 @@ static void walk_shadow_page_lockless_end(struct kvm_vcpu *vcpu)local_irq_enable (); } -static inline void *mmu_memory_cache_alloc_obj (struct kvm_mmu_memory_cache *mc, -gfp_t gfp_flags) -{ - gfp_flags |= mc->gfp_zero; - -if (mc->kmem_cache) -return kmem_cache_alloc (mc->kmem_cache, gfp_flags); -else -return (void *)__get_free_page (gfp_flags); -} - -static int kvm_mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min) -{ -void *obj; - -if (mc->nobjs >= min) -return 0 ; -while (mc->nobjs <ARRAY_SIZE (mc->objects)) { - obj =mmu_memory_cache_alloc_obj (mc,GFP_KERNEL_ACCOUNT ); -if (!obj) -return mc->nobjs >= min ?0 : -ENOMEM ; - mc->objects[mc->nobjs++] = obj; - } -return 0 ; -} - -static int kvm_mmu_memory_cache_nr_free_objects (struct kvm_mmu_memory_cache *mc) -{ -return mc->nobjs; -} - -static void kvm_mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) -{ -while (mc->nobjs) { -if (mc->kmem_cache) -kmem_cache_free (mc->kmem_cache, mc->objects[--mc->nobjs]); -else -free_page ((unsigned long )mc->objects[--mc->nobjs]); - } -} -static int mmu_topup_memory_caches (struct kvm_vcpu *vcpu,bool maybe_indirect) {int r;
@@ -1132,18 +1091,6 @@ static void mmu_free_memory_caches(struct kvm_vcpu *vcpu)kvm_mmu_free_memory_cache (&vcpu->arch.mmu_page_header_cache); } -static void *kvm_mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc) -{ -void *p; - -if (WARN_ON (!mc->nobjs)) - p =mmu_memory_cache_alloc_obj (mc,GFP_ATOMIC | __GFP_ACCOUNT); -else - p = mc->objects[--mc->nobjs]; -BUG_ON (!p); -return p; -} -static struct pte_list_desc *mmu_alloc_pte_list_desc (struct kvm_vcpu *vcpu) {return kvm_mmu_memory_cache_alloc (&vcpu->arch.mmu_pte_list_desc_cache);
include/linux/kvm_host.h +7 -0
@@ -816,6 +816,13 @@ void kvm_vcpu_on_spin(struct kvm_vcpu *vcpu, bool usermode_vcpu_not_eligible);void kvm_flush_remote_tlbs (struct kvm *kvm);void kvm_reload_remote_mmus (struct kvm *kvm); +#ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE +int kvm_mmu_topup_memory_cache (struct kvm_mmu_memory_cache *mc,int min); +int kvm_mmu_memory_cache_nr_free_objects (struct kvm_mmu_memory_cache *mc); +void kvm_mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc); +void *kvm_mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc); +#endif +bool kvm_make_vcpus_request_mask (struct kvm *kvm,unsigned int req,struct kvm_vcpu *except,unsigned long *vcpu_bitmap,cpumask_var_t tmp);
virt/kvm/kvm_main.c +55 -0
61 lines not on this page · raw message
Signature · 1 line
2.26.0
PATCH v2 16/21 KVM: arm64: Drop @max param from mmu_topup_memory_cache()
In reply to Sean ChristophersonReplace the @max param in mmu_topup_memory_cache() and instead use ARRAY_SIZE() to terminate the loop to fill the cache. This removes a BUG_ON() and sets the stage for moving arm64 to the common memory cache implementation.
No functional change intended.
--- arch/arm64/kvm/mmu.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
arch/arm64/kvm/mmu.c +4 -8
@@ -124,15 +124,13 @@ static void stage2_dissolve_pud(struct kvm *kvm, phys_addr_t addr, pud_t *pudp)put_page (virt_to_page (pudp)); } -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache, -int min,int max) +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache,int min) {void *page; -BUG_ON (max >KVM_NR_MEM_OBJS );if (cache->nobjs >= min)return 0 ; -while (cache->nobjs < max) { +while (cache->nobjs <ARRAY_SIZE (cache->objects)) { page = (void *)__get_free_page (GFP_PGTABLE_USER );if (!page)return -ENOMEM ;
@@ -1356,8 +1354,7 @@ int kvm_phys_addr_ioremap(struct kvm *kvm, phys_addr_t guest_ipa, pte =kvm_s2pte_mkwrite (pte); ret =mmu_topup_memory_cache (&cache, -kvm_mmu_cache_min_pages (kvm), -KVM_NR_MEM_OBJS ); +kvm_mmu_cache_min_pages (kvm));if (ret) goto out;spin_lock (&kvm->mmu_lock);
@@ -1737,8 +1734,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,up_read (¤t->mm->mmap_sem);/* We need minimum second+third level pages */ - ret =mmu_topup_memory_cache (memcache,kvm_mmu_cache_min_pages (kvm), -KVM_NR_MEM_OBJS ); + ret =mmu_topup_memory_cache (memcache,kvm_mmu_cache_min_pages (kvm));if (ret)return ret;
Signature · 1 line
2.26.0
PATCH v2 17/21 KVM: arm64: Use common code's approach for __GFP_ZERO with memory caches
In reply to Sean ChristophersonAdd a "gfp_zero" member to arm64's 'struct kvm_mmu_memory_cache' to make the struct and its usage compatible with the common 'struct kvm_mmu_memory_cache' in linux/kvm_host.h. This will minimize code churn when arm64 moves to the common implementation in a future patch, at the cost of temporarily having somewhat silly code.
Note, GFP_PGTABLE_USER is equivalent to GFP_KERNEL_ACCOUNT | GFP_ZERO:
#define GFP_PGTABLE_USER (GFP_PGTABLE_KERNEL | __GFP_ACCOUNT) | -> #define GFP_PGTABLE_KERNEL (GFP_KERNEL | __GFP_ZERO)
== GFP_KERNEL | __GFP_ACCOUNT | __GFP_ZERO
versus
#define GFP_KERNEL_ACCOUNT (GFP_KERNEL | __GFP_ACCOUNT)
with __GFP_ZERO explicitly OR'd in
== GFP_KERNEL | __GFP_ACCOUNT | __GFP_ZERO
No functional change intended.
--- arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/kvm/arm.c | 2 ++ arch/arm64/kvm/mmu.c | 5 +++-- 3 files changed, 6 insertions(+), 2 deletions(-)
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -105,6 +105,7 @@ struct kvm_arch {*/ struct kvm_mmu_memory_cache {int nobjs; +gfp_t gfp_zero;void *objects[KVM_NR_MEM_OBJS ]; };
arch/arm64/kvm/arm.c +2 -0
@@ -270,6 +270,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu) vcpu->arch.target =-1 ;bitmap_zero (vcpu->arch.features,KVM_VCPU_MAX_FEATURES ); + vcpu->arch.mmu_page_cache.gfp_zero = __GFP_ZERO; +/* Set up the timer */ kvm_timer_vcpu_init (vcpu);
arch/arm64/kvm/mmu.c +3 -2
@@ -131,7 +131,8 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache, int min)if (cache->nobjs >= min)return 0 ;while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - page = (void *)__get_free_page (GFP_PGTABLE_USER ); + page = (void *)__get_free_page (GFP_KERNEL_ACCOUNT | + cache->gfp_zero);if (!page)return -ENOMEM ; cache->objects[cache->nobjs++] = page;
@@ -1342,7 +1343,7 @@ int kvm_phys_addr_ioremap(struct kvm *kvm, phys_addr_t guest_ipa,phys_addr_t addr, end;int ret =0 ;unsigned long pfn; -struct kvm_mmu_memory_cache cache = {0 , }; +struct kvm_mmu_memory_cache cache = {0 , __GFP_ZERO, }; end = (guest_ipa + size +PAGE_SIZE -1 ) &PAGE_MASK ; pfn =__phys_to_pfn (pa);
Signature · 1 line
2.26.0
PATCH v2 18/21 KVM: arm64: Use common KVM implementation of MMU memory caches
In reply to Sean ChristophersonMove to the common MMU memory cache implementation now that the common code and arm64's existing code are semantically compatible.
No functional change intended.
--- arch/arm64/include/asm/Kbuild | 1 - arch/arm64/include/asm/kvm_host.h | 12 ------- arch/arm64/include/asm/kvm_types.h | 8 +++++ arch/arm64/kvm/mmu.c | 51 ++++++------------------------ 4 files changed, 18 insertions(+), 54 deletions(-) create mode 100644 arch/arm64/include/asm/kvm_types.h
arch/arm64/include/asm/Kbuild +0 -1
@@ -1,6 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 generic-y += early_ioremap.h -generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += qrwlock.h
arch/arm64/include/asm/kvm_host.h +0 -12
@@ -97,18 +97,6 @@ struct kvm_arch {bool return_nisv_io_abort_to_user; }; -#define KVM_NR_MEM_OBJS 40 - -/* -* We don't want allocation failures within the mmu code, so we preallocate -* enough memory for a single page fault in a cache. -*/ -struct kvm_mmu_memory_cache { -int nobjs; -gfp_t gfp_zero; -void *objects[KVM_NR_MEM_OBJS ]; -}; -struct kvm_vcpu_fault_info {u32 esr_el2;/* Hyp Syndrom Register */ u64 far_el2;/* Hyp Fault Address Register */
arch/arm64/include/asm/kvm_types.h new file +8 -0
@@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_ARM64_KVM_TYPES_H +#define _ASM_ARM64_KVM_TYPES_H + +#define KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE 40 + +#endif /* _ASM_ARM64_KVM_TYPES_H */ +
arch/arm64/kvm/mmu.c +10 -41
111 lines not on this page · raw message
Signature · 1 line
2.26.0
PATCH v2 19/21 KVM: MIPS: Drop @max param from mmu_topup_memory_cache()
In reply to Sean ChristophersonReplace the @max param in mmu_topup_memory_cache() and instead use ARRAY_SIZE() to terminate the loop to fill the cache. This removes a BUG_ON() and sets the stage for moving MIPS to the common memory cache implementation.
No functional change intended.
--- arch/mips/kvm/mmu.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
arch/mips/kvm/mmu.c +4 -8
@@ -25,15 +25,13 @@#define KVM_MMU_CACHE_MIN_PAGES 2#endif -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache, -int min,int max) +static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache,int min) {void *page; -BUG_ON (max >KVM_NR_MEM_OBJS );if (cache->nobjs >= min)return 0 ; -while (cache->nobjs < max) { +while (cache->nobjs <ARRAY_SIZE (cache->objects)) { page = (void *)__get_free_page (GFP_KERNEL );if (!page)return -ENOMEM ;
@@ -711,8 +709,7 @@ static int kvm_mips_map_page(struct kvm_vcpu *vcpu, unsigned long gpa, goto out;/* We need a minimum of cached pages ready for page table creation */ - err =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES , -KVM_NR_MEM_OBJS ); + err =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES );if (err) goto out;
@@ -796,8 +793,7 @@ static pte_t *kvm_trap_emul_pte_for_gva(struct kvm_vcpu *vcpu,int ret;/* We need a minimum of cached pages ready for page table creation */ - ret =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES , -KVM_NR_MEM_OBJS ); + ret =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES );if (ret)return NULL ;
Signature · 1 line
2.26.0
PATCH v2 20/21 KVM: MIPS: Account pages used for GPA page tables
In reply to Sean ChristophersonUse GFP_KERNEL_ACCOUNT instead of GFP_KERNEL when allocating pages for the the GPA page tables. The primary motivation for accounting the allocations is to align with the common KVM memory cache helpers in preparation for moving to the common implementation in a future patch. The actual accounting is a bonus side effect.
--- arch/mips/kvm/mmu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/mips/kvm/mmu.c +1 -1
@@ -32,7 +32,7 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache, int min)if (cache->nobjs >= min)return 0 ;while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - page = (void *)__get_free_page (GFP_KERNEL ); + page = (void *)__get_free_page (GFP_KERNEL_ACCOUNT );if (!page)return -ENOMEM ; cache->objects[cache->nobjs++] = page;
Signature · 1 line
2.26.0
PATCH v2 21/21 KVM: MIPS: Use common KVM implementation of MMU memory caches
In reply to Sean ChristophersonMove to the common MMU memory cache implementation now that the common code and MIPS's existing code are semantically compatible.
No functional change intended.
--- arch/mips/include/asm/Kbuild | 1 - arch/mips/include/asm/kvm_host.h | 11 --------- arch/mips/include/asm/kvm_types.h | 7 ++++++ arch/mips/kvm/mmu.c | 40 ++++--------------------------- 4 files changed, 12 insertions(+), 47 deletions(-) create mode 100644 arch/mips/include/asm/kvm_types.h
arch/mips/include/asm/Kbuild +0 -1
@@ -5,7 +5,6 @@ generated-y += syscall_table_64_n32.h generated-y += syscall_table_64_n64.h generated-y += syscall_table_64_o32.h generic-y += export.h -generic-y += kvm_types.h generic-y += local64.h generic-y += mcs_spinlock.h generic-y += parport.h
arch/mips/include/asm/kvm_host.h +0 -11
@@ -335,17 +335,6 @@ struct kvm_mips_tlb {long tlb_lo[2 ]; }; -#define KVM_NR_MEM_OBJS 4 - -/* -* We don't want allocation failures within the mmu code, so we preallocate -* enough memory for a single page fault in a cache. -*/ -struct kvm_mmu_memory_cache { -int nobjs; -void *objects[KVM_NR_MEM_OBJS ]; -}; -#define KVM_MIPS_AUX_FPU 0x1#define KVM_MIPS_AUX_MSA 0x2
arch/mips/include/asm/kvm_types.h new file +7 -0
@@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_MIPS_KVM_TYPES_H +#define _ASM_MIPS_KVM_TYPES_H + +#define KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE 4 + +#endif /* _ASM_MIPS_KVM_TYPES_H */
arch/mips/kvm/mmu.c +5 -35
@@ -25,39 +25,9 @@#define KVM_MMU_CACHE_MIN_PAGES 2#endif -static int mmu_topup_memory_cache (struct kvm_mmu_memory_cache *cache,int min) -{ -void *page; - -if (cache->nobjs >= min) -return 0 ; -while (cache->nobjs <ARRAY_SIZE (cache->objects)) { - page = (void *)__get_free_page (GFP_KERNEL_ACCOUNT ); -if (!page) -return -ENOMEM ; - cache->objects[cache->nobjs++] = page; - } -return 0 ; -} - -static void mmu_free_memory_cache (struct kvm_mmu_memory_cache *mc) -{ -while (mc->nobjs) -free_page ((unsigned long )mc->objects[--mc->nobjs]); -} - -static void *mmu_memory_cache_alloc (struct kvm_mmu_memory_cache *mc) -{ -void *p; - -BUG_ON (!mc || !mc->nobjs); - p = mc->objects[--mc->nobjs]; -return p; -} -void kvm_mmu_free_memory_caches (struct kvm_vcpu *vcpu) { -mmu_free_memory_cache (&vcpu->arch.mmu_page_cache); +kvm_mmu_free_memory_cache (&vcpu->arch.mmu_page_cache); }/**
@@ -151,7 +121,7 @@ static pte_t *kvm_mips_walk_pgd(pgd_t *pgd, struct kvm_mmu_memory_cache *cache,if (!cache)return NULL ; - new_pmd =mmu_memory_cache_alloc (cache); + new_pmd =kvm_mmu_memory_cache_alloc (cache);pmd_init ((unsigned long )new_pmd, (unsigned long )invalid_pte_table);pud_populate (NULL , pud, new_pmd);
@@ -162,7 +132,7 @@ static pte_t *kvm_mips_walk_pgd(pgd_t *pgd, struct kvm_mmu_memory_cache *cache,if (!cache)return NULL ; - new_pte =mmu_memory_cache_alloc (cache); + new_pte =kvm_mmu_memory_cache_alloc (cache);clear_page (new_pte);pmd_populate_kernel (NULL , pmd, new_pte); }
@@ -709,7 +679,7 @@ static int kvm_mips_map_page(struct kvm_vcpu *vcpu, unsigned long gpa, goto out;/* We need a minimum of cached pages ready for page table creation */ - err =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES ); + err =kvm_mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES );if (err) goto out;
@@ -793,7 +763,7 @@ static pte_t *kvm_trap_emul_pte_for_gva(struct kvm_vcpu *vcpu,int ret;/* We need a minimum of cached pages ready for page table creation */ - ret =mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES ); + ret =kvm_mmu_topup_memory_cache (memcache,KVM_MMU_CACHE_MIN_PAGES );if (ret)return NULL ;
Signature · 1 line
2.26.0
Quoted 5 lines · Sean Christopherson
Note, patch 18 will conflict with the p4d rework in 5.8. I originally stated I would send v2 only after that got pulled into Paolo's tree, but I got my timing wrong, i.e. I was thinking that would have already happened. I'll send v3 if necessary. I wanted to get v2 out there now that I actually compile tested other architectures.
Gah, too impatient by one day :-) I'll spin v3 later in the week.