AMD broadcast TLB invalidation
Subsystems (7)
v8 cover AMD broadcast TLB invalidation
Add support for broadcast TLB invalidation using AMD's INVLPGB instruction.
This allows the kernel to invalidate TLB entries on remote CPUs without needing to send IPIs, without having to wait for remote CPUs to handle those interrupts, and with less interruption to what was running on those CPUs.
Because x86 PCID space is limited, and there are some very large systems out there, broadcast TLB invalidation is only used for processes that are active on 3 or more CPUs, with the threshold being gradually increased the more the PCID space gets exhausted.
Combined with the removal of unnecessary lru_add_drain calls (see https://lkml.org/lkml/2024/12/19/1388) this results in a nice performance boost for the will-it-scale tlb_flush2_threads test on an AMD Milan system with 36 cores:
- vanilla kernel: 527k loops/second - lru_add_drain removal: 731k loops/second - only INVLPGB: 527k loops/second
- lru_add_drain + INVLPGB: 1157k loops/second
Profiling with only the INVLPGB changes showed while TLB invalidation went down from 40% of the total CPU time to only around 4% of CPU time, the contention simply moved to the LRU lock.
Fixing both at the same time about doubles the
number of iterations per second from this case.
Some numbers closer to real world performance
can be found at Phoronix, thanks to Michael:
https://www.phoronix.com/news/AMD-INVLPGB-Linux-Benefits
My current plan is to implement support for Intel's RAR (Remote Action Request) TLB flushing in a follow-up series, after this thing has been merged into -tip. Making things any larger would just be unwieldy for reviewers.
v8:
- round start & end to handle non-page-aligned callers (Steven & Jan)
- fix up changelog & add tested-by tags (Manali)
v7:
- a few small code cleanups (Nadav)
- fix spurious VM_WARN_ON_ONCE in mm_global_asid
- code simplifications & better barriers (Peter & Dave)
v6:
- fix info->end check in flush_tlb_kernel_range (Michael)
- disable broadcast TLB flushing on 32 bit x86
v5:
- use byte assembly for compatibility with older toolchains (Borislav, Michael)
- ensure a panic on an invalid number of extra pages (Dave, Tom)
- add cant_migrate() assertion to tlbsync (Jann)
- a bunch more cleanups (Nadav)
- key TCE enabling off X86_FEATURE_TCE (Andrew)
- fix a race between reclaim and ASID transition (Jann)
v4:
- Use only bitmaps to track free global ASIDs (Nadav)
- Improved AMD initialization (Borislav & Tom)
- Various naming and documentation improvements (Peter, Nadav, Tom, Dave)
- Fixes for subtle race conditions (Jann)
v3:
- Remove paravirt tlb_remove_table call (thank you Qi Zheng)
- More suggested cleanups and changelog fixes by Peter and Nadav
v2:
- Apply suggestions by Peter and Borislav (thank you!)
- Fix bug in arch_tlbbatch_flush, where we need to do both
the TLBSYNC, and flush the CPUs that are in the cpumask.
- Some updates to comments and changelogs based on questions.
PATCH v8 1/12 x86/mm: make MMU_GATHER_RCU_TABLE_FREE unconditional
Currently x86 uses CONFIG_MMU_GATHER_TABLE_FREE when using paravirt, and not when running on bare metal.
There is no real good reason to do things differently for each setup. Make them all the same.
Currently get_user_pages_fast synchronizes against page table freeing in two different ways:
- on bare metal, by blocking IRQs, which block TLB flush IPIs
- on paravirt, with MMU_GATHER_RCU_TABLE_FREE
This is done because some paravirt TLB flush implementations handle the TLB flush in the hypervisor, and will do the flush even when the target CPU has interrupts disabled.
Always handle page table freeing with MMU_GATHER_RCU_TABLE_FREE. Using RCU synchronization between page table freeing and get_user_pages_fast() allows bare metal to also do TLB flushing while interrupts are disabled.
Various places in the mm do still block IRQs or disable preemption as an implicit way to block RCU frees.
That makes it safe to use INVLPGB on AMD CPUs.
--- arch/x86/Kconfig | 2 +- arch/x86/kernel/paravirt.c | 7 +------ arch/x86/mm/pgtable.c | 16 ++++------------ 3 files changed, 6 insertions(+), 19 deletions(-)
arch/x86/Kconfig +1 -1
@@ -274,7 +274,7 @@ config X86 select HAVE_PCI select HAVE_PERF_REGS select HAVE_PERF_USER_STACK_DUMP - select MMU_GATHER_RCU_TABLE_FREE if PARAVIRT + select MMU_GATHER_RCU_TABLE_FREE select MMU_GATHER_MERGE_VMAS select HAVE_POSIX_CPU_TIMERS_TASK_WORK select HAVE_REGS_AND_STACK_ACCESS_API
arch/x86/kernel/paravirt.c +1 -6
@@ -59,11 +59,6 @@ void __init native_pv_lock_init(void)static_branch_enable (&virt_spin_lock_key); } -static void native_tlb_remove_table (struct mmu_gather *tlb,void *table) -{ -tlb_remove_page (tlb, table); -} -struct static_key paravirt_steal_enabled;struct static_key paravirt_steal_rq_enabled;
@@ -191,7 +186,7 @@ struct paravirt_patch_template pv_ops = { .mmu.flush_tlb_kernel = native_flush_tlb_global, .mmu.flush_tlb_one_user = native_flush_tlb_one_user, .mmu.flush_tlb_multi = native_flush_tlb_multi, - .mmu.tlb_remove_table = native_tlb_remove_table, + .mmu.tlb_remove_table = tlb_remove_table, .mmu.exit_mmap = paravirt_nop, .mmu.notify_page_enc_status_changed = paravirt_nop,
arch/x86/mm/pgtable.c +4 -12
@@ -18,14 +18,6 @@ EXPORT_SYMBOL(physical_mask);#define PGTABLE_HIGHMEM 0#endif -#ifndef CONFIG_PARAVIRT -static inline -void paravirt_tlb_remove_table (struct mmu_gather *tlb,void *table) -{ -tlb_remove_page (tlb, table); -} -#endif -gfp_t __userpte_alloc_gfp =GFP_PGTABLE_USER |PGTABLE_HIGHMEM ;pgtable_t pte_alloc_one (struct mm_struct *mm)
@@ -54,7 +46,7 @@ void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte) {pagetable_pte_dtor (page_ptdesc (pte));paravirt_release_pte (page_to_pfn (pte)); -paravirt_tlb_remove_table (tlb, pte); +tlb_remove_table (tlb, pte); }#if CONFIG_PGTABLE_LEVELS >2
@@ -70,7 +62,7 @@ void ___pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd) tlb->need_flush_all =1 ;#endif pagetable_pmd_dtor (ptdesc); -paravirt_tlb_remove_table (tlb,ptdesc_page (ptdesc)); +tlb_remove_table (tlb,ptdesc_page (ptdesc)); }#if CONFIG_PGTABLE_LEVELS >3
@@ -80,14 +72,14 @@ void ___pud_free_tlb(struct mmu_gather *tlb, pud_t *pud)pagetable_pud_dtor (ptdesc);paravirt_release_pud (__pa (pud) >>PAGE_SHIFT ); -paravirt_tlb_remove_table (tlb,virt_to_page (pud)); +tlb_remove_table (tlb,virt_to_page (pud)); }#if CONFIG_PGTABLE_LEVELS >4 void ___p4d_free_tlb (struct mmu_gather *tlb,p4d_t *p4d) {paravirt_release_p4d (__pa (p4d) >>PAGE_SHIFT ); -paravirt_tlb_remove_table (tlb,virt_to_page (p4d)); +tlb_remove_table (tlb,virt_to_page (p4d)); }#endif /* CONFIG_PGTABLE_LEVELS > 4 */ #endif /* CONFIG_PGTABLE_LEVELS > 3 */
Signature · 1 line
2.47.1
PATCH v8 2/12 x86/mm: remove pv_ops.mmu.tlb_remove_table call
In reply to Rik van RielEvery pv_ops.mmu.tlb_remove_table call ends up calling tlb_remove_table.
Get rid of the indirection by simply calling tlb_remove_table directly, and not going through the paravirt function pointers.
--- arch/x86/hyperv/mmu.c | 1 - arch/x86/include/asm/paravirt.h | 5 ----- arch/x86/include/asm/paravirt_types.h | 2 -- arch/x86/kernel/kvm.c | 1 - arch/x86/kernel/paravirt.c | 1 - arch/x86/xen/mmu_pv.c | 1 - 6 files changed, 11 deletions(-)
arch/x86/hyperv/mmu.c +0 -1
@@ -240,5 +240,4 @@ void hyperv_setup_mmu_ops(void)pr_info ("Using hypercall for remote TLB flush\n" ); pv_ops.mmu.flush_tlb_multi = hyperv_flush_tlb_multi; - pv_ops.mmu.tlb_remove_table = tlb_remove_table; }
arch/x86/include/asm/paravirt.h +0 -5
@@ -91,11 +91,6 @@ static inline void __flush_tlb_multi(const struct cpumask *cpumask,PVOP_VCALL2 (mmu.flush_tlb_multi, cpumask, info); } -static inline void paravirt_tlb_remove_table (struct mmu_gather *tlb,void *table) -{ -PVOP_VCALL2 (mmu.tlb_remove_table, tlb, table); -} -static inline void paravirt_arch_exit_mmap (struct mm_struct *mm) {PVOP_VCALL1 (mmu.exit_mmap, mm);
arch/x86/include/asm/paravirt_types.h +0 -2
@@ -136,8 +136,6 @@ struct pv_mmu_ops {void (*flush_tlb_multi)(const struct cpumask *cpus,const struct flush_tlb_info *info); -void (*tlb_remove_table)(struct mmu_gather *tlb,void *table); -/* Hook for intercepting the destruction of an mm_struct. */ void (*exit_mmap)(struct mm_struct *mm);void (*notify_page_enc_status_changed)(unsigned long pfn,int npages,bool enc);
arch/x86/kernel/kvm.c +0 -1
@@ -838,7 +838,6 @@ static void __init kvm_guest_init(void)#ifdef CONFIG_SMP if (pv_tlb_flush_supported ()) { pv_ops.mmu.flush_tlb_multi = kvm_flush_tlb_multi; - pv_ops.mmu.tlb_remove_table = tlb_remove_table;pr_info ("KVM setup pv remote TLB flush\n" ); }
arch/x86/kernel/paravirt.c +0 -1
@@ -186,7 +186,6 @@ struct paravirt_patch_template pv_ops = { .mmu.flush_tlb_kernel = native_flush_tlb_global, .mmu.flush_tlb_one_user = native_flush_tlb_one_user, .mmu.flush_tlb_multi = native_flush_tlb_multi, - .mmu.tlb_remove_table = tlb_remove_table, .mmu.exit_mmap = paravirt_nop, .mmu.notify_page_enc_status_changed = paravirt_nop,
arch/x86/xen/mmu_pv.c +0 -1
@@ -2137,7 +2137,6 @@ static const typeof(pv_ops) xen_mmu_ops __initconst = { .flush_tlb_kernel = xen_flush_tlb, .flush_tlb_one_user = xen_flush_tlb_one_user, .flush_tlb_multi = xen_flush_tlb_multi, - .tlb_remove_table = tlb_remove_table, .pgd_alloc = xen_pgd_alloc, .pgd_free = xen_pgd_free,
Signature · 1 line
2.47.1
PATCH v8 3/12 x86/mm: consolidate full flush threshold decision
In reply to Rik van RielReduce code duplication by consolidating the decision point for whether to do individual invalidations or a full flush inside get_flush_tlb_info.
--- arch/x86/mm/tlb.c | 52 ++++++++++++++++++++++++----------------------- 1 file changed, 27 insertions(+), 25 deletions(-)
arch/x86/mm/tlb.c +27 -25
@@ -1000,8 +1000,13 @@ static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm,BUG_ON (this_cpu_inc_return (flush_tlb_info_idx) !=1 );#endif - info->start = start; - info->end = end; +/* +* Round the start and end addresses to the page size specified +* by the stride shift. This ensures partial pages at the end of +* a range get fully invalidated. +*/ + info->start =round_down (start,1 << stride_shift); + info->end =round_up (end,1 << stride_shift); info->mm = mm; info->stride_shift = stride_shift; info->freed_tables = freed_tables;
@@ -1009,6 +1014,15 @@ static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm, info->initiating_cpu =smp_processor_id (); info->trim_cpumask =0 ; +/* +* If the number of flushes is so large that a full flush +* would be faster, do a full flush. +*/ +if ((end - start) >> stride_shift > tlb_single_page_flush_ceiling) { + info->start =0 ; + info->end =TLB_FLUSH_ALL ; + } +return info; }
@@ -1026,17 +1040,8 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, bool freed_tables) {struct flush_tlb_info *info; +int cpu =get_cpu ();u64 new_tlb_gen; -int cpu; - - cpu =get_cpu (); - -/* Should we flush just the requested range? */ -if ((end ==TLB_FLUSH_ALL ) || - ((end - start) >> stride_shift) > tlb_single_page_flush_ceiling) { - start =0 ; - end =TLB_FLUSH_ALL ; - }/* This is also a barrier that synchronizes with switch_mm(). */ new_tlb_gen =inc_mm_tlb_gen (mm);
@@ -1089,22 +1094,19 @@ static void do_kernel_range_flush(void *info)void flush_tlb_kernel_range (unsigned long start,unsigned long end) { -/* Balance as user space task's flush, a bit conservative */ -if (end ==TLB_FLUSH_ALL || - (end - start) > tlb_single_page_flush_ceiling <<PAGE_SHIFT ) { -on_each_cpu (do_flush_tlb_all,NULL ,1 ); - }else { -struct flush_tlb_info *info; +struct flush_tlb_info *info; -preempt_disable (); - info =get_flush_tlb_info (NULL , start, end,0 , false, -TLB_GENERATION_INVALID ); +guard (preempt)(); + + info =get_flush_tlb_info (NULL , start, end,PAGE_SHIFT , false, +TLB_GENERATION_INVALID ); +if (info->end ==TLB_FLUSH_ALL ) +on_each_cpu (do_flush_tlb_all,NULL ,1 ); +else on_each_cpu (do_kernel_range_flush, info,1 ); -put_flush_tlb_info (); -preempt_enable (); - } +put_flush_tlb_info (); }/*
@@ -1276,7 +1278,7 @@ void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch)int cpu =get_cpu (); - info =get_flush_tlb_info (NULL ,0 ,TLB_FLUSH_ALL ,0 , false, + info =get_flush_tlb_info (NULL ,0 ,TLB_FLUSH_ALL ,PAGE_SHIFT , false,TLB_GENERATION_INVALID );/* * flush_tlb_multi() is not optimized for the common case in which only
Signature · 1 line
2.47.1
Peter Zijlstra
maintainerRe: [PATCH v8 03/12] x86/mm: consolidate full flush threshold decision
Quoted 10 lines · Rik van Riel
arch/x86/mm/tlb.c +0
-2@@ -1000,8 +1000,13 @@ static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm,BUG_ON (this_cpu_inc_return (flush_tlb_info_idx) !=1 );#endif - info->start = start; - info->end = end;
arch/x86/mm/tlb.c static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm, · line 1012
Quoted 10 lines
arch/x86/mm/tlb.c +7
-0+/* +* Round the start and end addresses to the page size specified +* by the stride shift. This ensures partial pages at the end of +* a range get fully invalidated. +*/ + info->start =round_down (start,1 << stride_shift); + info->end =round_up (end,1 << stride_shift); info->mm = mm; info->stride_shift = stride_shift; info->freed_tables = freed_tables;
Rather than doing this; should we not fix whatever dodgy users are feeding us non-page-aligned addresses for invalidation?
Re: [PATCH v8 03/12] x86/mm: consolidate full flush threshold decision
Quoted 22 lines · Peter Zijlstra
Quoted 20 lines · Rik van Riel
arch/x86/mm/tlb.c +0
-0@@ -1000,8 +1000,13 @@ static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm, BUG_ON(this_cpu_inc_return(flush_tlb_info_idx) != 1); #endifarch/x86/mm/tlb.c +2
-2- info->start = start; - info->end = end; +/* +* Round the start and end addresses to the page size specified
arch/x86/mm/tlb.c +1
-0+* by the stride shift. This ensures partial pages at the end of
arch/x86/mm/tlb.c +3
-0+* a range get fully invalidated. +*/ + info->start = round_down(start, 1 <<
stride_shift);
Quoted 9 lines
Quoted 5 lines
arch/x86/mm/tlb.c +1
-0+ info->end = round_up(end, 1 <<
stride_shift);
info->mm= mm;
info->stride_shift=stride_shift;
info->freed_tables=freed_tables;Rather than doing this; should we not fix whatever dodgy users are feeding us non-page-aligned addresses for invalidation?
The best way to do that would probably be by adding a WARN_ON_ONCE here if the value of either start or end changed, not by merging code that will trigger kernel crashes - even if the bug is elsewhere.
I would be happy to add a WARN_ON_ONCE either in a next version, or in a follow-up patch, whichever is more convenient for you.
Signature · 1 line
All Rights Reversed.
Peter Zijlstra
maintainerRe: [PATCH v8 03/12] x86/mm: consolidate full flush threshold decision
In reply to Peter ZijlstraQuoted 10 lines · Peter Zijlstra
Quoted 8 lines · Rik van Riel
arch/x86/mm/tlb.c +0
-0@@ -1000,8 +1000,13 @@ static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm,BUG_ON (this_cpu_inc_return (flush_tlb_info_idx) !=1 );#endif
Quoted 15 lines
arch/x86/mm/tlb.c static struct flush_tlb_info *get_flush_tlb_info(struct mm_struct *mm, · line 1012
Quoted 12 lines
arch/x86/mm/tlb.c +7
-2- info->start = start; - info->end = end; +/* +* Round the start and end addresses to the page size specified +* by the stride shift. This ensures partial pages at the end of +* a range get fully invalidated. +*/ + info->start =round_down (start,1 << stride_shift); + info->end =round_up (end,1 << stride_shift); info->mm = mm; info->stride_shift = stride_shift; info->freed_tables = freed_tables;Rather than doing this; should we not fix whatever dodgy users are feeding us non-page-aligned addresses for invalidation?
That is, I feel this is worthy of WARN_ONCE at the very least.
PATCH v8 4/12 x86/mm: get INVLPGB count max from CPUID
In reply to Rik van RielThe CPU advertises the maximum number of pages that can be shot down with one INVLPGB instruction in the CPUID data.
Save that information for later use.
--- arch/x86/Kconfig.cpu | 5 +++++ arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/tlbflush.h | 7 +++++++ arch/x86/kernel/cpu/amd.c | 8 ++++++++ 4 files changed, 21 insertions(+)
arch/x86/Kconfig.cpu +5 -0
@@ -395,6 +395,10 @@ config X86_VMX_FEATURE_NAMES def_bool y depends on IA32_FEAT_CTL +config X86_BROADCAST_TLB_FLUSH + def_bool y + depends on CPU_SUP_AMD && 64BIT + menuconfig PROCESSOR_SELECT bool "Supported processor vendors" if EXPERT help
@@ -431,6 +435,7 @@ config CPU_SUP_CYRIX_32 config CPU_SUP_AMD default y bool "Support AMD processors" if PROCESSOR_SELECT + select X86_BROADCAST_TLB_FLUSH help This enables detection, tunings and quirks for AMD processors
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -338,6 +338,7 @@#define X86_FEATURE_CLZERO (13*32+ 0)/* "clzero" CLZERO instruction */ #define X86_FEATURE_IRPERF (13*32+ 1)/* "irperf" Instructions Retired Count */ #define X86_FEATURE_XSAVEERPTR (13*32+ 2)/* "xsaveerptr" Always save/restore FP error pointers */ +#define X86_FEATURE_INVLPGB (13*32+ 3)/* INVLPGB and TLBSYNC instruction supported. */ #define X86_FEATURE_RDPRU (13*32+ 4)/* "rdpru" Read processor register at user level */ #define X86_FEATURE_WBNOINVD (13*32+ 9)/* "wbnoinvd" WBNOINVD instruction */ #define X86_FEATURE_AMD_IBPB (13*32+12)/* Indirect Branch Prediction Barrier */
arch/x86/include/asm/tlbflush.h +7 -0
@@ -183,6 +183,13 @@ static inline void cr4_init_shadow(void)extern unsigned long mmu_cr4_features;extern u32 *trampoline_cr4_features; +/* How many pages can we invalidate with one INVLPGB. */ +#ifdef CONFIG_X86_BROADCAST_TLB_FLUSH +extern u16 invlpgb_count_max; +#else +#define invlpgb_count_max 1 +#endif +extern void initialize_tlbstate_and_flush (void );/*
arch/x86/kernel/cpu/amd.c +8 -0
@@ -29,6 +29,8 @@#include "cpu.h" +u16 invlpgb_count_max__ro_after_init ; +static inline int rdmsrl_amd_safe (unsigned msr,unsigned long long *p) {u32 gprs[8 ] = {0 };
@@ -1135,6 +1137,12 @@ static void cpu_detect_tlb_amd(struct cpuinfo_x86 *c) tlb_lli_2m[ENTRIES ] = eax & mask; tlb_lli_4m[ENTRIES ] = tlb_lli_2m[ENTRIES ] >>1 ; + +/* Max number of pages INVLPGB can invalidate in one shot */ +if (boot_cpu_has (X86_FEATURE_INVLPGB )) { +cpuid (0x80000008 , &eax, &ebx, &ecx, &edx); + invlpgb_count_max = (edx &0xffff ) +1 ; + } }static const struct cpu_dev amd_cpu_dev = {
Signature · 1 line
2.47.1
PATCH v8 5/12 x86/mm: add INVLPGB support code
In reply to Rik van RielAdd invlpgb.h with the helper functions and definitions needed to use broadcast TLB invalidation on AMD EPYC 3 and newer CPUs.
--- arch/x86/include/asm/invlpgb.h | 101 ++++++++++++++++++++++++++++++++ arch/x86/include/asm/tlbflush.h | 1 + 2 files changed, 102 insertions(+) create mode 100644 arch/x86/include/asm/invlpgb.h
arch/x86/include/asm/invlpgb.h new file +101 -0
@@ -0,0 +1,101 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_INVLPGB +#define _ASM_X86_INVLPGB + +#include <linux/kernel.h> +#include <vdso/bits.h> +#include <vdso/page.h> + +/* +* INVLPGB does broadcast TLB invalidation across all the CPUs in the system. +* +* The INVLPGB instruction is weakly ordered, and a batch of invalidations can +* be done in a parallel fashion. +* +* TLBSYNC is used to ensure that pending INVLPGB invalidations initiated from +* this CPU have completed. +*/ +static inline void __invlpgb (unsigned long asid,unsigned long pcid, +unsigned long addr,u16 extra_count, +bool pmd_stride,u8 flags) +{ +u32 edx = (pcid <<16 ) | asid; +u32 ecx = (pmd_stride <<31 ) | extra_count; +u64 rax = addr | flags; + +/* The low bits in rax are for flags. Verify addr is clean. */ +VM_WARN_ON_ONCE (addr & ~PAGE_MASK ); + +/* INVLPGB; supported in binutils >= 2.36. */ + asmvolatile (".byte 0x0f, 0x01, 0xfe" : :"a" (rax),"c" (ecx),"d" (edx)); +} + +/* Wait for INVLPGB originated by this CPU to complete. */ +static inline void tlbsync (void ) +{ +cant_migrate (); +/* TLBSYNC: supported in binutils >= 0.36. */ + asmvolatile (".byte 0x0f, 0x01, 0xff" :::"memory" ); +} + +/* +* INVLPGB can be targeted by virtual address, PCID, ASID, or any combination +* of the three. For example: +* - INVLPGB_VA | INVLPGB_INCLUDE_GLOBAL: invalidate all TLB entries at the address +* - INVLPGB_PCID: invalidate all TLB entries matching the PCID +* +* The first can be used to invalidate (kernel) mappings at a particular +* address across all processes. +* +* The latter invalidates all TLB entries matching a PCID. +*/ +#define INVLPGB_VA BIT(0) +#define INVLPGB_PCID BIT(1) +#define INVLPGB_ASID BIT(2) +#define INVLPGB_INCLUDE_GLOBAL BIT(3) +#define INVLPGB_FINAL_ONLY BIT(4) +#define INVLPGB_INCLUDE_NESTED BIT(5) + +/* Flush all mappings for a given pcid and addr, not including globals. */ +static inline void invlpgb_flush_user (unsigned long pcid, +unsigned long addr) +{ +__invlpgb (0 , pcid, addr,0 ,0 ,INVLPGB_PCID |INVLPGB_VA ); +tlbsync (); +} + +static inline void invlpgb_flush_user_nr_nosync (unsigned long pcid, +unsigned long addr, +u16 nr, +bool pmd_stride) +{ +__invlpgb (0 , pcid, addr, nr -1 , pmd_stride,INVLPGB_PCID |INVLPGB_VA ); +} + +/* Flush all mappings for a given PCID, not including globals. */ +static inline void invlpgb_flush_single_pcid_nosync (unsigned long pcid) +{ +__invlpgb (0 , pcid,0 ,0 ,0 ,INVLPGB_PCID ); +} + +/* Flush all mappings, including globals, for all PCIDs. */ +static inline void invlpgb_flush_all (void ) +{ +__invlpgb (0 ,0 ,0 ,0 ,0 ,INVLPGB_INCLUDE_GLOBAL ); +tlbsync (); +} + +/* Flush addr, including globals, for all PCIDs. */ +static inline void invlpgb_flush_addr_nosync (unsigned long addr,u16 nr) +{ +__invlpgb (0 ,0 , addr, nr -1 ,0 ,INVLPGB_INCLUDE_GLOBAL ); +} + +/* Flush all mappings for all PCIDs except globals. */ +static inline void invlpgb_flush_all_nonglobals (void ) +{ +__invlpgb (0 ,0 ,0 ,0 ,0 ,0 ); +tlbsync (); +} + +#endif /* _ASM_X86_INVLPGB */
arch/x86/include/asm/tlbflush.h +1 -0
@@ -10,6 +10,7 @@#include <asm/cpufeature.h> #include <asm/special_insns.h> #include <asm/smp.h> +#include <asm/invlpgb.h> #include <asm/invpcid.h> #include <asm/pti.h> #include <asm/processor-flags.h>
Signature · 1 line
2.47.1
PATCH v8 6/12 x86/mm: use INVLPGB for kernel TLB flushes
In reply to Rik van RielUse broadcast TLB invalidation for kernel addresses when available.
Remove the need to send IPIs for kernel TLB flushes.
--- arch/x86/mm/tlb.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)
arch/x86/mm/tlb.c +27 -1
@@ -1082,6 +1082,30 @@ void flush_tlb_all(void)on_each_cpu (do_flush_tlb_all,NULL ,1 ); } +static bool broadcast_kernel_range_flush (struct flush_tlb_info *info) +{ +unsigned long addr; +unsigned long nr; + +if (!IS_ENABLED (CONFIG_X86_BROADCAST_TLB_FLUSH )) +return false; + +if (!cpu_feature_enabled (X86_FEATURE_INVLPGB )) +return false; + +if (info->end ==TLB_FLUSH_ALL ) { +invlpgb_flush_all (); +return true; + } + +for (addr = info->start; addr < info->end; addr += nr <<PAGE_SHIFT ) { + nr =min ((info->end - addr) >>PAGE_SHIFT , invlpgb_count_max); +invlpgb_flush_addr_nosync (addr, nr); + } +tlbsync (); +return true; +} +static void do_kernel_range_flush (void *info) {struct flush_tlb_info *f = info;
@@ -1101,7 +1125,9 @@ void flush_tlb_kernel_range(unsigned long start, unsigned long end) info =get_flush_tlb_info (NULL , start, end,PAGE_SHIFT , false,TLB_GENERATION_INVALID ); -if (info->end ==TLB_FLUSH_ALL ) +if (broadcast_kernel_range_flush (info)) + ;/* Fall through. */ +else if (info->end ==TLB_FLUSH_ALL )on_each_cpu (do_flush_tlb_all,NULL ,1 );else on_each_cpu (do_kernel_range_flush, info,1 );
Signature · 1 line
2.47.1
PATCH v8 7/12 x86/mm: use INVLPGB in flush_tlb_all
In reply to Rik van RielThe flush_tlb_all() function is not used a whole lot, but we might as well use broadcast TLB flushing there, too.
--- arch/x86/mm/tlb.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
arch/x86/mm/tlb.c +15 -0
@@ -1070,6 +1070,19 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, } +static bool broadcast_flush_tlb_all (void ) +{ +if (!IS_ENABLED (CONFIG_X86_BROADCAST_TLB_FLUSH )) +return false; + +if (!cpu_feature_enabled (X86_FEATURE_INVLPGB )) +return false; + +guard (preempt)(); +invlpgb_flush_all (); +return true; +} +static void do_flush_tlb_all (void *info) {count_vm_tlb_event (NR_TLB_REMOTE_FLUSH_RECEIVED );
@@ -1078,6 +1091,8 @@ static void do_flush_tlb_all(void *info)void flush_tlb_all (void ) { +if (broadcast_flush_tlb_all ()) +return ;count_vm_tlb_event (NR_TLB_REMOTE_FLUSH );on_each_cpu (do_flush_tlb_all,NULL ,1 ); }
Signature · 1 line
2.47.1
PATCH v8 8/12 x86/mm: use broadcast TLB flushing for page reclaim TLB flushing
In reply to Rik van RielIn the page reclaim code, we only track the CPU(s) where the TLB needs to be flushed, rather than all the individual mappings that may be getting invalidated.
Use broadcast TLB flushing when that is available.
--- arch/x86/mm/tlb.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/x86/mm/tlb.c +3 -1
@@ -1326,7 +1326,9 @@ void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch)* a local TLB flush is needed. Optimize this use-case by calling * flush_tlb_func_local() directly in this case. */ -if (cpumask_any_but (&batch->cpumask, cpu) < nr_cpu_ids) { +if (cpu_feature_enabled (X86_FEATURE_INVLPGB )) { +invlpgb_flush_all_nonglobals (); + }else if (cpumask_any_but (&batch->cpumask, cpu) < nr_cpu_ids) {flush_tlb_multi (&batch->cpumask, info); }else if (cpumask_test_cpu (cpu, &batch->cpumask)) {lockdep_assert_irqs_enabled ();
Signature · 1 line
2.47.1
PATCH v8 9/12 x86/mm: enable broadcast TLB invalidation for multi-threaded processes
In reply to Rik van RielUse broadcast TLB invalidation, using the INVPLGB instruction, on AMD EPYC 3 and newer CPUs.
In order to not exhaust PCID space, and keep TLB flushes local for single threaded processes, we only hand out broadcast ASIDs to processes active on 4 or more CPUs.
--- arch/x86/include/asm/mmu.h | 6 + arch/x86/include/asm/mmu_context.h | 14 ++ arch/x86/include/asm/tlbflush.h | 73 ++++++ arch/x86/mm/tlb.c | 344 ++++++++++++++++++++++++++++- 4 files changed, 425 insertions(+), 12 deletions(-)
arch/x86/include/asm/mmu.h +6 -0
@@ -69,6 +69,12 @@ typedef struct {u16 pkey_allocation_map;s16 execute_only_pkey;#endif + +#ifdef CONFIG_X86_BROADCAST_TLB_FLUSH +u16 global_asid; +bool asid_transition; +#endif + } mm_context_t;#define INIT_MM_CONTEXT (mm) \
arch/x86/include/asm/mmu_context.h +14 -0
@@ -139,6 +139,8 @@ static inline void mm_reset_untag_mask(struct mm_struct *mm)#define enter_lazy_tlb enter_lazy_tlbextern void enter_lazy_tlb (struct mm_struct *mm,struct task_struct *tsk); +extern void destroy_context_free_global_asid (struct mm_struct *mm); +/* * Init a new mm. Used on mm copies, like at fork() * and on mm's that are brand-new, like at execve().
@@ -161,6 +163,14 @@ static inline int init_new_context(struct task_struct *tsk, mm->context.execute_only_pkey = -1; }#endif + +#ifdef CONFIG_X86_BROADCAST_TLB_FLUSH +if (cpu_feature_enabled (X86_FEATURE_INVLPGB )) { + mm->context.global_asid =0 ; + mm->context.asid_transition = false; + } +#endif +mm_reset_untag_mask (mm);init_new_context_ldt (mm);return 0 ;
@@ -170,6 +180,10 @@ static inline int init_new_context(struct task_struct *tsk,static inline void destroy_context (struct mm_struct *mm) {destroy_context_ldt (mm); +#ifdef CONFIG_X86_BROADCAST_TLB_FLUSH +if (cpu_feature_enabled (X86_FEATURE_INVLPGB )) +destroy_context_free_global_asid (mm); +#endif } extern void switch_mm(struct mm_struct *prev, struct mm_struct *next,
arch/x86/include/asm/tlbflush.h +73 -0
85 lines not on this page · raw message
arch/x86/mm/tlb.c +332 -12
426 lines not on this page · raw message
Signature · 1 line
2.47.1
PATCH v8 10/12 x86/mm: do targeted broadcast flushing from tlbbatch code
In reply to Rik van RielInstead of doing a system-wide TLB flush from arch_tlbbatch_flush, queue up asynchronous, targeted flushes from arch_tlbbatch_add_pending.
This also allows us to avoid adding the CPUs of processes using broadcast flushing to the batch->cpumask, and will hopefully further reduce TLB flushing from the reclaim and compaction paths.
--- arch/x86/include/asm/tlbbatch.h | 1 + arch/x86/include/asm/tlbflush.h | 12 ++----- arch/x86/mm/tlb.c | 57 +++++++++++++++++++++++++++++++-- 3 files changed, 58 insertions(+), 12 deletions(-)
arch/x86/include/asm/tlbbatch.h +1 -0
@@ -10,6 +10,7 @@ struct arch_tlbflush_unmap_batch {* the PFNs being flushed.. */ struct cpumask cpumask; + bool used_invlpgb; };#endif /* _ARCH_X86_TLBBATCH_H */
arch/x86/include/asm/tlbflush.h +3 -9
@@ -359,21 +359,15 @@ static inline u64 inc_mm_tlb_gen(struct mm_struct *mm)return atomic64_inc_return (&mm->context.tlb_gen); } -static inline void arch_tlbbatch_add_pending (struct arch_tlbflush_unmap_batch *batch, -struct mm_struct *mm, -unsigned long uaddr) -{ -inc_mm_tlb_gen (mm); -cpumask_or (&batch->cpumask, &batch->cpumask,mm_cpumask (mm)); -mmu_notifier_arch_invalidate_secondary_tlbs (mm,0 ,-1UL ); -} -static inline void arch_flush_tlb_batched_pending (struct mm_struct *mm) {flush_tlb_mm (mm); }extern void arch_tlbbatch_flush (struct arch_tlbflush_unmap_batch *batch); +extern void arch_tlbbatch_add_pending (struct arch_tlbflush_unmap_batch *batch, +struct mm_struct *mm, +unsigned long uaddr); static inline bool pte_flags_need_flush(unsigned long oldflags, unsigned long newflags,
arch/x86/mm/tlb.c +54 -3
75 lines not on this page · raw message
Signature · 1 line
2.47.1
Peter Zijlstra
maintainerRe: [PATCH v8 10/12] x86/mm: do targeted broadcast flushing from tlbbatch code
Quoted 27 lines · Rik van Riel
(quoted diff) +17
-0@@ -1657,12 +1655,65 @@ void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch) local_irq_enable(); } + /* + * If we issued (asynchronous) INVLPGB flushes, wait for them here. + * The cpumask above contains only CPUs that were running tasks + * not using broadcast TLB flushing. + */ + if (cpu_feature_enabled(X86_FEATURE_INVLPGB) && batch->used_invlpgb) { + tlbsync(); + migrate_enable(); + batch->used_invlpgb = false; + } + cpumask_clear(&batch->cpumask); put_flush_tlb_info(); put_cpu(); } +void arch_tlbbatch_add_pending(struct arch_tlbflush_unmap_batch *batch, + struct mm_struct *mm, + unsigned long uaddr) +{ + u16 asid = mm_global_asid(mm); +
Review void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch) · line 1690
Quoted 10 lines
(quoted diff) +10
-0+ if (asid) { + /* + * Queue up an asynchronous invalidation. The corresponding + * TLBSYNC is done in arch_tlbbatch_flush(), and must be done + * on the same CPU. + */ + if (!batch->used_invlpgb) { + batch->used_invlpgb = true; + migrate_disable(); + }
How about we do something like this instead?
This keeps all the TLBSYNC in the same task as the INVLPGB, without making things complicated and allowing random CR3 writes in between them -- which makes my head hurt.
---
arch/x86/include/asm/tlbbatch.h +0 -1
@@ -10,7 +10,6 @@ struct arch_tlbflush_unmap_batch {* the PFNs being flushed.. */ struct cpumask cpumask; - bool used_invlpgb; };#endif /* _ARCH_X86_TLBBATCH_H */
arch/x86/include/asm/tlbflush.h +1 -0
@@ -106,6 +106,7 @@ struct tlb_state {* need to be invalidated. */ bool invalidate_other; +bool need_tlbsync;#ifdef CONFIG_ADDRESS_MASKING /*
arch/x86/mm/tlb.c +36 -8
75 lines not on this page · raw message
arch/x86/include/asm/invlpgb.h +11 -11
@@ -3,6 +3,7 @@#define _ASM_X86_INVLPGB#include <linux/kernel.h> +#include <asm/page_types.h> #include <vdso/bits.h> #include <vdso/page.h>
@@ -31,9 +32,8 @@ static inline void __invlpgb(unsigned lo }/* Wait for INVLPGB originated by this CPU to complete. */ -static inline void tlbsync (void ) +static inline void __tlbsync (void ) { -cant_migrate ();/* TLBSYNC: supported in binutils >= 0.36. */ asmvolatile (".byte 0x0f, 0x01, 0xff" :::"memory" ); }
@@ -61,19 +61,19 @@ static inline void invlpgb_flush_user(un unsigned long addr) {__invlpgb (0 , pcid, addr,0 ,0 ,INVLPGB_PCID |INVLPGB_VA ); -tlbsync (); +__tlbsync (); } -static inline void invlpgb_flush_user_nr_nosync (unsigned long pcid, -unsigned long addr, -u16 nr, -bool pmd_stride) +static inline void __invlpgb_flush_user_nr (unsigned long pcid, +unsigned long addr, +u16 nr, +bool pmd_stride) {__invlpgb (0 , pcid, addr, nr -1 , pmd_stride,INVLPGB_PCID |INVLPGB_VA ); }/* Flush all mappings for a given PCID, not including globals. */ -static inline void invlpgb_flush_single_pcid_nosync (unsigned long pcid) +static inline void __invlpgb_flush_single_pcid (unsigned long pcid) {__invlpgb (0 , pcid,0 ,0 ,0 ,INVLPGB_PCID ); }
@@ -82,11 +82,11 @@ static inline void invlpgb_flush_single_static inline void invlpgb_flush_all (void ) {__invlpgb (0 ,0 ,0 ,0 ,0 ,INVLPGB_INCLUDE_GLOBAL ); -tlbsync (); +__tlbsync (); }/* Flush addr, including globals, for all PCIDs. */ -static inline void invlpgb_flush_addr_nosync (unsigned long addr,u16 nr) +static inline void __invlpgb_flush_addr (unsigned long addr,u16 nr) {__invlpgb (0 ,0 , addr, nr -1 ,0 ,INVLPGB_INCLUDE_GLOBAL ); }
@@ -95,7 +95,7 @@ static inline void invlpgb_flush_addr_nostatic inline void invlpgb_flush_all_nonglobals (void ) {__invlpgb (0 ,0 ,0 ,0 ,0 ,0 ); -tlbsync (); +__tlbsync (); }#endif /* _ASM_X86_INVLPGB */
Re: [PATCH v8 10/12] x86/mm: do targeted broadcast flushing from tlbbatch code
Quoted 6 lines · Peter Zijlstra
How about we do something like this instead?
This keeps all the TLBSYNC in the same task as the INVLPGB, without making things complicated and allowing random CR3 writes in between them -- which makes my head hurt.
I like your idea better!
Guess I should go make and test a v9 with
the WARN_ONCE in patch 3, and these changes :)
Signature · 1 line
All Rights Reversed.
PATCH v8 11/12 x86/mm: enable AMD translation cache extensions
In reply to Rik van RielWith AMD TCE (translation cache extensions) only the intermediate mappings that cover the address range zapped by INVLPG / INVLPGB get invalidated, rather than all intermediate mappings getting zapped at every TLB invalidation.
This can help reduce the TLB miss rate, by keeping more intermediate mappings in the cache.
From the AMD manual:
Translation Cache Extension (TCE) Bit. Bit 15, read/write. Setting this bit to 1 changes how the INVLPG, INVLPGB, and INVPCID instructions operate on TLB entries. When this bit is 0, these instructions remove the target PTE from the TLB as well as all upper-level table entries that are cached in the TLB, whether or not they are associated with the target PTE. When this bit is set, these instructions will remove the target PTE and only those upper-level entries that lead to the target PTE in the page table hierarchy, leaving unrelated upper-level entries intact.
--- arch/x86/include/asm/msr-index.h | 2 ++ arch/x86/kernel/cpu/amd.c | 4 ++++ tools/arch/x86/include/asm/msr-index.h | 2 ++ 3 files changed, 8 insertions(+)
arch/x86/include/asm/msr-index.h +2 -0
@@ -25,6 +25,7 @@#define _EFER_SVME 12/* Enable virtualization */ #define _EFER_LMSLE 13/* Long Mode Segment Limit Enable */ #define _EFER_FFXSR 14/* Enable Fast FXSAVE/FXRSTOR */ +#define _EFER_TCE 15/* Enable Translation Cache Extensions */ #define _EFER_AUTOIBRS 21/* Enable Automatic IBRS */ #define EFER_SCE (1<<_EFER_SCE)
@@ -34,6 +35,7 @@#define EFER_SVME (1<<_EFER_SVME)#define EFER_LMSLE (1<<_EFER_LMSLE)#define EFER_FFXSR (1<<_EFER_FFXSR) +#define EFER_TCE (1<<_EFER_TCE)#define EFER_AUTOIBRS (1<<_EFER_AUTOIBRS)/*
arch/x86/kernel/cpu/amd.c +4 -0
@@ -1071,6 +1071,10 @@ static void init_amd(struct cpuinfo_x86 *c)/* AMD CPUs don't need fencing after x2APIC/TSC_DEADLINE MSR writes. */ clear_cpu_cap (c,X86_FEATURE_APIC_MSRS_FENCE ); + +/* Enable Translation Cache Extension */ +if (cpu_feature_enabled (X86_FEATURE_TCE )) +msr_set_bit (MSR_EFER , _EFER_TCE); }#ifdef CONFIG_X86_32
tools/arch/x86/include/asm/msr-index.h +2 -0
@@ -25,6 +25,7 @@#define _EFER_SVME 12/* Enable virtualization */ #define _EFER_LMSLE 13/* Long Mode Segment Limit Enable */ #define _EFER_FFXSR 14/* Enable Fast FXSAVE/FXRSTOR */ +#define _EFER_TCE 15/* Enable Translation Cache Extensions */ #define _EFER_AUTOIBRS 21/* Enable Automatic IBRS */ #define EFER_SCE (1<<_EFER_SCE)
@@ -34,6 +35,7 @@#define EFER_SVME (1<<_EFER_SVME)#define EFER_LMSLE (1<<_EFER_LMSLE)#define EFER_FFXSR (1<<_EFER_FFXSR) +#define EFER_TCE (1<<_EFER_TCE)#define EFER_AUTOIBRS (1<<_EFER_AUTOIBRS)/*
Signature · 1 line
2.47.1
PATCH v8 12/12 x86/mm: only invalidate final translations with INVLPGB
In reply to Rik van RielUse the INVLPGB_FINAL_ONLY flag when invalidating mappings with INVPLGB. This way only leaf mappings get removed from the TLB, leaving intermediate translations cached.
On the (rare) occasions where we free page tables we do a full flush, ensuring intermediate translations get flushed from the TLB.
--- arch/x86/include/asm/invlpgb.h | 10 ++++++++-- arch/x86/mm/tlb.c | 8 ++++---- 2 files changed, 12 insertions(+), 6 deletions(-)
arch/x86/include/asm/invlpgb.h +8 -2
@@ -67,9 +67,15 @@ static inline void invlpgb_flush_user(unsigned long pcid,static inline void invlpgb_flush_user_nr_nosync (unsigned long pcid,unsigned long addr,u16 nr, -bool pmd_stride) +bool pmd_stride, +bool freed_tables) { -__invlpgb (0 , pcid, addr, nr -1 , pmd_stride,INVLPGB_PCID |INVLPGB_VA ); +unsigned long flags =INVLPGB_PCID |INVLPGB_VA ; + +if (!freed_tables) + flags |=INVLPGB_FINAL_ONLY ; + +__invlpgb (0 , pcid, addr, nr -1 , pmd_stride, flags); }/* Flush all mappings for a given PCID, not including globals. */
arch/x86/mm/tlb.c +4 -4
@@ -518,10 +518,10 @@ static void broadcast_tlb_flush(struct flush_tlb_info *info) nr =min (maxnr, (info->end - addr) >> info->stride_shift); nr =max (nr,1 ); -invlpgb_flush_user_nr_nosync (kern_pcid (asid), addr, nr, pmd); +invlpgb_flush_user_nr_nosync (kern_pcid (asid), addr, nr, pmd, info->freed_tables);/* Do any CPUs supporting INVLPGB need PTI? */ if (static_cpu_has (X86_FEATURE_PTI )) -invlpgb_flush_user_nr_nosync (user_pcid (asid), addr, nr, pmd); +invlpgb_flush_user_nr_nosync (user_pcid (asid), addr, nr, pmd, info->freed_tables); addr += nr << info->stride_shift; }while (addr < info->end);
@@ -1688,10 +1688,10 @@ void arch_tlbbatch_add_pending(struct arch_tlbflush_unmap_batch *batch, batch->used_invlpgb = true;migrate_disable (); } -invlpgb_flush_user_nr_nosync (kern_pcid (asid), uaddr,1 , false); +invlpgb_flush_user_nr_nosync (kern_pcid (asid), uaddr,1 , false, false);/* Do any CPUs supporting INVLPGB need PTI? */ if (static_cpu_has (X86_FEATURE_PTI )) -invlpgb_flush_user_nr_nosync (user_pcid (asid), uaddr,1 , false); +invlpgb_flush_user_nr_nosync (user_pcid (asid), uaddr,1 , false, false);/* * Some CPUs might still be using a local ASID for this
Signature · 1 line
2.47.1