Avoid IPI while updating page table entries.
Subsystems (7)
v3 cover Avoid IPI while updating page table entries.
Problem Summary:
Slow termination of KVM guest with large guest RAM config due to a large number of IPIs that were caused by clearing level 1 PTE entries (THP) entries. This is shown in the stack trace below.
- qemu-system-ppc [kernel.vmlinux] [k] smp_call_function_many
- smp_call_function_many
- 36.09% smp_call_function_many
serialize_against_pte_lookup
radix__pmdp_huge_get_and_clear
zap_huge_pmd
unmap_page_range
unmap_vmas
unmap_region
__do_munmap
__vm_munmap
sys_munmap
system_call
__munmap
qemu_ram_munmap
qemu_anon_ram_free
reclaim_ramblock
call_rcu_thread
qemu_thread_start
start_thread
__cloneWhy we need to do IPI when clearing PMD entries:
This was added as part of commit: 13bd817bb884 ("powerpc/thp: Serialize pmd clear against a linux page table walk")
serialize_against_pte_lookup makes sure that all parallel lockless page table walk completes before we convert a PMD pte entry to regular pmd entry. We end up doing that conversion in the below scenarios
1) __split_huge_zero_page_pmd
2) do_huge_pmd_wp_page_fallback
3) MADV_DONTNEED running parallel to page faults.
local_irq_disable and lockless page table walk:
The lockless page table walk work with the assumption that we can dereference the page table contents without holding a lock. For this to work, we need to make sure we read the page table contents atomically and page table pages are not going to be freed/released while we are walking the
table pages. We can achieve by using a rcu based freeing for page table pages or if the architecture implements broadcast tlbie, we can block the IPI as we walk the page table pages.
To support both the above framework, lockless page table walk is done with irq disabled instead of rcu_read_lock()
We do have two interface for lockless page table walk, gup fast and __find_linux_pte. This patch series makes __find_linux_pte table walk safe against the conversion of PMD PTE to regular PMD.
gup fast:
gup fast is already safe against THP split because kernel now differentiate between a pmd split and a compound page split. gup fast can run parallel to a pmd split and we prevent a parallel gup fast to a hugepage split, by freezing the page refcount and failing the speculative page ref increment.
Similar to how gup is safe against parallel pmd split, this patch series updates the __find_linux_pte callers to be safe against a parallel pmd split. We do that by enforcing the following rules.
1) Don't reload the pte value, because that can be updated in parallel.
2) Code should be able to work with a stale PTE value and not the recent one. ie, the pte value that we are looking at may not be the latest value in the page table.
3) Before looking at pte value check for _PAGE_PTE bit. We now do this as part of pte_present() check.
Performance:
This speeds up Qemu guest RAM del/unplug time as below 128 core, 496GB guest:
Without patch:
munmap start: timer = 13162 ms, PID=7684
munmap finish: timer = 95312 ms, PID=7684 - delta = 82150 ms
With patch (upto removing IPI)
munmap start: timer = 196449 ms, PID=6681
munmap finish: timer = 196488 ms, PID=6681 - delta = 39ms
With patch (with adding the tlb invalidate in pmdp_huge_get_and_clear_full) munmap start: timer = 196345 ms, PID=6879
munmap finish: timer = 196714 ms, PID=6879 - delta = 369ms
Changes from V2:
* Rebase to lastest kernel
Changes from V1:
* Update commit messages
* Qemu Performance numbers
Aneesh Kumar K.V (22):
powerpc/pkeys: Avoid using lockless page table walk powerpc/pkeys: Check vma before returning key fault error to the user powerpc/mm/hash64: use _PAGE_PTE when checking for pte_present powerpc/hash64: Restrict page table lookup using init_mm with
__flush_hash_table_range
powerpc/book3s64/hash: Use the pte_t address from the caller powerpc/mce: Don't reload pte val in addr_to_pfn powerpc/perf/callchain: Use __get_user_pages_fast in
read_user_stack_slow
powerpc/kvm/book3s: switch from raw_spin_*lock to arch_spin_lock. powerpc/kvm/book3s: Add helper to walk partition scoped linux page
table.
powerpc/kvm/nested: Add helper to walk nested shadow linux page table. powerpc/kvm/book3s: Use kvm helpers to walk shadow or secondary table powerpc/kvm/book3s: Add helper for host page table walk powerpc/kvm/book3s: Use find_kvm_host_pte in page fault handler powerpc/kvm/book3s: Use find_kvm_host_pte in h_enter powerpc/kvm/book3s: use find_kvm_host_pte in pute_tce functions powerpc/kvm/book3s: Avoid using rmap to protect parallel page table
update.
powerpc/kvm/book3s: use find_kvm_host_pte in
kvmppc_book3s_instantiate_page
powerpc/kvm/book3s: Use find_kvm_host_pte in kvmppc_get_hpa powerpc/kvm/book3s: Use pte_present instead of opencoding
_PAGE_PRESENT check
powerpc/mm/book3s64: Avoid sending IPI on clearing PMD
mm: change pmdp_huge_get_and_clear_full take vm_area_struct as arg powerpc/mm/book3s64: Fix MADV_DONTNEED and parallel page fault race
arch/powerpc/include/asm/book3s/64/pgtable.h | 20 +++-- .../include/asm/book3s/64/tlbflush-hash.h | 3 +- arch/powerpc/include/asm/kvm_book3s.h | 2 +- arch/powerpc/include/asm/kvm_book3s_64.h | 34 ++++++++- arch/powerpc/include/asm/mmu.h | 9 --- arch/powerpc/kernel/mce_power.c | 14 ++-- arch/powerpc/kernel/pci_64.c | 2 +- arch/powerpc/kvm/book3s_64_mmu_hv.c | 15 ++-- arch/powerpc/kvm/book3s_64_mmu_radix.c | 40 +++++----- arch/powerpc/kvm/book3s_64_vio_hv.c | 64 ++++++++-------- arch/powerpc/kvm/book3s_hv_nested.c | 37 ++++++--- arch/powerpc/kvm/book3s_hv_rm_mmu.c | 58 +++++--------- arch/powerpc/mm/book3s64/hash_pgtable.c | 11 --- arch/powerpc/mm/book3s64/hash_tlb.c | 16 +--- arch/powerpc/mm/book3s64/hash_utils.c | 62 ++++----------- arch/powerpc/mm/book3s64/pgtable.c | 24 ++++-- arch/powerpc/mm/book3s64/radix_pgtable.c | 19 ++--- arch/powerpc/mm/fault.c | 75 +++++++++++++------ arch/powerpc/perf/callchain_64.c | 46 ++++-------- arch/s390/include/asm/pgtable.h | 4 +- include/asm-generic/pgtable.h | 4 +- mm/huge_memory.c | 4 +- 22 files changed, 275 insertions(+), 288 deletions(-)
Signature · 1 line
2.25.3
PATCH v3 1/22 powerpc/pkeys: Avoid using lockless page table walk
Fetch pkey from vma instead of linux page table. Also document the fact that in some cases the pkey returned in siginfo won't be the same as the one we took keyfault on. Even with linux page table walk, we can end up in a similar scenario.
--- arch/powerpc/include/asm/mmu.h | 9 --- arch/powerpc/mm/book3s64/hash_utils.c | 24 -------- arch/powerpc/mm/fault.c | 83 +++++++++++++++++++-------- 3 files changed, 60 insertions(+), 56 deletions(-)
arch/powerpc/include/asm/mmu.h +0 -9
@@ -291,15 +291,6 @@ static inline bool early_radix_enabled(void) }#endif -#ifdef CONFIG_PPC_MEM_KEYS -extern u16 get_mm_addr_key (struct mm_struct *mm,unsigned long address); -#else -static inline u16 get_mm_addr_key (struct mm_struct *mm,unsigned long address) -{ -return 0 ; -} -#endif /* CONFIG_PPC_MEM_KEYS */ -#ifdef CONFIG_STRICT_KERNEL_RWX static inline bool strict_kernel_rwx_enabled (void ) {
arch/powerpc/mm/book3s64/hash_utils.c +0 -24
@@ -1671,30 +1671,6 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,hash_preload (vma->vm_mm, address, is_exec, trap); } -#ifdef CONFIG_PPC_MEM_KEYS -/* -* Return the protection key associated with the given address and the -* mm_struct. -*/ -u16 get_mm_addr_key (struct mm_struct *mm,unsigned long address) -{ -pte_t *ptep; -u16 pkey =0 ; -unsigned long flags; - -if (!mm || !mm->pgd) -return 0 ; - -local_irq_save (flags); - ptep =find_linux_pte (mm->pgd, address,NULL ,NULL ); -if (ptep) - pkey =pte_to_pkey_bits (pte_val (READ_ONCE (*ptep))); -local_irq_restore (flags); - -return pkey; -} -#endif /* CONFIG_PPC_MEM_KEYS */ -#ifdef CONFIG_PPC_TRANSACTIONAL_MEM static inline void tm_flush_hash_page (int local) {
arch/powerpc/mm/fault.c +60 -23
120 lines not on this page · raw message
Signature · 1 line
2.25.3
PATCH v3 2/22 powerpc/pkeys: Check vma before returning key fault error to the user
In reply to Aneesh Kumar K.VIf multiple threads in userspace keep changing the protection keys mapping a range, there can be a scenario where kernel takes a key fault but the pkey value found in the siginfo struct is a permissive one.
This can confuse the userspace as shown in the below test case.
/* use this to control the number of test iterations */
static void pkeyreg_set(int pkey, unsigned long rights)
{
unsigned long reg, shift;
shift = (NR_PKEYS - pkey - 1) * PKEY_BITS_PER_PKEY;
asm volatile("mfspr %0, 0xd" : "=r"(reg));
reg &= ~(((unsigned long) PKEY_BITS_MASK) << shift);
reg |= (rights & PKEY_BITS_MASK) << shift;
asm volatile("mtspr 0xd, %0" : : "r"(reg));
}static unsigned long pkeyreg_get(void)
{
unsigned long reg;
asm volatile("mfspr %0, 0xd" : "=r"(reg));
return reg;
}static int sys_pkey_mprotect(void *addr, size_t len, int prot, int pkey)
{
return syscall(SYS_pkey_mprotect, addr, len, prot, pkey);
}static int sys_pkey_alloc(unsigned long flags, unsigned long access_rights)
{
return syscall(SYS_pkey_alloc, flags, access_rights);
}static int sys_pkey_free(int pkey)
{
return syscall(SYS_pkey_free, pkey);
}static int faulting_pkey;
static int permissive_pkey;
static pthread_barrier_t pkey_set_barrier;
static pthread_barrier_t mprotect_barrier;
static void pkey_handle_fault(int signum, siginfo_t *sinfo, void *ctx)
{
unsigned long pkeyreg;
/* FIXME: printf is not signal-safe but for the current purpose,
it gets the job done. */
printf("pkey: exp = %d, got = %d\n", faulting_pkey, sinfo->si_pkey);
fflush(stdout);
assert(sinfo->si_code == SEGV_PKUERR);
assert(sinfo->si_pkey == faulting_pkey);
/* clear pkey permissions to let the faulting instruction continue */
pkeyreg_set(faulting_pkey, 0x0);
}static void *do_mprotect_fault(void *p)
{
unsigned long rights, pkeyreg, pgsize;
unsigned int i;
void *region;
int pkey;
srand(time(NULL));
pgsize = sysconf(_SC_PAGESIZE);
rights = PKEY_DISABLE_WRITE;
region = p;
/* allocate key, no permissions */
assert((pkey = sys_pkey_alloc(0, PKEY_DISABLE_ACCESS)) > 0);
pkeyreg_set(4, 0x0);
/* cache the pkey here as the faulting pkey for future reference
in the signal handler */
faulting_pkey = pkey;
printf("%s: faulting pkey = %d\n", __func__, faulting_pkey);
/* try to allocate, mprotect and free pkeys repeatedly */
for (i = 0; i < NUM_ITERATIONS; i++) {
/* sync up with the other thread here */
pthread_barrier_wait(&pkey_set_barrier);
/* make sure that the pkey used by the non-faulting thread
is made permissive for this thread's context too so that
no faults are triggered because it still might have been
set to a restrictive value */// pkeyreg_set(permissive_pkey, 0x0);
/* sync up with the other thread here */ pthread_barrier_wait(&mprotect_barrier); /* perform mprotect */ assert(!sys_pkey_mprotect(region, pgsize, PROT_READ | PROT_WRITE, pkey)); /* choose a random byte from the protected region and attempt to write to it, this will generate a fault */ *((char *) region + (rand() % pgsize)) = rand(); /* restore pkey permissions as the signal handler may have cleared the bit out for the sake of continuing */ pkeyreg_set(pkey, PKEY_DISABLE_WRITE); } /* free pkey */ sys_pkey_free(pkey); return NULL; }
static void *do_mprotect_nofault(void *p)
{
unsigned long pgsize;
unsigned int i, j;
void *region;
int pkey;
pgsize = sysconf(_SC_PAGESIZE);
region = p;
/* try to allocate, mprotect and free pkeys repeatedly */
for (i = 0; i < NUM_ITERATIONS; i++) {
/* allocate pkey, all permissions */
assert((pkey = sys_pkey_alloc(0, 0)) > 0);
permissive_pkey = pkey;
/* sync up with the other thread here */
pthread_barrier_wait(&pkey_set_barrier);
pthread_barrier_wait(&mprotect_barrier);
/* perform mprotect on the common page, no faults will
be triggered as this is most permissive */
assert(!sys_pkey_mprotect(region, pgsize, PROT_READ | PROT_WRITE, pkey));
/* free pkey */
assert(!sys_pkey_free(pkey));
}
return NULL;
}int main(int argc, char **argv)
{
pthread_t fault_thread, nofault_thread;
unsigned long pgsize;
struct sigaction act;
pthread_attr_t attr;
cpu_set_t fault_cpuset, nofault_cpuset;
unsigned int i;
void *region;
/* allocate memory region to protect */
pgsize = sysconf(_SC_PAGESIZE);
assert(region = memalign(pgsize, pgsize));
CPU_ZERO(&fault_cpuset);
CPU_SET(0, &fault_cpuset);
CPU_ZERO(&nofault_cpuset);
CPU_SET(8, &nofault_cpuset);
assert(!pthread_attr_init(&attr));
/* setup sigsegv signal handler */
act.sa_handler = 0;
act.sa_sigaction = pkey_handle_fault;
assert(!sigprocmask(SIG_SETMASK, 0, &act.sa_mask));
act.sa_flags = SA_SIGINFO;
act.sa_restorer = 0;
assert(!sigaction(SIGSEGV, &act, NULL));
/* setup barrier for the two threads */
pthread_barrier_init(&pkey_set_barrier, NULL, 2);
pthread_barrier_init(&mprotect_barrier, NULL, 2);
/* setup and start threads */
assert(!pthread_create(&fault_thread, &attr, &do_mprotect_fault, region));
assert(!pthread_setaffinity_np(fault_thread, sizeof(cpu_set_t), &fault_cpuset));
assert(!pthread_create(&nofault_thread, &attr, &do_mprotect_nofault, region));
assert(!pthread_setaffinity_np(nofault_thread, sizeof(cpu_set_t), &nofault_cpuset));
/* cleanup */
assert(!pthread_attr_destroy(&attr));
assert(!pthread_join(fault_thread, NULL));
assert(!pthread_join(nofault_thread, NULL));
assert(!pthread_barrier_destroy(&pkey_set_barrier));
assert(!pthread_barrier_destroy(&mprotect_barrier));
free(region);
puts("PASS");
return EXIT_SUCCESS;
}The above test can result the below failure without this patch.
pkey: exp = 3, got = 3
pkey: exp = 3, got = 4
a.out: pkey-siginfo-race.c:100: pkey_handle_fault: Assertion `sinfo->si_pkey == faulting_pkey' failed. Aborted
Check for vma access before considering this a key fault. If vma pkey allow access retry the acess again.
Test case is written by Sandipan Das <[email protected]> hence added SOB from him.
--- arch/powerpc/mm/fault.c | 8 -------- 1 file changed, 8 deletions(-)
arch/powerpc/mm/fault.c +0 -8
@@ -319,14 +319,6 @@ static bool bad_stack_expansion(struct pt_regs *regs, unsigned long address,static bool access_pkey_error (bool is_write,bool is_exec,bool is_pkey,struct vm_area_struct *vma) { -/* -* Read or write was blocked by protection keys. This is -* always an unconditional error and can never result in -* a follow-up action to resolve the fault, like a COW. -*/ -if (is_pkey) -return true; -/* * Make sure to check the VMA so that we do not perform * faults just to hit a pkey fault as soon as we fill in a
Signature · 1 line
2.25.3
PATCH v3 3/22 powerpc/mm/hash64: use _PAGE_PTE when checking for pte_present
In reply to Aneesh Kumar K.VThis makes the pte_present check stricter by checking for additional _PAGE_PTE bit. A level 1 pte pointer (THP pte) can be switched to a pointer to level 0 pte page table page by following two operations.
1) THP split.
2) madvise(MADV_DONTNEED) in parallel to page fault.
A lockless page table walk need to make sure we can handle such changes gracefully.
--- arch/powerpc/include/asm/book3s/64/pgtable.h | 15 ++++++++++----- arch/powerpc/mm/book3s64/hash_utils.c | 11 +++++++++-- 2 files changed, 19 insertions(+), 7 deletions(-)
arch/powerpc/include/asm/book3s/64/pgtable.h +10 -5
@@ -553,6 +553,12 @@ static inline pte_t pte_clear_savedwrite(pte_t pte) }#endif /* CONFIG_NUMA_BALANCING */ +static inline bool pte_hw_valid (pte_t pte) +{ +return (pte_raw (pte) &cpu_to_be64 (_PAGE_PRESENT | _PAGE_PTE)) == +cpu_to_be64 (_PAGE_PRESENT | _PAGE_PTE); +} +static inline int pte_present (pte_t pte) {/*
@@ -561,12 +567,11 @@ static inline int pte_present(pte_t pte)* invalid during ptep_set_access_flags. Hence we look for _PAGE_INVALID * if we find _PAGE_PRESENT cleared. */ -return !!(pte_raw (pte) &cpu_to_be64 (_PAGE_PRESENT | _PAGE_INVALID)); -} -static inline bool pte_hw_valid (pte_t pte) -{ -return !!(pte_raw (pte) &cpu_to_be64 (_PAGE_PRESENT)); +if (pte_hw_valid (pte)) +return true; +return (pte_raw (pte) &cpu_to_be64 (_PAGE_INVALID | _PAGE_PTE)) == +cpu_to_be64 (_PAGE_INVALID | _PAGE_PTE); }#ifdef CONFIG_PPC_MEM_KEYS
arch/powerpc/mm/book3s64/hash_utils.c +9 -2
@@ -1350,8 +1350,15 @@ int hash_page_mm(struct mm_struct *mm, unsigned long ea, goto bail; } -/* Add _PAGE_PRESENT to the required access perm */ - access |= _PAGE_PRESENT; +/* +* Add _PAGE_PRESENT to the required access perm. If there are parallel +* updates to the pte that can possibly clear _PAGE_PTE, catch that too. +* +* We can safely use the return pte address in rest of the function +* because we do set H_PAGE_BUSY which prevents further updates to pte +* from generic code. +*/ + access |= _PAGE_PRESENT | _PAGE_PTE;/* * Pre-check access permissions (will be re-checked atomically
Signature · 1 line
2.25.3
PATCH v3 4/22 powerpc/hash64: Restrict page table lookup using init_mm with __flush_hash_table_range
In reply to Aneesh Kumar K.VThis is only used with init_mm currently. Walking init_mm is much simpler because we don't need to handle concurrent page table like other mm_context
--- .../include/asm/book3s/64/tlbflush-hash.h | 3 +-- arch/powerpc/kernel/pci_64.c | 2 +- arch/powerpc/mm/book3s64/hash_tlb.c | 16 +++------------- 3 files changed, 5 insertions(+), 16 deletions(-)
arch/powerpc/include/asm/book3s/64/tlbflush-hash.h +1 -2
@@ -113,8 +113,7 @@ static inline void hash__flush_tlb_kernel_range(unsigned long start,struct mmu_gather ;extern void hash__tlb_flush (struct mmu_gather *tlb);/* Private function for use by PCI IO mapping code */ -extern void __flush_hash_table_range (struct mm_struct *mm,unsigned long start, -unsigned long end); +extern void __flush_hash_table_range (unsigned long start,unsigned long end);extern void flush_tlb_pmd_range (struct mm_struct *mm,pmd_t *pmd,unsigned long addr);#endif /* _ASM_POWERPC_BOOK3S_64_TLBFLUSH_HASH_H */
arch/powerpc/kernel/pci_64.c +1 -1
@@ -100,7 +100,7 @@ int pcibios_unmap_io_space(struct pci_bus *bus) pci_name(bus->self));#ifdef CONFIG_PPC_BOOK3S_64 -__flush_hash_table_range (&init_mm, res->start + _IO_BASE, +__flush_hash_table_range (res->start + _IO_BASE, res->end + _IO_BASE +1 );#endif return 0 ;
arch/powerpc/mm/book3s64/hash_tlb.c +3 -13
@@ -176,7 +176,6 @@ void hash__tlb_flush(struct mmu_gather *tlb)* from the hash table (and the TLB). But keeps * the linux PTEs intact. * -* @mm : mm_struct of the target address space (generally init_mm) * @start : starting address * @end : ending address (not included in the flush) *
@@ -189,17 +188,14 @@ void hash__tlb_flush(struct mmu_gather *tlb)* Because of that usage pattern, it is implemented for small size rather * than speed. */ -void __flush_hash_table_range (struct mm_struct *mm,unsigned long start, -unsigned long end) +void __flush_hash_table_range (unsigned long start,unsigned long end) { -bool is_thp;int hugepage_shift;unsigned long flags; start =_ALIGN_DOWN (start,PAGE_SIZE ); end =_ALIGN_UP (end,PAGE_SIZE ); -BUG_ON (!mm->pgd);/* * Note: Normally, we should only ever use a batch within a
@@ -212,21 +208,15 @@ void __flush_hash_table_range(struct mm_struct *mm, unsigned long start,local_irq_save (flags);arch_enter_lazy_mmu_mode ();for (; start < end; start +=PAGE_SIZE ) { -pte_t *ptep =find_current_mm_pte (mm->pgd, start, &is_thp, - &hugepage_shift); +pte_t *ptep =find_init_mm_pte (start, &hugepage_shift);unsigned long pte;if (ptep ==NULL )continue ; pte =pte_val (*ptep); -if (is_thp) -trace_hugepage_invalidate (start, pte);if (!(pte &H_PAGE_HASHPTE ))continue ; -if (unlikely (is_thp)) -hpte_do_hugepage_flush (mm, start, (pmd_t *)ptep, pte); -else -hpte_need_flush (mm, start, ptep, pte, hugepage_shift); +hpte_need_flush (&init_mm, start, ptep, pte, hugepage_shift); }arch_leave_lazy_mmu_mode ();local_irq_restore (flags);
Signature · 1 line
2.25.3
PATCH v3 5/22 powerpc/book3s64/hash: Use the pte_t address from the caller
In reply to Aneesh Kumar K.VDon't fetch the pte value using lockless page table walk. Instead use the value from the caller. hash_preload is called with ptl lock held. So it is safe to use the pte_t address directly.
--- arch/powerpc/mm/book3s64/hash_utils.c | 27 +++++---------------------- 1 file changed, 5 insertions(+), 22 deletions(-)
arch/powerpc/mm/book3s64/hash_utils.c +5 -22
@@ -1546,14 +1546,11 @@ static bool should_hash_preload(struct mm_struct *mm, unsigned long ea) }#endif -static void hash_preload (struct mm_struct *mm,unsigned long ea, +static void hash_preload (struct mm_struct *mm,pte_t *ptep,unsigned long ea,bool is_exec,unsigned long trap) { -int hugepage_shift;unsigned long vsid;pgd_t *pgdir; -pte_t *ptep; -unsigned long flags;int rc, ssize, update_flags =0 ;unsigned long access = _PAGE_PRESENT | _PAGE_READ | (is_exec ? _PAGE_EXEC :0 );
@@ -1575,30 +1572,18 @@ static void hash_preload(struct mm_struct *mm, unsigned long ea, vsid =get_user_vsid (&mm->context, ea, ssize);if (!vsid)return ; -/* -* Hash doesn't like irqs. Walking linux page table with irq disabled -* saves us from holding multiple locks. -*/ -local_irq_save (flags); -/* -* THP pages use update_mmu_cache_pmd. We don't do -* hash preload there. Hence can ignore THP here -*/ - ptep =find_current_mm_pte (pgdir, ea,NULL , &hugepage_shift); -if (!ptep) - goto out_exit; - -WARN_ON (hugepage_shift);#ifdef CONFIG_PPC_64K_PAGES /* If either H_PAGE_4K_PFN or cache inhibited is set (and we are on * a 64K kernel), then we don't preload, hash_page() will take * care of it once we actually try to access the page. * That way we don't have to duplicate all of the logic for segment * page size demotion here +* Called with PTL held, hence can be sure the value won't change in +* between. */ if ((pte_val (*ptep) &H_PAGE_4K_PFN ) ||pte_ci (*ptep)) - goto out_exit; +return ;#endif /* CONFIG_PPC_64K_PAGES */ /* Is that local to this CPU ? */
@@ -1623,8 +1608,6 @@ static void hash_preload(struct mm_struct *mm, unsigned long ea,mm_ctx_user_psize (&mm->context),mm_ctx_user_psize (&mm->context), pte_val(*ptep)); -out_exit: -local_irq_restore (flags); }/*
@@ -1675,7 +1658,7 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,return ; } -hash_preload (vma->vm_mm, address, is_exec, trap); +hash_preload (vma->vm_mm, ptep, address, is_exec, trap); }#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
Signature · 1 line
2.25.3
PATCH v3 6/22 powerpc/mce: Don't reload pte val in addr_to_pfn
In reply to Aneesh Kumar K.VA lockless page table walk should be safe against parallel THP collapse, THP split and madvise(MADV_DONTNEED)/parallel fault. This patch makes sure kernel won't reload the pteval when checking for different conditions. The patch also added a check for pte_present to make sure the kernel is indeed operating
on a PTE and not a pointer to level 0 table page.
The pfn value we find here can be different from the actual pfn on which machine check happened. This can happen if we raced with a parallel update of the page table. In such a scenario we end up isolating a wrong pfn. But that doesn't have any other side effect.
--- arch/powerpc/kernel/mce_power.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)
arch/powerpc/kernel/mce_power.c +9 -5
@@ -27,7 +27,7 @@*/ unsigned long addr_to_pfn (struct pt_regs *regs,unsigned long addr) { -pte_t *ptep; +pte_t *ptep, pte;unsigned int shift;unsigned long pfn, flags;struct mm_struct *mm;
@@ -39,19 +39,23 @@ unsigned long addr_to_pfn(struct pt_regs *regs, unsigned long addr)local_irq_save (flags); ptep =__find_linux_pte (mm->pgd, addr,NULL , &shift); +if (!ptep) { + pfn =ULONG_MAX ; + goto out; + } + pte =READ_ONCE (*ptep); -if (!ptep ||pte_special (*ptep)) { +if (!pte_present (pte) ||pte_special (pte)) { pfn =ULONG_MAX ; goto out; }if (shift <=PAGE_SHIFT ) - pfn =pte_pfn (*ptep); + pfn =pte_pfn (pte);else {unsigned long rpnmask = (1ul << shift) -PAGE_SIZE ; - pfn =pte_pfn (__pte (pte_val (*ptep) | (addr & rpnmask))); + pfn =pte_pfn (__pte (pte_val (pte) | (addr & rpnmask))); } - out:local_irq_restore (flags);return pfn;
Signature · 1 line
2.25.3
PATCH v3 7/22 powerpc/perf/callchain: Use __get_user_pages_fast in read_user_stack_slow
In reply to Aneesh Kumar K.Vread_user_stack_slow is called with interrupts soft disabled and it copies contents from the page which we find mapped to a specific address. To convert userspace address to pfn, the kernel now uses lockless page table walk.
The kernel needs to make sure the pfn value read remains stable and is not released and reused for another process while the contents are read from the page. This can only be achieved by holding a page reference.
One of the first approaches I tried was to check the pte value after the kernel copies the contents from the page. But as shown below we can still get it wrong
CPU0 CPU1
pte = READ_ONCE(*ptep);
pte_clear(pte);
put_page(page);
page = alloc_page();
memcpy(page_address(page), "secret password", nr);
memcpy(buf, kaddr + offset, nb);
put_page(page);
handle_mm_fault()
page = alloc_page();
set_pte(pte, page);if (pte_val(pte) != pte_val(*ptep))
Hence switch to __get_user_pages_fast.
--- arch/powerpc/perf/callchain_64.c | 46 ++++++++++---------------------- 1 file changed, 14 insertions(+), 32 deletions(-)
arch/powerpc/perf/callchain_64.c +14 -32
@@ -26,43 +26,25 @@*/ int read_user_stack_slow (void __user *ptr,void *buf,int nb) { -int ret = -EFAULT ; -pgd_t *pgdir; -pte_t *ptep, pte; -unsigned int shift; +unsigned long addr = (unsigned long ) ptr;unsigned long offset; -unsigned long pfn, flags; +struct page *page; +int nrpages;void *kaddr; - pgdir = current->mm->pgd; -if (!pgdir) -return -EFAULT ; + nrpages =__get_user_pages_fast (addr,1 ,1 , &page); +if (nrpages ==1 ) { + kaddr =page_address (page); + +/* align address to page boundary */ + offset = addr & ~PAGE_MASK ; -local_irq_save (flags); - ptep =find_current_mm_pte (pgdir, addr,NULL , &shift); -if (!ptep) - goto err_out; -if (!shift) - shift =PAGE_SHIFT ; - -/* align address to page boundary */ - offset = addr & ((1UL << shift) -1 ); - - pte =READ_ONCE (*ptep); -if (!pte_present (pte) || !pte_user (pte)) - goto err_out; - pfn =pte_pfn (pte); -if (!page_is_ram (pfn)) - goto err_out; - -/* no highmem to worry about here */ - kaddr =pfn_to_kaddr (pfn); -memcpy (buf, kaddr + offset, nb); - ret =0 ; -err_out: -local_irq_restore (flags); -return ret; +memcpy (buf, kaddr + offset, nb); +put_page (page); +return 0 ; + } +return -EFAULT ; }static int read_user_stack_64 (unsigned long __user *ptr,unsigned long *ret)
Signature · 1 line
2.25.3
PATCH v3 8/22 powerpc/kvm/book3s: switch from raw_spin_*lock to arch_spin_lock.
In reply to Aneesh Kumar K.VThese functions can get called in realmode. Hence use low level arch_spin_lock which is safe to be called in realmode.
--- arch/powerpc/kvm/book3s_hv_rm_mmu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
arch/powerpc/kvm/book3s_hv_rm_mmu.c +4 -4
@@ -948,7 +948,7 @@ static long kvmppc_do_h_page_init_zero(struct kvm_vcpu *vcpu,return ret;/* Check if we've been invalidated */ -raw_spin_lock (&kvm->mmu_lock.rlock); +arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock);if (mmu_notifier_retry (kvm, mmu_seq)) { ret =H_TOO_HARD ; goto out_unlock;
@@ -960,7 +960,7 @@ static long kvmppc_do_h_page_init_zero(struct kvm_vcpu *vcpu,kvmppc_update_dirty_map (memslot, dest >>PAGE_SHIFT ,PAGE_SIZE ); out_unlock: -raw_spin_unlock (&kvm->mmu_lock.rlock); +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock);return ret; }
@@ -984,7 +984,7 @@ static long kvmppc_do_h_page_init_copy(struct kvm_vcpu *vcpu,return ret;/* Check if we've been invalidated */ -raw_spin_lock (&kvm->mmu_lock.rlock); +arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock);if (mmu_notifier_retry (kvm, mmu_seq)) { ret =H_TOO_HARD ; goto out_unlock;
@@ -996,7 +996,7 @@ static long kvmppc_do_h_page_init_copy(struct kvm_vcpu *vcpu,kvmppc_update_dirty_map (dest_memslot, dest >>PAGE_SHIFT ,PAGE_SIZE ); out_unlock: -raw_spin_unlock (&kvm->mmu_lock.rlock); +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock);return ret; }
Signature · 1 line
2.25.3
PATCH v3 9/22 powerpc/kvm/book3s: Add helper to walk partition scoped linux page table.
In reply to Aneesh Kumar K.VThe locking rules for walking partition scoped table is different from process scoped table. Hence add a helper for secondary linux page table walk and also add check whether we are holding the right locks.
--- arch/powerpc/include/asm/kvm_book3s_64.h | 13 +++++++++++++ arch/powerpc/kvm/book3s_64_mmu_radix.c | 12 ++++++------ arch/powerpc/kvm/book3s_hv_nested.c | 2 +- 3 files changed, 20 insertions(+), 7 deletions(-)
arch/powerpc/include/asm/kvm_book3s_64.h +13 -0
@@ -14,6 +14,7 @@#include <asm/book3s/64/mmu-hash.h> #include <asm/cpu_has_feature.h> #include <asm/ppc-opcode.h> +#include <asm/pte-walk.h> #ifdef CONFIG_PPC_PSERIES static inline bool kvmhv_on_pseries (void )
@@ -634,6 +635,18 @@ extern void kvmhv_remove_nest_rmap_range(struct kvm *kvm, unsigned long gpa, unsigned long hpa, unsigned long nbytes); +static inline pte_t *find_kvm_secondary_pte (struct kvm *kvm,unsigned long ea, +unsigned *hshift) +{ +pte_t *pte; + +VM_WARN (!spin_is_locked (&kvm->mmu_lock), +"%s called with kvm mmu_lock not held \n" , __func__); + pte =__find_linux_pte (kvm->arch.pgtable, ea,NULL , hshift); + +return pte; +} +#endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ #endif /* __ASM_KVM_BOOK3S_64_H__ */
arch/powerpc/kvm/book3s_64_mmu_radix.c +6 -6
@@ -980,11 +980,11 @@ int kvm_unmap_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,return 0 ; } - ptep =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + ptep =find_kvm_secondary_pte (kvm, gpa, &shift);if (ptep &&pte_present (*ptep))kvmppc_unmap_pte (kvm, ptep, gpa, shift, memslot, kvm->arch.lpid); -return 0 ; +return 0 ; }/* Called with kvm->mmu_lock held */
@@ -1000,7 +1000,7 @@ int kvm_age_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,if (kvm->arch.secure_guest &KVMPPC_SECURE_INIT_DONE )return ref; - ptep =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + ptep =find_kvm_secondary_pte (kvm, gpa, &shift);if (ptep &&pte_present (*ptep) &&pte_young (*ptep)) { old =kvmppc_radix_update_pte (kvm, ptep, _PAGE_ACCESSED,0 , gpa, shift);
@@ -1027,7 +1027,7 @@ int kvm_test_age_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,if (kvm->arch.secure_guest &KVMPPC_SECURE_INIT_DONE )return ref; - ptep =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + ptep =find_kvm_secondary_pte (kvm, gpa, &shift);if (ptep &&pte_present (*ptep) &&pte_young (*ptep)) ref =1 ;return ref;
@@ -1047,7 +1047,7 @@ static int kvm_radix_test_clear_dirty(struct kvm *kvm,if (kvm->arch.secure_guest &KVMPPC_SECURE_INIT_DONE )return ret; - ptep =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + ptep =find_kvm_secondary_pte (kvm, gpa, &shift);if (ptep &&pte_present (*ptep) &&pte_dirty (*ptep)) { ret =1 ;if (shift)
@@ -1108,7 +1108,7 @@ void kvmppc_radix_flush_memslot(struct kvm *kvm, gpa = memslot->base_gfn <<PAGE_SHIFT ;spin_lock (&kvm->mmu_lock);for (n = memslot->npages; n; --n) { - ptep =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + ptep =find_kvm_secondary_pte (kvm, gpa, &shift);if (ptep &&pte_present (*ptep))kvmppc_unmap_pte (kvm, ptep, gpa, shift, memslot, kvm->arch.lpid);
arch/powerpc/kvm/book3s_hv_nested.c +1 -1
@@ -1362,7 +1362,7 @@ static long int __kvmhv_nested_page_fault(struct kvm_run *run,/* See if can find translation in our partition scoped tables for L1 */ pte =__pte (0 );spin_lock (&kvm->mmu_lock); - pte_p =__find_linux_pte (kvm->arch.pgtable, gpa,NULL , &shift); + pte_p =find_kvm_secondary_pte (kvm, gpa, &shift);if (!shift) shift =PAGE_SHIFT ;if (pte_p)
Signature · 1 line
2.25.3
PATCH v3 10/22 powerpc/kvm/nested: Add helper to walk nested shadow linux page table.
In reply to Aneesh Kumar K.VThe locking rules for walking nested shadow linux page table is different from process scoped table. Hence add a helper for nested page table walk and also
add check whether we are holding the right locks.
--- arch/powerpc/kvm/book3s_hv_nested.c | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-)
arch/powerpc/kvm/book3s_hv_nested.c +21 -7
@@ -750,6 +750,24 @@ static struct kvm_nested_guest *kvmhv_find_nested(struct kvm *kvm, int lpid)return kvm->arch.nested_guests[lpid]; } +static pte_t *find_kvm_nested_guest_pte (struct kvm *kvm,unsigned long lpid, +unsigned long ea,unsigned *hshift) +{ +struct kvm_nested_guest *gp; +pte_t *pte; + + gp =kvmhv_find_nested (kvm, lpid); +if (!gp) +return NULL ; + +VM_WARN (!spin_is_locked (&kvm->mmu_lock), +"%s called with kvm mmu_lock not held \n" , __func__); + pte =__find_linux_pte (gp->shadow_pgtable, ea,NULL , hshift); + +return pte; +} + +static inline bool kvmhv_n_rmap_is_equal (u64 rmap_1,u64 rmap_2) { return !((rmap_1 ^ rmap_2) & (RMAP_NESTED_LPID_MASK |
@@ -792,19 +810,15 @@ static void kvmhv_update_nest_rmap_rc(struct kvm *kvm, u64 n_rmap, unsigned long clr, unsigned long set, unsigned long hpa, unsigned long mask) { - struct kvm_nested_guest *gp; unsigned long gpa;unsigned int shift, lpid;pte_t *ptep; gpa = n_rmap &RMAP_NESTED_GPA_MASK ; lpid = (n_rmap &RMAP_NESTED_LPID_MASK ) >>RMAP_NESTED_LPID_SHIFT ; - gp =kvmhv_find_nested (kvm, lpid); -if (!gp) -return ;/* Find the pte */ - ptep =__find_linux_pte (gp->shadow_pgtable, gpa,NULL , &shift); + ptep =find_kvm_nested_guest_pte (kvm, lpid, gpa, &shift);/* * If the pte is present and the pfn is still the same, update the pte. * If the pfn has changed then this is a stale rmap entry, the nested
@@ -854,7 +868,7 @@ static void kvmhv_remove_nest_rmap(struct kvm *kvm, u64 n_rmap,return ;/* Find and invalidate the pte */ - ptep =__find_linux_pte (gp->shadow_pgtable, gpa,NULL , &shift); + ptep =find_kvm_nested_guest_pte (kvm, lpid, gpa, &shift);/* Don't spuriously invalidate ptes if the pfn has changed */ if (ptep &&pte_present (*ptep) && ((pte_val (*ptep) & mask) == hpa))kvmppc_unmap_pte (kvm, ptep, gpa, shift,NULL , gp->shadow_lpid);
@@ -921,7 +935,7 @@ static bool kvmhv_invalidate_shadow_pte(struct kvm_vcpu *vcpu,int shift;spin_lock (&kvm->mmu_lock); - ptep =__find_linux_pte (gp->shadow_pgtable, gpa,NULL , &shift); + ptep =find_kvm_nested_guest_pte (kvm, gp->l1_lpid, gpa, &shift);if (!shift) shift =PAGE_SHIFT ;if (ptep &&pte_present (*ptep)) {
Signature · 1 line
2.25.3
PATCH v3 11/22 powerpc/kvm/book3s: Use kvm helpers to walk shadow or secondary table
In reply to Aneesh Kumar K.Vupdate kvmppc_hv_handle_set_rc to use find_kvm_nested_guest_pte and find_kvm_secondary_pte
--- arch/powerpc/include/asm/kvm_book3s.h | 2 +- arch/powerpc/include/asm/kvm_book3s_64.h | 3 +++ arch/powerpc/kvm/book3s_64_mmu_radix.c | 18 +++++++++--------- arch/powerpc/kvm/book3s_hv_nested.c | 13 ++++++------- 4 files changed, 19 insertions(+), 17 deletions(-)
arch/powerpc/include/asm/kvm_book3s.h +1 -1
@@ -198,7 +198,7 @@ extern void kvmppc_unmap_pte(struct kvm *kvm, pte_t *pte, unsigned long gpa,unsigned int shift, const struct kvm_memory_slot *memslot, unsigned int lpid); -extern bool kvmppc_hv_handle_set_rc (struct kvm *kvm,pgd_t *pgtable, +extern bool kvmppc_hv_handle_set_rc (struct kvm *kvm,bool nested,bool writing,unsigned long gpa,unsigned int lpid); extern int kvmppc_book3s_instantiate_page(struct kvm_vcpu *vcpu,
arch/powerpc/include/asm/kvm_book3s_64.h +3 -0
@@ -647,6 +647,9 @@ static inline pte_t *find_kvm_secondary_pte(struct kvm *kvm, unsigned long ea,return pte; } +extern pte_t *find_kvm_nested_guest_pte (struct kvm *kvm,unsigned long lpid, +unsigned long ea,unsigned *hshift); +#endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ #endif /* __ASM_KVM_BOOK3S_64_H__ */
arch/powerpc/kvm/book3s_64_mmu_radix.c +9 -9
@@ -735,7 +735,7 @@ int kvmppc_create_pte(struct kvm *kvm, pgd_t *pgtable, pte_t pte,return ret; } -bool kvmppc_hv_handle_set_rc (struct kvm *kvm,pgd_t *pgtable,bool writing, +bool kvmppc_hv_handle_set_rc (struct kvm *kvm,bool nested,bool writing,unsigned long gpa,unsigned int lpid) {unsigned long pgflags;
@@ -750,12 +750,12 @@ bool kvmppc_hv_handle_set_rc(struct kvm *kvm, pgd_t *pgtable, bool writing, pgflags = _PAGE_ACCESSED;if (writing) pgflags |= _PAGE_DIRTY; -/* -* We are walking the secondary (partition-scoped) page table here. -* We can do this without disabling irq because the Linux MM -* subsystem doesn't do THP splits and collapses on this tree. -*/ - ptep =__find_linux_pte (pgtable, gpa,NULL , &shift); + +if (nested) + ptep =find_kvm_nested_guest_pte (kvm, lpid, gpa, &shift); +else + ptep =find_kvm_secondary_pte (kvm, gpa, &shift); +if (ptep &&pte_present (*ptep) && (!writing ||pte_write (*ptep))) {kvmppc_radix_update_pte (kvm, ptep,0 , pgflags, gpa, shift);return true;
@@ -948,8 +948,8 @@ int kvmppc_book3s_radix_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,/* Failed to set the reference/change bits */ if (dsisr &DSISR_SET_RC ) {spin_lock (&kvm->mmu_lock); -if (kvmppc_hv_handle_set_rc (kvm, kvm->arch.pgtable, - writing, gpa, kvm->arch.lpid)) +if (kvmppc_hv_handle_set_rc (kvm, false, writing, + gpa, kvm->arch.lpid)) dsisr &= ~DSISR_SET_RC ;spin_unlock (&kvm->mmu_lock);
arch/powerpc/kvm/book3s_hv_nested.c +6 -7
@@ -750,8 +750,8 @@ static struct kvm_nested_guest *kvmhv_find_nested(struct kvm *kvm, int lpid)return kvm->arch.nested_guests[lpid]; } -static pte_t *find_kvm_nested_guest_pte (struct kvm *kvm,unsigned long lpid, -unsigned long ea,unsigned *hshift) +pte_t *find_kvm_nested_guest_pte (struct kvm *kvm,unsigned long lpid, +unsigned long ea,unsigned *hshift) {struct kvm_nested_guest *gp;pte_t *pte;
@@ -767,7 +767,6 @@ static pte_t *find_kvm_nested_guest_pte(struct kvm *kvm, unsigned long lpid,return pte; } -static inline bool kvmhv_n_rmap_is_equal (u64 rmap_1,u64 rmap_2) { return !((rmap_1 ^ rmap_2) & (RMAP_NESTED_LPID_MASK |
@@ -1226,16 +1225,16 @@ static long kvmhv_handle_nested_set_rc(struct kvm_vcpu *vcpu,spin_lock (&kvm->mmu_lock);/* Set the rc bit in the pte of our (L0) pgtable for the L1 guest */ - ret =kvmppc_hv_handle_set_rc (kvm, kvm->arch.pgtable, writing, - gpte.raddr, kvm->arch.lpid); + ret =kvmppc_hv_handle_set_rc (kvm, false, writing, + gpte.raddr, kvm->arch.lpid);if (!ret) { ret = -EINVAL ; goto out_unlock; }/* Set the rc bit in the pte of the shadow_pgtable for the nest guest */ - ret =kvmppc_hv_handle_set_rc (kvm, gp->shadow_pgtable, writing, n_gpa, - gp->shadow_lpid); + ret =kvmppc_hv_handle_set_rc (kvm, true, writing, + n_gpa, gp->shadow_lpid);if (!ret) ret = -EINVAL ;else
Signature · 1 line
2.25.3
PATCH v3 12/22 powerpc/kvm/book3s: Add helper for host page table walk
In reply to Aneesh Kumar K.V--- arch/powerpc/include/asm/kvm_book3s_64.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
arch/powerpc/include/asm/kvm_book3s_64.h +16 -0
@@ -647,6 +647,22 @@ static inline pte_t *find_kvm_secondary_pte(struct kvm *kvm, unsigned long ea,return pte; } +static inline pte_t *find_kvm_host_pte (struct kvm *kvm,unsigned long mmu_seq, +unsigned long ea,unsigned *hshift) +{ +pte_t *pte; + +VM_WARN (!spin_is_locked (&kvm->mmu_lock), +"%s called with kvm mmu_lock not held \n" , __func__); + +if (mmu_notifier_retry (kvm, mmu_seq)) +return NULL ; + + pte =__find_linux_pte (kvm->mm->pgd, ea,NULL , hshift); + +return pte; +} +extern pte_t *find_kvm_nested_guest_pte (struct kvm *kvm,unsigned long lpid,unsigned long ea,unsigned *hshift);
Signature · 1 line
2.25.3
PATCH v3 13/22 powerpc/kvm/book3s: Use find_kvm_host_pte in page fault handler
In reply to Aneesh Kumar K.V--- arch/powerpc/kvm/book3s_64_mmu_hv.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/powerpc/kvm/book3s_64_mmu_hv.c +5 -5
@@ -602,20 +602,20 @@ int kvmppc_book3s_hv_page_fault(struct kvm_run *run, struct kvm_vcpu *vcpu,* Read the PTE from the process' radix tree and use that * so we get the shift and attribute bits. */ -local_irq_disable (); - ptep =__find_linux_pte (vcpu->arch.pgdir, hva,NULL , &shift); +spin_lock (&kvm->mmu_lock); + ptep =find_kvm_host_pte (kvm, mmu_seq, hva, &shift);/* * If the PTE disappeared temporarily due to a THP * collapse, just return and let the guest try again. */ if (!ptep) { -local_irq_enable (); +spin_unlock (&kvm->mmu_lock);if (page)put_page (page);return RESUME_GUEST ; } - pte = *ptep; -local_irq_enable (); + pte =READ_ONCE (*ptep); +spin_unlock (&kvm->mmu_lock); hpa =pte_pfn (pte) <<PAGE_SHIFT ; pte_size =PAGE_SIZE ;if (shift)
Signature · 1 line
2.25.3
PATCH v3 14/22 powerpc/kvm/book3s: Use find_kvm_host_pte in h_enter
In reply to Aneesh Kumar K.VSince kvmppc_do_h_enter can get called in realmode use low level arch_spin_lock which is safe to be called in realmode.
--- arch/powerpc/kvm/book3s_64_mmu_hv.c | 5 ++--- arch/powerpc/kvm/book3s_hv_rm_mmu.c | 22 ++++++---------------- 2 files changed, 8 insertions(+), 19 deletions(-)
arch/powerpc/kvm/book3s_64_mmu_hv.c +2 -3
@@ -281,11 +281,10 @@ static long kvmppc_virtmode_do_h_enter(struct kvm *kvm, unsigned long flags, {long ret; -/* Protect linux PTE lookup from page table destruction */ -rcu_read_lock_sched ();/* this disables preemption too */ +preempt_disable (); ret =kvmppc_do_h_enter (kvm, flags, pte_index, pteh, ptel, kvm->mm->pgd, false, pte_idx_ret); -rcu_read_unlock_sched (); +preempt_enable ();if (ret ==H_TOO_HARD ) {/* this can't happen */ pr_err ("KVM: Oops, kvmppc_h_enter returned too hard!\n" );
arch/powerpc/kvm/book3s_hv_rm_mmu.c +6 -16
@@ -210,7 +210,7 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,pte_t *ptep;unsigned int writing;unsigned long mmu_seq; -unsigned long rcbits, irq_flags =0 ; +unsigned long rcbits;if (kvm_is_radix (kvm))return H_FUNCTION ;
@@ -248,17 +248,9 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,/* Translate to host virtual address */ hva =__gfn_to_hva_memslot (memslot, gfn); -/* -* If we had a page table table change after lookup, we would -* retry via mmu_notifier_retry. -*/ -if (!realmode) -local_irq_save (irq_flags); -/* -* If called in real mode we have MSR_EE = 0. Otherwise -* we disable irq above. -*/ - ptep =__find_linux_pte (pgdir, hva,NULL , &hpage_shift); + +arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock); + ptep =find_kvm_host_pte (kvm, mmu_seq, hva, &hpage_shift);if (ptep) {pte_t pte;unsigned int host_pte_size;
@@ -272,8 +264,7 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags,* to <= host page size, if host is using hugepage */ if (host_pte_size < psize) { -if (!realmode) -local_irq_restore (flags); +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock);return H_PARAMETER ; } pte =kvmppc_read_update_linux_pte (ptep, writing);
@@ -287,8 +278,7 @@ long kvmppc_do_h_enter(struct kvm *kvm, unsigned long flags, pa |= gpa & ~PAGE_MASK ; } } -if (!realmode) -local_irq_restore (irq_flags); +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock); ptel &=HPTE_R_KEY |HPTE_R_PP0 | (psize-1 ); ptel |= pa;
Signature · 1 line
2.25.3
PATCH v3 15/22 powerpc/kvm/book3s: use find_kvm_host_pte in pute_tce functions
In reply to Aneesh Kumar K.VCurrent code just hold rmap lock to ensure parallel page table update is prevented. That is not sufficient. The kernel should also check whether a mmu_notifer callback was running in parallel.
--- arch/powerpc/kvm/book3s_64_vio_hv.c | 30 +++++++++++++++++++++++------ 1 file changed, 24 insertions(+), 6 deletions(-)
arch/powerpc/kvm/book3s_64_vio_hv.c +24 -6
@@ -437,8 +437,8 @@ long kvmppc_rm_h_put_tce(struct kvm_vcpu *vcpu, unsigned long liobn,return H_SUCCESS ; } -static long kvmppc_rm_ua_to_hpa (struct kvm_vcpu *vcpu, -unsigned long ua,unsigned long *phpa) +static long kvmppc_rm_ua_to_hpa (struct kvm_vcpu *vcpu,unsigned long mmu_seq, +unsigned long ua,unsigned long *phpa) {pte_t *ptep, pte;unsigned shift =0 ;
@@ -452,10 +452,17 @@ static long kvmppc_rm_ua_to_hpa(struct kvm_vcpu *vcpu,* to exit which will agains result in the below page table walk * to finish. */ - ptep =__find_linux_pte (vcpu->arch.pgdir, ua,NULL , &shift); -if (!ptep || !pte_present (*ptep)) +/* an rmap lock won't make it safe. because that just ensure hash +* page table entries are removed with rmap lock held. After that +* mmu notifier returns and we go ahead and removing ptes from Qemu page table. +*/ + ptep =find_kvm_host_pte (vcpu->kvm, mmu_seq, ua, &shift); +if (!ptep) +return -ENXIO ; + + pte =READ_ONCE (*ptep); +if (!pte_present (pte))return -ENXIO ; - pte = *ptep;if (!shift) shift =PAGE_SHIFT ;
@@ -477,10 +484,12 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu, unsigned long liobn, unsigned long ioba, unsigned long tce_list, unsigned long npages) { + struct kvm *kvm = vcpu->kvm;struct kvmppc_spapr_tce_table *stt;long i, ret =H_SUCCESS ;unsigned long tces, entry, ua =0 ;unsigned long *rmap =NULL ; +unsigned long mmu_seq;bool prereg = false;struct kvmppc_spapr_tce_iommu_table *stit;
@@ -488,6 +497,12 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,if (kvm_is_radix (vcpu->kvm))return H_TOO_HARD ; +/* +* used to check for invalidations in progress +*/ + mmu_seq = kvm->mmu_notifier_seq; +smp_rmb (); + stt =kvmppc_find_table (vcpu->kvm, liobn);if (!stt)return H_TOO_HARD ;
@@ -547,7 +562,9 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,* real page. */ lock_rmap (rmap); -if (kvmppc_rm_ua_to_hpa (vcpu, ua, &tces)) { + +arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock); +if (kvmppc_rm_ua_to_hpa (vcpu, mmu_seq, ua, &tces)) { ret =H_TOO_HARD ; goto unlock_exit; }
@@ -593,6 +610,7 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,if (rmap)unlock_rmap (rmap); +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock);return ret; }
Signature · 1 line
2.25.3
PATCH v3 16/22 powerpc/kvm/book3s: Avoid using rmap to protect parallel page table update.
In reply to Aneesh Kumar K.VWe now depend on kvm->mmu_lock
--- arch/powerpc/kvm/book3s_64_vio_hv.c | 38 +++++++---------------------- 1 file changed, 9 insertions(+), 29 deletions(-)
arch/powerpc/kvm/book3s_64_vio_hv.c +9 -29
@@ -74,8 +74,8 @@ struct kvmppc_spapr_tce_table *kvmppc_find_table(struct kvm *kvm,EXPORT_SYMBOL_GPL (kvmppc_find_table);#ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE -static long kvmppc_rm_tce_to_ua (struct kvm *kvm,unsigned long tce, -unsigned long *ua,unsigned long **prmap) +static long kvmppc_rm_tce_to_ua (struct kvm *kvm, +unsigned long tce,unsigned long *ua) {unsigned long gfn = tce >>PAGE_SHIFT ;struct kvm_memory_slot *memslot;
@@ -87,9 +87,6 @@ static long kvmppc_rm_tce_to_ua(struct kvm *kvm, unsigned long tce, *ua =__gfn_to_hva_memslot (memslot, gfn) | (tce & ~(PAGE_MASK |TCE_PCI_READ |TCE_PCI_WRITE )); -if (prmap) - *prmap = &memslot->arch.rmap[gfn - memslot->base_gfn]; -return 0 ; }
@@ -116,7 +113,7 @@ static long kvmppc_rm_tce_validate(struct kvmppc_spapr_tce_table *stt,if (iommu_tce_check_gpa (stt->page_shift, gpa))return H_PARAMETER ; -if (kvmppc_rm_tce_to_ua (stt->kvm, tce, &ua,NULL )) +if (kvmppc_rm_tce_to_ua (stt->kvm, tce, &ua))return H_TOO_HARD ;list_for_each_entry_lockless (stit, &stt->iommu_tables, next) {
@@ -411,7 +408,7 @@ long kvmppc_rm_h_put_tce(struct kvm_vcpu *vcpu, unsigned long liobn,return ret; dir =iommu_tce_direction (tce); -if ((dir !=DMA_NONE ) &&kvmppc_rm_tce_to_ua (vcpu->kvm, tce, &ua,NULL )) +if ((dir !=DMA_NONE ) &&kvmppc_rm_tce_to_ua (vcpu->kvm, tce, &ua))return H_PARAMETER ; entry = ioba >> stt->page_shift;
@@ -488,7 +485,6 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,struct kvmppc_spapr_tce_table *stt;long i, ret =H_SUCCESS ;unsigned long tces, entry, ua =0 ; -unsigned long *rmap =NULL ;unsigned long mmu_seq;bool prereg = false;struct kvmppc_spapr_tce_iommu_table *stit;
@@ -530,7 +526,7 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,*/ struct mm_iommu_table_group_mem_t *mem; -if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce_list, &ua,NULL )) +if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce_list, &ua))return H_TOO_HARD ; mem =mm_iommu_lookup_rm (vcpu->kvm->mm, ua,IOMMU_PAGE_SIZE_4K );
@@ -546,23 +542,9 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,* We do not require memory to be preregistered in this case * so lock rmap and do __find_linux_pte_or_hugepte(). */ -if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce_list, &ua, &rmap)) -return H_TOO_HARD ; - - rmap = (void *)vmalloc_to_phys (rmap); -if (WARN_ON_ONCE_RM (!rmap)) +if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce_list, &ua))return H_TOO_HARD ; -/* -* Synchronize with the MMU notifier callbacks in -* book3s_64_mmu_hv.c (kvm_unmap_hva_range_hv etc.). -* While we have the rmap lock, code running on other CPUs -* cannot finish unmapping the host real page that backs -* this guest real page, so we are OK to access the host -* real page. -*/ -lock_rmap (rmap); -arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock);if (kvmppc_rm_ua_to_hpa (vcpu, mmu_seq, ua, &tces)) { ret =H_TOO_HARD ;
@@ -582,7 +564,7 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,unsigned long tce =be64_to_cpu (((u64 *)tces)[i]); ua =0 ; -if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce, &ua,NULL )) { +if (kvmppc_rm_tce_to_ua (vcpu->kvm, tce, &ua)) { ret =H_PARAMETER ; goto invalidate_exit; }
@@ -607,10 +589,8 @@ long kvmppc_rm_h_put_tce_indirect(struct kvm_vcpu *vcpu,iommu_tce_kill_rm (stit->tbl, entry, npages); unlock_exit: -if (rmap) -unlock_rmap (rmap); - -arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock); +if (!prereg) +arch_spin_unlock (&kvm->mmu_lock.rlock.raw_lock);return ret; }
Signature · 1 line
2.25.3
PATCH v3 17/22 powerpc/kvm/book3s: use find_kvm_host_pte in kvmppc_book3s_instantiate_page
In reply to Aneesh Kumar K.V--- arch/powerpc/kvm/book3s_64_mmu_radix.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/powerpc/kvm/book3s_64_mmu_radix.c +5 -5
@@ -813,20 +813,20 @@ int kvmppc_book3s_instantiate_page(struct kvm_vcpu *vcpu,* Read the PTE from the process' radix tree and use that * so we get the shift and attribute bits. */ -local_irq_disable (); - ptep =__find_linux_pte (vcpu->arch.pgdir, hva,NULL , &shift); +spin_lock (&kvm->mmu_lock); + ptep =find_kvm_host_pte (kvm, mmu_seq, hva, &shift);/* * If the PTE disappeared temporarily due to a THP * collapse, just return and let the guest try again. */ if (!ptep) { -local_irq_enable (); +spin_unlock (&kvm->mmu_lock);if (page)put_page (page);return RESUME_GUEST ; } - pte = *ptep; -local_irq_enable (); + pte =READ_ONCE (*ptep); +spin_unlock (&kvm->mmu_lock);/* If we're logging dirty pages, always map single pages */ large_enable = !(memslot->flags &KVM_MEM_LOG_DIRTY_PAGES );
Signature · 1 line
2.25.3
PATCH v3 18/22 powerpc/kvm/book3s: Use find_kvm_host_pte in kvmppc_get_hpa
In reply to Aneesh Kumar K.V--- arch/powerpc/kvm/book3s_hv_rm_mmu.c | 32 ++++++++++------------------- 1 file changed, 11 insertions(+), 21 deletions(-)
arch/powerpc/kvm/book3s_hv_rm_mmu.c +11 -21
@@ -878,8 +878,8 @@ long kvmppc_h_clear_mod(struct kvm_vcpu *vcpu, unsigned long flags,return ret; } -static int kvmppc_get_hpa (struct kvm_vcpu *vcpu,unsigned long gpa, -int writing,unsigned long *hpa, +static int kvmppc_get_hpa (struct kvm_vcpu *vcpu,unsigned long mmu_seq, +unsigned long gpa,int writing,unsigned long *hpa,struct kvm_memory_slot **memslot_p) {struct kvm *kvm = vcpu->kvm;
@@ -898,7 +898,7 @@ static int kvmppc_get_hpa(struct kvm_vcpu *vcpu, unsigned long gpa, hva =__gfn_to_hva_memslot (memslot, gfn);/* Try to find the host pte for that virtual address */ - ptep =__find_linux_pte (vcpu->arch.pgdir, hva,NULL , &shift); + ptep =find_kvm_host_pte (kvm, mmu_seq, hva, &shift);if (!ptep)return H_TOO_HARD ; pte =kvmppc_read_update_linux_pte (ptep, writing);
@@ -933,16 +933,11 @@ static long kvmppc_do_h_page_init_zero(struct kvm_vcpu *vcpu, mmu_seq = kvm->mmu_notifier_seq;smp_rmb (); - ret =kvmppc_get_hpa (vcpu, dest,1 , &pa, &memslot); -if (ret !=H_SUCCESS ) -return ret; - -/* Check if we've been invalidated */ arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock); -if (mmu_notifier_retry (kvm, mmu_seq)) { - ret =H_TOO_HARD ; + + ret =kvmppc_get_hpa (vcpu, mmu_seq, dest,1 , &pa, &memslot); +if (ret !=H_SUCCESS ) goto out_unlock; - }/* Zero the page */ for (i =0 ; i <SZ_4K ; i +=L1_CACHE_BYTES , pa +=L1_CACHE_BYTES )
@@ -966,19 +961,14 @@ static long kvmppc_do_h_page_init_copy(struct kvm_vcpu *vcpu, mmu_seq = kvm->mmu_notifier_seq;smp_rmb (); - ret =kvmppc_get_hpa (vcpu, dest,1 , &dest_pa, &dest_memslot); -if (ret !=H_SUCCESS ) -return ret; - ret =kvmppc_get_hpa (vcpu, src,0 , &src_pa,NULL ); +arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock); + ret =kvmppc_get_hpa (vcpu, mmu_seq, dest,1 , &dest_pa, &dest_memslot);if (ret !=H_SUCCESS ) -return ret; + goto out_unlock; -/* Check if we've been invalidated */ -arch_spin_lock (&kvm->mmu_lock.rlock.raw_lock); -if (mmu_notifier_retry (kvm, mmu_seq)) { - ret =H_TOO_HARD ; + ret =kvmppc_get_hpa (vcpu, mmu_seq, src,0 , &src_pa,NULL ); +if (ret !=H_SUCCESS ) goto out_unlock; - }/* Copy the page */ memcpy ((void *)dest_pa, (void *)src_pa,SZ_4K );
Signature · 1 line
2.25.3
PATCH v3 19/22 powerpc/kvm/book3s: Use pte_present instead of opencoding _PAGE_PRESENT check
In reply to Aneesh Kumar K.VThis adds _PAGE_PTE check and makes sure we validate the pte value returned via find_kvm_host_pte.
NOTE: this also considers _PAGE_INVALID to the software valid bit.
--- arch/powerpc/include/asm/kvm_book3s_64.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/powerpc/include/asm/kvm_book3s_64.h +1 -1
@@ -435,7 +435,7 @@ static inline pte_t kvmppc_read_update_linux_pte(pte_t *ptep, int writing)continue ; }/* If pte is not present return None */ -if (unlikely (!(pte_val (old_pte) & _PAGE_PRESENT))) +if (unlikely (!pte_present (old_pte)))return __pte (0 ); new_pte =pte_mkyoung (old_pte);
Signature · 1 line
2.25.3
PATCH v3 20/22 powerpc/mm/book3s64: Avoid sending IPI on clearing PMD
In reply to Aneesh Kumar K.VNow that all the lockless page table walk is careful w.r.t the PTE
address returned, we can now revert
commit: 13bd817bb884 ("powerpc/thp: Serialize pmd clear against a linux page table walk.")
We also drop the equivalent IPI from other pte updates routines. We still keep IPI in hash pmdp collapse and that is to take care of parallel hash page table insert. The radix pmdp collapse flush can possibly be removed once I am sure generic code doesn't have the any expectations around parallel gup walk.
This speeds up Qemu guest RAM del/unplug time as below
128 core, 496GB guest:
Without patch:
munmap start: timer = 13162 ms, PID=7684
munmap finish: timer = 95312 ms, PID=7684 - delta = 82150 ms
With patch:
munmap start: timer = 196449 ms, PID=6681
munmap finish: timer = 196488 ms, PID=6681 - delta = 39ms
--- arch/powerpc/mm/book3s64/hash_pgtable.c | 11 ----------- arch/powerpc/mm/book3s64/pgtable.c | 8 -------- arch/powerpc/mm/book3s64/radix_pgtable.c | 19 +++++++------------ 3 files changed, 7 insertions(+), 31 deletions(-)
arch/powerpc/mm/book3s64/hash_pgtable.c +0 -11
@@ -363,17 +363,6 @@ pmd_t hash__pmdp_huge_get_and_clear(struct mm_struct *mm,* hash fault look at them. */ memset (pgtable,0 ,PTE_FRAG_SIZE ); -/* -* Serialize against find_current_mm_pte variants which does lock-less -* lookup in page tables with local interrupts disabled. For huge pages -* it casts pmd_t to pte_t. Since format of pte_t is different from -* pmd_t we want to prevent transit from pmd pointing to page table -* to pmd pointing to huge page (and back) while interrupts are disabled. -* We clear pmd to possibly replace it with page table pointer in -* different code paths. So make sure we wait for the parallel -* find_curren_mm_pte to finish. -*/ -serialize_against_pte_lookup (mm);return old_pmd; }
arch/powerpc/mm/book3s64/pgtable.c +0 -8
@@ -109,14 +109,6 @@ pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address, old_pmd =pmd_hugepage_update (vma->vm_mm, address, pmdp, _PAGE_PRESENT, _PAGE_INVALID);flush_pmd_tlb_range (vma, address, address +HPAGE_PMD_SIZE ); -/* -* This ensures that generic code that rely on IRQ disabling -* to prevent a parallel THP split work as expected. -* -* Marking the entry with _PAGE_INVALID && ~_PAGE_PRESENT requires -* a special case check in pmd_access_permitted. -*/ -serialize_against_pte_lookup (vma->vm_mm);return __pmd (old_pmd); }
arch/powerpc/mm/book3s64/radix_pgtable.c +7 -12
@@ -962,7 +962,13 @@ pmd_t radix__pmdp_collapse_flush(struct vm_area_struct *vma, unsigned long addre pmd = *pmdp;pmd_clear (pmdp); -/*FIXME!! Verify whether we need this kick below */ +/* +* pmdp collapse_flush need to ensure that there are no parallel gup +* walk after this call. This is needed so that we can have stable +* page ref count when collapsing a page. We don't allow a collapse page +* if we have gup taken on the page. We can ensure that by sending IPI +* because gup walk happens with IRQ disabled. +*/ serialize_against_pte_lookup (vma->vm_mm);radix__flush_tlb_collapsed_pmd (vma->vm_mm, address);
@@ -1023,17 +1029,6 @@ pmd_t radix__pmdp_huge_get_and_clear(struct mm_struct *mm, old =radix__pmd_hugepage_update (mm, addr, pmdp, ~0UL ,0 ); old_pmd =__pmd (old); -/* -* Serialize against find_current_mm_pte which does lock-less -* lookup in page tables with local interrupts disabled. For huge pages -* it casts pmd_t to pte_t. Since format of pte_t is different from -* pmd_t we want to prevent transit from pmd pointing to page table -* to pmd pointing to huge page (and back) while interrupts are disabled. -* We clear pmd to possibly replace it with page table pointer in -* different code paths. So make sure we wait for the parallel -* find_current_mm_pte to finish. -*/ -serialize_against_pte_lookup (mm);return old_pmd; }
Signature · 1 line
2.25.3
PATCH v3 21/22 mm: change pmdp_huge_get_and_clear_full take vm_area_struct as arg
In reply to Aneesh Kumar K.VWe will use this in later patch to do tlb flush when clearing pmd entries.
--- arch/s390/include/asm/pgtable.h | 4 ++-- include/asm-generic/pgtable.h | 4 ++-- mm/huge_memory.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
arch/s390/include/asm/pgtable.h +2 -2
@@ -1560,7 +1560,7 @@ static inline pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm, }#define __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULL -static inline pmd_t pmdp_huge_get_and_clear_full (struct mm_struct *mm, +static inline pmd_t pmdp_huge_get_and_clear_full (struct vm_area_struct *vma,unsigned long addr,pmd_t *pmdp,int full) {
@@ -1569,7 +1569,7 @@ static inline pmd_t pmdp_huge_get_and_clear_full(struct mm_struct *mm, *pmdp =__pmd (_SEGMENT_ENTRY_EMPTY);return pmd; } -return pmdp_xchg_lazy (mm, addr, pmdp,__pmd (_SEGMENT_ENTRY_EMPTY)); +return pmdp_xchg_lazy (vma->vm_mm, addr, pmdp,__pmd (_SEGMENT_ENTRY_EMPTY)); }#define __HAVE_ARCH_PMDP_HUGE_CLEAR_FLUSH
include/asm-generic/pgtable.h +2 -2
@@ -159,11 +159,11 @@ static inline pud_t pudp_huge_get_and_clear(struct mm_struct *mm,#ifdef CONFIG_TRANSPARENT_HUGEPAGE #ifndef __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULL -static inline pmd_t pmdp_huge_get_and_clear_full (struct mm_struct *mm, +static inline pmd_t pmdp_huge_get_and_clear_full (struct vm_area_struct *vma,unsigned long address,pmd_t *pmdp,int full) { -return pmdp_huge_get_and_clear (mm, address, pmdp); +return pmdp_huge_get_and_clear (vma->vm_mm, address, pmdp); }#endif
mm/huge_memory.c +2 -2
@@ -1852,8 +1852,8 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,* pgtable_trans_huge_withdraw after finishing pmdp related * operations. */ - orig_pmd =pmdp_huge_get_and_clear_full (tlb->mm, addr, pmd, - tlb->fullmm); + orig_pmd =pmdp_huge_get_and_clear_full (vma, addr, pmd, + tlb->fullmm);tlb_remove_pmd_tlb_entry (tlb, pmd, addr);if (vma_is_special_huge (vma)) {if (arch_needs_pgtable_deposit ())
Signature · 1 line
2.25.3
PATCH v3 22/22 powerpc/mm/book3s64: Fix MADV_DONTNEED and parallel page fault race
In reply to Aneesh Kumar K.VMADV_DONTNEED holds mmap_sem in read mode and that implies a parallel page fault is possible and the kernel can end up with a level 1 PTE entry (THP entry) converted to a level 0 PTE entry without flushing the THP TLB entry.
Most architectures including POWER have issues with kernel instantiating a level 0 PTE entry while holding level 1 TLB entries.
The code sequence I am looking at is
down_read(mmap_sem) down_read(mmap_sem)
zap_pmd_range()
zap_huge_pmd()
pmd lock held
pmd_cleared
table details added to mmu_gather
pmd_unlock()
insert a level 0 PTE entry()
tlb_finish_mmu().
Fix this by forcing a tlb flush before releasing pmd lock if this is not a fullmm invalidate. We can safely skip this invalidate for task exit case (fullmm invalidate) because in that case we are sure there can be no parallel fault handlers.
This do change the Qemu guest RAM del/unplug time as below
128 core, 496GB guest:
Without patch:
munmap start: timer = 196449 ms, PID=6681
munmap finish: timer = 196488 ms, PID=6681 - delta = 39ms
With patch:
munmap start: timer = 196345 ms, PID=6879
munmap finish: timer = 196714 ms, PID=6879 - delta = 369ms
--- arch/powerpc/include/asm/book3s/64/pgtable.h | 5 +++++ arch/powerpc/mm/book3s64/pgtable.c | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+)
arch/powerpc/include/asm/book3s/64/pgtable.h +5 -0
@@ -1265,6 +1265,11 @@ static inline pmd_t pmdp_collapse_flush(struct vm_area_struct *vma, }#define pmdp_collapse_flush pmdp_collapse_flush +#define __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR_FULL +pmd_t pmdp_huge_get_and_clear_full (struct vm_area_struct *vma, +unsigned long addr, +pmd_t *pmdp,int full); +#define __HAVE_ARCH_PGTABLE_DEPOSITstatic inline void pgtable_trans_huge_deposit (struct mm_struct *mm,pmd_t *pmdp,pgtable_t pgtable)
arch/powerpc/mm/book3s64/pgtable.c +18 -0
@@ -112,6 +112,24 @@ pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,return __pmd (old_pmd); } +pmd_t pmdp_huge_get_and_clear_full (struct vm_area_struct *vma, +unsigned long addr,pmd_t *pmdp,int full) +{ +pmd_t pmd; +VM_BUG_ON (addr & ~HPAGE_PMD_MASK ); +VM_BUG_ON ((pmd_present (*pmdp) && !pmd_trans_huge (*pmdp) && + !pmd_devmap (*pmdp)) || !pmd_present (*pmdp)); + pmd =pmdp_huge_get_and_clear (vma->vm_mm, addr, pmdp); +/* +* if it not a fullmm flush, then we can possibly end up converting +* this PMD pte entry to a regular level 0 PTE by a parallel page fault. +* Make sure we flush the tlb in this case. +*/ +if (!full) +flush_pmd_tlb_range (vma, addr, addr +HPAGE_PMD_SIZE ); +return pmd; +} +static pmd_t pmd_set_protbits (pmd_t pmd,pgprot_t pgprot) {return __pmd (pmd_val (pmd) |pgprot_val (pgprot));
Signature · 1 line
2.25.3